# Herdr Goal > Use when the user invokes /herdr-goal with a large multi-part objective inside a Herdr session (HERDR_ENV=1) and wants it split across parallel lead agents. Not for single tasks one agent can do directly, and not outside Herdr. - Skill: `ralphcrisostomo/herdr-goal` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add ralphcrisostomo/herdr-goal` - Raw SKILL.md: https://api.skillmd.com/api/skills/ralphcrisostomo/herdr-goal/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - Author: ralphcrisostomo (https://skillmd.com/u/ralphcrisostomo) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/ralphcrisostomo/herdr-goal --- # Herdr Orchestrator (/herdr-goal) ## Overview You are the orchestrator. You NEVER implement: no file edits, no project commands, no "quick fixes". You decompose the goal, delegate every workstream to a lead agent in its own Herdr pane and git worktree, keep them moving until everything is done, then report. **REQUIRED SUB-SKILL:** Invoke the `herdr` skill FIRST. It is the authority on CLI syntax, IDs, agent status semantics (`idle`/`done` both mean completed), and safety rules. Everything below assumes it. Precondition: `test "${HERDR_ENV:-}" = 1` — if it fails, say so and stop. ## Workflow ### 1. Decompose - If the goal is vague or has open design decisions, invoke `superpowers:brainstorming` with the user before spawning anything. - Split into independent workstreams — no two leads touching the same files. Run at most 3 leads concurrently; queue the rest. **"Continue the lead you already have" is a real entry point — don't decompose, inherit.** When the user points you at an existing managed lead (a workspace this or a prior session spawned), skip spawning: find its workspace (`herdr worktree list`, `herdr pane list --workspace `), and reconstruct state from artifacts before sending anything — its branch position (`git log`), its merge-base vs current `main`, and its uncommitted tree. Two things bite here specifically. First, an inherited lead's branch was very likely cut from an OLD `main`: check `git log --oneline ..main` and, if the base has moved, the first instruction is "rebase, then re-validate," because any plan or spec it already wrote encodes assumptions about a `main` that no longer exists (in one run a written-but-unimplemented edit-mutations plan was stale in three specific ways — an index assumption that had since become a real bug, a "no pipeline resolvers exist" claim, and a whole feature the plan predated). Second, its worktree may hold uncommitted work; triage it before doing anything else and classify each file (real content vs `bun run format` churn) — but state your classification as provisional and tell the lead to verify, because you are reading a tree you did not build. In one run the orchestrator wrongly tagged a 130-line diff as foreign work to preserve; it was the lead's own format churn, and the lead was right to check rather than obey. **Split by LAYER, not by feature.** Two features that each need a schema change, a data-access change, and a UI change will collide on every shared file if you give one feature to each lead. Give one lead the whole data plane (schema, migrations, infra, server-side code) and another the whole client (types, mocks, components, pages) — *both* features each — and the file sets are naturally disjoint. Verify it rather than assuming: after the leads finish, `comm -12` their `git diff --name-only` lists should be empty. **The layer split makes the client DEPEND on the data plane, so sequence it — don't just brief "build against the mock."** In a mock/live-composable architecture the mock the client renders against lives in the *server* lead's files (composables/types/seed). At spawn both branches sit at the same base, so those methods/types do not exist in the client's worktree yet, and the client cannot edit server-owned files to stub them — a client told to "run against the mock" will (correctly) block on the first turn. Handle it up front: tell the client lead to split its own work into **seam-free** (buildable now with no server contract — e.g. a self-contained component refresh, a hidden form field) and **seam-heavy** (calls methods/fields the server owns), do the seam-free slice first, then STOP. Meanwhile have the server lead commit its **mock methods + type fields as an early foundational checkpoint** (before its live branches + infra). Then — this is the payoff of the disjoint split — `git merge ` into the client branch is CONFLICT-FREE (the file sets don't overlap), so you hand the client a real contract to build the seam-heavy slice against with full typecheck + runnable verification, without serializing the whole run. Do NOT let the client shim the missing types into its own files: two independent declarations of the same type collide at the final merge. Idle time on the client while it waits for the foundation costs nothing (an idle agent burns no tokens) — a clean single merge beats piecemeal merges the later work then invalidates. **A worktree is per-repo, so a workstream cannot span two repos.** If the layer split puts infra in repo A and a consumer in repo B, that is two leads, not one — there is no single checkout that holds both. Split again along the repo boundary and let the contract carry the agreement across it. Give leads the absolute path to the *main checkout* of any repo they must read but do not own; their worktree does not contain it. **Audit the primary checkout's working tree before writing the contract.** Leads branch from a COMMIT; anything applied-but-uncommitted in the main checkout is invisible to every lead. In one run an owner-decided change (password minimum) had been applied to the live environment from an uncommitted working-tree edit — both leads branched from a main that contradicted live, and a fresh env came up wrong until the orchestrator found the dirty file mid-run. `git status` the primary checkout first: commit (stage by name) what belongs to the goal area, classify the rest as foreign work to leave untouched, and name both in the contract. **Re-check it again immediately before merging — foreign dirt APPEARS mid-run and blocks the merge.** A clean audit at spawn time says nothing about the tree an hour later. In one run the primary checkout was clean at spawn and, at merge time, held 16 modified files plus an untracked module (~258 lines) from another session's in-flight feature — two of them files a lead owned. `git merge` refused outright ("Please commit your changes or stash them before you merge. Aborting"). **Do NOT stash or commit another session's work to clear the path**, and do not `git checkout --` it: that is someone's uncommitted hours. Report the blocker to the owner with the exact colliding paths (`comm -12` the dirty list against each lead's file list) and offer merging into your integration branch instead. Often the right move is to wait a beat and re-check — in that run the other session committed to its own branch within minutes and the block cleared itself with nothing touched. Identify the owning session before escalating (`herdr workspace list`, then `pane read` the candidates); the pane's status bar names its branch and worktree. **Exception — an uncommitted file the leads only READ should not be committed.** When the goal IS an owner's in-progress edit to a source of truth the leads consume but never modify (a design export, a spec doc, a scraped fixture), committing it publishes a mid-edit file that is not yours. Instead give the brief the **absolute path to that file in the primary checkout**, state that the worktree's own copy is STALE and must be ignored, and forbid the lead from editing it in either location ("if `git status` in your worktree shows a change under `design/`, you went wrong — revert it"). This is strictly better than the commit for read-only inputs: the lead reads the live truth, the owner keeps their uncommitted edit, and nothing of theirs lands in your branch. **Write the contract before spawning, as a file both leads read.** Leads that never see each other's code agree only on what you wrote down. Put it in your scratchpad and give every brief its absolute path: - the exact wire shapes (field names, types, null vs absent, ordering and limit guarantees) - what is deliberately NOT on the wire, and what derives it instead - the file-ownership table, stated as exclusive - decisions the owner already made, marked "do not re-open" — both leads will otherwise hit their own brainstorm gates and block on the same questions - the load-bearing conventions of this repo that a fresh agent cannot infer **The contract is your deliverable, and its gaps are your bugs.** When a review later finds "both halves implemented this correctly but the result is still wrong", that is a contract defect, not a lead defect. Escalate it to the owner as a decision; do not hand it to a lead as a fix request. Expect several. In one run the leads and reviewers found six, every one traceable to the contract rather than to a lead: - an action specified in two sections with **no operation defined anywhere** — both leads flagged the same hole independently - a **limit specified in isolation from the safety pass it interacts with** — the cap dropped item #7 from storage, and the redaction pass only redacted what it stored, so the cap silently defeated the gate - a term that was simultaneously "not a X" in one clause and "a X that must not leak" in another - an equivalence stated without saying **which path it governs**: "absent and empty are the same" was true on the read path and false on the write path, where a missing parent map failed the whole transaction. Nearly half of one writer's rows were affected. When a contract asserts two things are interchangeable, name the direction — read, write, or both - a **value class widened on one side** by a later amendment while the consumer's parsing rule was never updated - a verification clause loose enough to permit a test that derives its expectation from the function under test (see §11 guidance in step 4) Write the contract expecting this, and re-read it for these shapes before spawning: every limit against every pass it feeds, every equivalence against every path, every value class against every consumer. **A contract decision that rests on a fact about live data must be MEASURED against live data before you write it, not reasoned from the schema.** In one run the contract ruled a whole remedy out of scope ("rows without this timestamp have no recoverable time, so the fallback is permanent by design") — every lead implemented that faithfully, every gate passed, and the shipped result fixed a minority of the rows the owner cared about, because the truthful timestamp was sitting on a sibling field the read path simply never projected. The leads could not have caught it: the defect was in the premise, not the code. One read-only query before spawning would have. The mirror-image error is sizing that measurement off *stored* data when a read-time filter decides what renders. Counting rows in the stored list gave "11 rows affected"; the list is append-only and the read path drops soft-deleted entries, so exactly **1** was visible. The fix was right and the number was inflated 11x — a number you put in front of the owner to justify scope. Measure what actually reaches the screen: apply the same filters the read path applies, then count. ### 2. Spawn one lead per workstream Check every target repo is a Git repo before spawning — `worktree create` needs one. If a repo is uninitialized, `git init` it, confirm what belongs in `.gitignore` (generated output, scraped data, `node_modules`), and make an initial commit; that commit is the pre-work SHA for the review gate. Tell the user before initializing. A worktree checkout excludes gitignored paths, so a lead gets no `node_modules` and no generated data. Put the install command and the absolute path to any generated fixtures in the main checkout into the brief. Discover current syntax with `herdr worktree` (bare group prints usage; never probe `worktree create` with no args — it executes). If the printed usage differs from the commands below, the printed usage wins. Then: **Always pass `--cwd ` to every `worktree` command, including `list`.** Without it, `worktree list` resolves against the UI-FOCUSED pane's repo, not your own — so in a multi-repo session it silently reports a sibling project's worktrees as if they were yours. In one run a bare `worktree list` returned two `herd/*` worktrees belonging to another repo entirely; reading those as pre-existing leads of your own would send you inheriting work that is not there. Re-run with `--cwd` and compare `result.source.repo_name` against the repo you actually mean before believing any listing. ```bash herdr worktree create --cwd --branch herd/ --label "" --no-focus --json ``` Parse the returned workspace and pane IDs from the JSON — never construct them. Note `pane split` and `pane get` take no `--json` flag (unlike `worktree create`) and error if given one; both print JSON regardless. A poller that pipes `pane get --json` into a parser silently yields nothing and every lead reads as dead — drop the flag. If the workstream must land on a branch already checked out elsewhere (e.g. merging finished work into `main` from the primary checkout) — `worktree create` fails, git refuses a second checkout of the same branch — skip it and split a sibling pane in your own workspace instead: `herdr pane split --current --direction right --no-focus`, same cwd as the branch's existing checkout. This lead has no linked workspace; step 4 cleans it up differently. **Pick each lead's model by workstream complexity** — don't run every lead on the most expensive tier: | Workstream | Launch with | |---|---| | Mechanical: renames, boilerplate, config edits, running known scripts | `claude --model haiku --dangerously-skip-permissions` | | Standard well-specified dev work: features, tests, straightforward refactors | `claude --model sonnet --dangerously-skip-permissions` | | Complex: hard debugging, architecture, ambiguous spec, cross-cutting changes | `claude --model opus --dangerously-skip-permissions` | When unsure between two tiers, take the higher one — a wrong answer costs more than the tier gap. State each lead's model in your tracking list. In the returned pane: ```bash herdr pane run "claude --model --dangerously-skip-permissions" herdr wait agent-status --status idle --timeout 60000 herdr pane run "" herdr wait agent-status --status working --timeout 30000 ``` **Task brief must contain:** - Objective and acceptance criteria for this workstream only - "Work only in this worktree. Commit all work on this branch when done." - Skills/tools to lean on: `superpowers:brainstorming`, `superpowers:systematic-debugging`, `superpowers:test-driven-development`, context7 for library docs, rtk-prefixed commands - "Finish with a summary: what changed, how it was verified, branch name, anything unresolved." **Write the brief to a file in the lead's worktree and point `pane run` at it.** Anything long enough to be a complete spec is long enough to be swallowed as an attachment (see step 3), and flattening it to one `;`-separated line costs the structure the lead needs. Write `BRIEF.md` into the worktree root, then send a short `pane run` that says to read it, states the objective in one sentence, and tells the lead to delete the file before its final commit. The same trick carries review findings back in later rounds — per-item file:line detail does not survive being flattened into a single argument. Follow-up `pane run` messages pass through the shell: backticks inside the message get command-substituted (a `` `arguments` `` fragment executed and vanished from the delivered text mid-run). Strip backticks/`$( )` from any inline follow-up, and read the pane's echoed `❯` line after sending to confirm what actually landed. **Never echo secrets out of a pane.** Leads routinely touch `.env` files, terraform outputs, and cookie jars — a `pane read` can surface an API key, and anything you quote back lands in your own transcript and the user's scrollback. Point a lead at a credentials *path* rather than a value, and when reporting, name the file or say the variable is present; never print the value. If you must confirm a credential, confirm it is non-empty, not what it is. **Token hygiene:** a lead starts with empty context — the brief is its entire task spec, so make it complete up front (acceptance criteria, constraints, file hints); a well-specified first turn beats drip-feeding follow-ups. On your side, keep pane reads bounded (`--lines 120`–`200`, never unbounded scrollback) — you only need status and summaries, not lead transcripts, in your own context. ### 3. Monitor until done Track your leads in a list (pane ID, workspace ID, workstream, last status). A lead is **completed** only when its status is `done`, or `idle` AFTER you have seen it `working` — a boot-time `idle` is not completion. And even a real `done` can be a MID-TASK pause: a lead that backgrounds a long shell (a 15-min `terraform apply`) goes `done` while the work still runs, then resumes on its own task notification. Before treating `done` as complete, read the pane — a status bar showing `1 shell still running` or a summary saying "waiting for the background task" means keep polling for the next `working`→`done` cycle, not hand off. A lead can also go `done` having simply ENDED ITS TURN mid-plan, with no background shell and no limit halt: in one run a lead reported `done` with 3 of its 6 todo items still open, four modified files uncommitted, and a scratch `_keytest.spec.ts` sitting in the tree. So on EVERY completion read the pane's todo list and run `git status` in the worktree before believing it — open items or a dirty tree mean resume with a numbered list of the gaps, not hand off. Round-robin with short waits so one slow lead never starves a blocked one: ```bash herdr pane get # per lead, in rotation — the reliable check herdr wait agent-status --status done --timeout 120000 # only to block until the NEXT transition ``` **Poll with `pane get`, not `wait --status done`.** `done` and `idle` are one state differing only in whether the result has been seen, and a lead that completes while you are looking at its tab lands on `idle` directly — so a `wait` for `done` blocks until timeout on an agent that already finished. Treat `idle`-after-`working` and `done` identically as completed. Keep polling in rotation until every lead is complete; never end the turn with leads still running and hand monitoring back to the user. Also do NOT wait on a lead's completion phrase with `wait output --match ""` when that phrase appears in the brief you sent (e.g. "FOUNDATION READY") — it false-matches the brief's own echo in the transcript and returns instantly. Detect a lead's milestone by status transition (`pane get`) plus a direct artifact read (`git log --oneline ..` for the expected commit), not by output-matching a string you yourself wrote into the pane. And `herdr pane read` prints framing around its JSON — piping it into a strict JSON parser fails with "Extra data"; read it as raw text (`tail`) instead. - Completed (per rule above) → go to step 4. - `blocked` → `pane read --source recent-unwrapped --lines 120`, answer via `pane run`. Escalate to the user only for decisions a lead can't make (scope changes, destructive actions). A blocked lead jumps the rotation — answer it before any completion cleanup, and confirm it returns to `working` afterward. - **A usage-limit halt looks exactly like completion and is not.** A lead can hit the account's usage cap mid-task and go `blocked` on a two-option menu: "Stop and wait for limit to reset" / "Add funds to continue with usage credits". A fully EXHAUSTED weekly limit presents differently and more quietly: no menu at all, just a line like "You've hit your weekly limit · resets " and the pane goes straight to `done` with the work half-written and UNCOMMITTED. There is nothing to answer and nothing to resume until the reset, so your job is preservation: commit the lead's uncommitted tree on its own branch yourself (stage by name, exclude `BRIEF.md`) with a message that says plainly it is unverified and lists what never ran. An uncommitted worktree is one stray `git checkout` from gone, and a WIP commit on a side branch risks nothing. Then write a resume doc onto that branch — branch state, the defects you found auditing it, and the resume order — and copy any scratchpad contract in beside it, because the scratchpad does not survive the session. **Label every audit finding in that doc as UNVERIFIED unless you actually verified it, because a confidently-worded handoff sends the resume straight at whatever it names.** In one run the orchestrator's audit led with "four `for...of` loops that will half-apply at `CreateFunction`" — wrong: the lint rule rejects C-style `for(;;)`/`while` only, seven already-DEPLOYED resolvers used the identical `for...of` form, and the real platform validator accepted all four units. The lead nearly rewrote four working files on the strength of it. The cheap check that settles this class in a minute: grep for the construct in code that is already shipped and running, and run the platform's own validator. Shipped code using the construct is proof the construct is legal. Your grep-and-reason audit is a hypothesis; the deployed artifact and the real validator are the evidence. Always take the wait option (`send-keys Enter` while it is the highlighted row) — **spending the user's money is never yours to authorize**, and escalate the funds decision to them. **Audit the lead's committed state BEFORE you escalate and attach the result to the question** — the owner's spend decision turns on whether work is at risk, and you cannot say. In one run the lead's fix was already committed with a clean tree, so "wait" cost only an unfinished re-review and nothing was lost; presenting that made the choice trivial instead of anxious. Critically, once that menu is dismissed the pane reports `done` while the work is half-finished: in one run the lead had written 150 lines across 7 files, committed **nothing**, left a `console.log('[DIAG] …')` in a component, and never touched one of the files its brief named. So after any limit halt, audit the worktree yourself (`git log ..` empty? `git status` dirty? `git grep` for debug leftovers?) and resume with an **explicit numbered list of the gaps you found** — the lead lost its plan with its turn, and a bare "continue" makes it re-derive one. - **A transient API error also presents as `done`, and is the cheapest of all these to fix.** A lead can die mid-response on `API Error: Connection closed mid-response` — the pane goes `done` with an empty commit range, which reads exactly like a lead that refused the work or halted on a limit. The tell is that its context is INTACT (low context %, its earlier turns still in the transcript) and there is no limit banner and no menu. Recovery is a plain `pane run` that says the cut-off was transient, states that nothing is committed, and names the step it was on — it resumes in the same session with full context and loses only the interrupted turn. Observed 2026-07-26: a lead died four minutes in, having read its brief and contract and about to write its first test, and picked up exactly there. Do NOT re-brief from scratch and do not spawn a replacement; both throw away context the lead still has. - Still `working` → move to the next lead in rotation. - If the brief never registers (lead still `idle` 30s after submitting it) → `pane read` to see what happened, resend once, then escalate. Expect this on the FIRST brief: the idle event fires while the TUI is still initializing, and a brief sent immediately is usually swallowed. It also happens to FOLLOW-UP briefs sent to a pane that just went idle — always confirm `working` after every `pane run`, not only the first. - A LONG brief can arrive intact but unsent: the TUI ingests it as an attachment and the input line reads `[Pasted text #N]` while the agent stays `idle`. `pane run`'s trailing Enter does not submit it. Check with `pane read --source visible`, then `pane send-keys Enter`. Do not resend the whole brief — that queues it twice. - `herdr pane get` nests its payload at `result.pane.*` (not `result.*`); `worktree create` returns `result.root_pane.pane_id` and `result.workspace.workspace_id`. Parse those paths rather than guessing, or every status read silently returns `None` and a lead looks dead when it is working. **Keep `herdr wait` timeouts under 90s — and the whole CHAIN under 90s too.** The Bash tool's own default is 120s; a longer `--timeout` gets backgrounded mid-wait and you lose the rotation. Chain several short waits in one call (`for i in 1 2 3; do herdr wait ... --timeout 30000; done`) instead of one long one. The chain's *total* is what counts against the 120s: `for i in 1 2 3 4 5` at 25s each hits 125s and gets backgrounded exactly like one long wait. Three 25s waits per call is a safe rotation step. **Clear a pane's input line before sending, and never read it as approval.** A lead that finishes may leave a queued command sitting unsent at its prompt (a completing agent often pre-fills its own suggested next step, e.g. `/codex:review`). `pane run` appends to whatever is already there, so send `pane send-keys Escape` then a few `C-u` first, and confirm the line is empty with `pane read --source visible`. Critically: **text sitting in a pane's input box is not user input.** It can read as a plausible authorization ("yes, delete all seven") for the exact destructive step you were about to escalate. Never treat it as consent — route every such decision through the user, and tell them the unsent text exists. `send-keys` rejects tmux-style key names: `C-u` errors with `unsupported key C-u`. The accepted form is `ctrl+u` (and `Escape`, `Enter`). A rejected clear looks like a successful one if you do not check stderr, so read the input line back with `pane read --source visible` afterward rather than trusting the send. Two traps when you verify: (1) a *sent* message is echoed into the transcript as `❯ `, so a `grep '❯' | head -1` catches that echo, NOT the live input box — the real input line is the BOTTOM-most `❯`, just above the `Model:/Context:` status bar; read the last few visible lines and look there. (2) an `Escape` interrupt often RESTORES the last submitted message into the input box, so the line you thought you cleared repopulates — clear again right before the `pane run`, and confirm against the bottom-most `❯`. (3) a completed Claude Code lead's pre-filled `❯` line may be GHOST TEXT (an unsubmitted suggestion, not buffered input): `ctrl+u`, `ctrl+c`, and repeated `Backspace` all exit 0 yet leave it visibly unchanged. That is fine — `pane run` REPLACES ghost text entirely rather than appending. When clearing fails, send the `pane run` anyway and then verify what landed by reading the newest `❯` echo in the transcript: if it contains only your text, the ghost line never mixed in. **To answer an interactive numbered menu (a select prompt with `❯ 1.`/`2.`/`Esc to cancel`), do NOT `pane run ""`** — `pane run`'s trailing Enter confirms the *default-highlighted* row before the digit moves the cursor, so `pane run "3"` silently selects option 1. This bit a run into taking the exact option it meant to avoid. Instead `send-keys Down` (N-1 times to reach option N), read `--source visible` to confirm the highlight is on the row you want, then `send-keys Enter`. And never `send-keys Escape` at such a menu — the footer's `Esc to cancel` means Escape dismisses the whole prompt. **A lead can also block on a MULTI-question form, and answering one question jumps the cursor straight to Submit with the rest still unanswered.** It renders as a header of checkboxes (`← ☐ Posts: N ☐ Topic cap ✔ Submit →`) with `Tab/Arrow keys to navigate` in the footer. `Right`/`Left` move between questions; `Enter` selects the highlighted option for the CURRENT question, flips its box to `☒`, and lands you on `Submit`. Submitting there discards the unanswered ones, so: read every question first (arrow across, and read each one's options before deciding anything), put them ALL to the owner in one `AskUserQuestion`, then fill them one at a time, navigating BACK rather than accepting the jump to Submit, and confirm the header shows `☒` for every question before you press Enter on Submit. Verify afterwards by grepping the transcript for the `→ ` echo per question — one echo per question, or you submitted a partial form. **An MCP server can also block a lead with an elicitation prompt that has nothing to do with the work, and its highlight is invisible in plain text.** Observed live: `context7` interrupted a lead with "You're using Context7 anonymously… run `npx ctx7 setup`", rendered as a select row plus two buttons (`Accept Decline`). Two traps. First, `↑`/`↓` move between the select row and the button row while `←`/`→` move *between the buttons* — and **which button is highlighted does not show in `pane read` text at all**; only `pane read --source visible --format ansi` reveals it (the highlighted one is bold/coloured, e.g. `38;5;211`, the other dim `38;5;246`). Read the ANSI before pressing Enter rather than assuming the left button is selected. Second, do NOT reach for `Escape` here even though the footer offers `Esc to cancel`: Escape on a working Claude Code pane interrupts the agent's turn as well. Decline the sign-in (an interactive browser auth is not something a background lead can complete, and it is not yours to authorize), then confirm the pane returns to `working`. The lead loses only that one doc lookup. **A `pane run` sent while a lead is `working` is QUEUED, not lost.** The pane shows `Press up to edit queued messages` and the text lands as the lead's next turn. So a contract amendment or a correction can be delivered the moment you decide it, without waiting for `idle` — read the pane afterwards and confirm your text appears verbatim above the status bar. This is the cheap way to answer a lead that escalated something mid-round. One specific menu is recoverable in place: a lead that hits its provider's **usage-limit menu** ("Stop and wait for limit to reset" / "Add funds") mid-task. Confirm the safe default (`send-keys Enter` on the highlighted stop option — a spend option is the user's call, never yours), and if the user has since re-authenticated (`/login`), a plain `pane run "continue"` resumes the same session with full context — no restart, no re-brief. Observed live: the lead picked up mid-task and finished. Watch the pane's own limit banner (e.g. "96% of weekly limit") and surface it to the user before starting any large new workstream on that account; parking reviewed-but-unmerged work on its branch with a memory note beats racing the wall. **Check the remaining allowance BEFORE you spawn, not only mid-run** — a run launched near the wall does not degrade gracefully, it dies at the worst moment: in one run both leads halted within minutes of each other, one of them mid-verification with ~1100 lines uncommitted, and the SAME limit had already taken Codex out, so the review gate had no primary reviewer either. The cost of that is not just lost time; it is an unverified WIP that reads as finished work to whoever resumes. **A review that completes inside a halted lead is LOST, not stored.** In that run a lead's fallback reviewer finished (34 tool uses) and the lead hit the wall before summarising it — the findings were nowhere: collapsed in the pane transcript, absent from disk, unrecoverable. So instruct every lead to write review findings to a file in its worktree AS IT RECEIVES THEM, before acting on them, and to commit that file. Then a halt costs you the fixes, not the findings. **Give that file a per-lead name in the contract, or it is the one guaranteed merge conflict in an otherwise disjoint split.** Telling both leads to write `REVIEW-FINDINGS.md` puts the same path on both branches, so the file sets are no longer disjoint and the second merge hits an add/add conflict — over a docs file, after all the real work verified clean. Check the repo for an existing convention and match it (`REVIEW-FINDINGS-.md` beside whatever earlier sub-projects left behind), and state the exact filename per lead in the ownership table. It costs one line in the contract; discovering it at merge time costs a round-trip to each lead. Expect this after *most* completions, not as a rare event — one run hit it four times across three panes, and a single-lead run still hit it twice. Observed strings were `push it`, `merge it to main`, `re-run the seam review against the merged result`, and `report unresolved items and finish up`: every one an imperative naming exactly the step that was genuinely next, and two of them naming irreversible outward-facing actions. That is what makes them dangerous — they are not noise, they are plausible. Clear the line before every send, and when one names a destructive or outward-facing step, say so to the user explicitly rather than silently discarding it. The most convincing variant appears when the lead has just ASKED a question and gone `done`: the ghost line then reads as the answer to it (`yes, re-run round 3`, `send the survivors back to the lead to fix`, `show me the removeForumTopic diff` — all three in one run). Never let that stand as the owner's answer. If the step it names is one you would order anyway, order it yourself in your own words so the authority is yours; if it needs a decision, route the question to the user and tell them the unsent text exists. - A completed lead frees a concurrency slot for a queued workstream. ### 4. Complete a lead ```bash herdr pane read --source recent-unwrapped --lines 200 # capture the summary ``` **A substantial final summary does NOT survive the pane's scrollback — ask for it as a FILE.** `pane read` is capped by the terminal's own buffer, and a lead's report of any real length has already scrolled past it by the time you look: raising `--lines` to 600 returns the same 41 lines, and both `head` and `tail` of that window show the same truncated tail. This bit twice in one run — a seam review's findings S1–S4 and a whole verification section (test totals, validator results, mutation numbers) were simply gone. Do not try to reconstruct them and do not let the lead re-derive them: send one follow-up telling it to write the full report to a named path in your scratchpad, copying what it already established and re-running nothing, then Read that file. Build it into the brief's "done means" for any lead whose report you will actually need. **Distrust the shell before you distrust the lead.** In one run the token-proxy hook wrapping bash (`rtk`) returned *fabricated* file contents — a `cat -n` came back with lines rewritten and an invented `// MUTATION: ...` comment that did not exist on disk — and separately made `grep` silently drop matching lines, which made real mutation runs look like they produced no output. `git status` was clean throughout, so nothing flagged it. It corrupts git reads too, not just file reads: in another run a wrapped `git log --oneline main..` returned the branch's PRE-MERGE commits and silently omitted the merge commit that was actually at HEAD, which reads exactly like a lead that claimed a merge it never made. Read files with the Read tool, and put `rtk proxy` in front of EVERY load-bearing git read (`git log`, `git diff`, `git merge-base`, `git status`) as well as `cat`/`grep`/`git show`; never audit a lead's work through the plain wrapped forms. If you catch this, tell the lead too — its own review rounds were reading through the same proxy — and tell the user, because every other session in that repo is affected. The same proxy also **reformats `terraform plan` / `git diff` output and strips the leading `+`/`-`**, so a text-grep for `will be destroyed` or a `+ source_code_hash` line returns a FALSE EMPTY on a plan that really does contain them — which is the one assertion you least want wrong before an irreversible apply. Assert on `terraform show -json ` instead of grepping plan text, and treat any plan claim derived from a wrapped text grep as unproven. **When a lead must verify in a real browser, remember the Playwright MCP server is sandboxed to the repo root.** File uploads are rejected from anywhere else ("outside allowed roots"), so a fixture written to your scratchpad cannot be uploaded. Put such fixtures in a **gitignored** directory inside the repo (`.playwright-mcp/` already is one here — check with `git check-ignore -v`) so the tree stays clean and the deploy's clean-tree gate is not tripped, and delete them afterwards. Building the file in-page instead (a canvas → `toBlob` → `DataTransfer` → `input.files`) avoids the filesystem entirely and collapses a multi-call chooser dance into one `browser_evaluate`; note that a synthetic `input` event is enough for Vue's `v-model` on a native input, but some validated inputs still need real keystrokes (`browser_type`) before their submit button enables. **A completion signal is not a success signal.** The status goes to `done` whether the lead shipped the work, refused it, or shipped something that doesn't do what it claims. Its summary is a *claim*, not evidence — never relay one as fact you have checked. Verify against artifacts you read yourself: `git log`/`git diff --stat` for the commit, a clean `git status` for the tree, the test command's own output. A lead reporting "all tests pass" after running a wrapper that swallowed the real exit code is the same event as one that genuinely passed. **When two leads reach OPPOSITE conclusions about the same seam, the tie is yours to break by reading the code — do not average them and do not take the confident one.** In one run the client lead reported "no divergence, verified concretely" on the seam while the data-plane lead, running a differential harness that fed identical inputs through both implementations (one of them the resolver *fetched back from AWS*), produced a three-row table of inputs that yielded different results. The orchestrator read the twenty lines of client code and confirmed the second lead in one look: the field was set from the raw array length with no filter, while the resolver counted survivors after validating them. The pattern generalises — a lead reasoning from its own design intent ("correct by construction") loses to a lead holding execution evidence, and the reasoning lead's error is usually that it verified an ADJACENT claim (here: that the consumer read the field verbatim, which was true and irrelevant). Read the code, name which lead was wrong and why when you hand the fixes over, and give the fixes to whoever owns the files. Green tests prove even less than they look like they do when the lead wrote both the code and the fixtures: it will reach for input shapes its implementation already handles. Where the work has an external contract — a field another service reads, a data shape a scraper actually emits, a row another system writes — a passing suite is not evidence the contract holds. Say so in the brief, and make the review gate probe the real shapes rather than re-run the lead's own tests. **The specific failure is the self-referential test, and it is the most dangerous thing in this whole document.** A guard test that asks the implementation what it found, then asserts that is what it found, passes unconditionally — it cannot fail, and it is invisible in review because it reads like a real assertion. In one run this shipped a defect that published live personal data on 122 records while the suite was green; the *fix's own* guard test then repeated the pattern on a different axis and hid 19 more; and a third instance survived eight review rounds because it tested one side of a seam in isolation. **Mutation proof is necessary and still not sufficient — it cannot see a blind spot the tests and the implementation share.** In one run a lead reported …(truncated)