@feigi/fleet-ctl 3.82.15 → 3.82.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.82.15",
+  "version": "3.82.17",
   "description": "Agent fleet: run-team controller, merge bot, PR reviewer, and the ticket pipeline they share",
   "license": "Apache-2.0",
   "repository": {

package/skills/run-team/SKILL.md

@@ -59,8 +59,8 @@ phase, or in any later one, asks the maintainer which tickets to take.
    one stopped; before it, a re-run runs every step again.
 
    The `tier-roles` step runs `~/.fleet/bin/fleet-run tier-roles.mjs --check
-   --in-flight <B>`, `<B>` being the `--in-flight` given, else the default
-   **Defaults** (**Queue depth**) states. What it checks is in the header of `scripts/tier-roles.mjs`, under
+   --in-flight <B>`, `<B>` being the `--in-flight` given, else the default.
+   **Default: In-flight bound 5, fixed for the run.** See references/pull.md. What it checks is in the header of `scripts/tier-roles.mjs`, under
    the tier routes. A line it prints on a pass about omp's `task.maxConcurrency`
    is a notice in the step's output and never holds: read it, report it, and
    go on — the fleet never writes that setting.
@@ -151,8 +151,7 @@ phase, or in any later one, asks the maintainer which tickets to take.
    `REFRESHED shortlist: <n> entries; <k> lifted`. A head whose Pull ended
    this run is not counted, unless on a lifted exclusion. Phase 0 runs it by hand
    once because a dead run's shortlist is stale by definition.
-   None of those triggers runs while `HOLD (in-flight <n>/<B>)` stands
-   (**Queue depth**).
+   None of those triggers runs while `HOLD (in-flight <n>/<B>)` stands.
 
 **No multi-select, no maintainer tick.** Selection and ordering are batched —
 one scan, oldest first; admission never is. The invariant this replaces — one
@@ -305,6 +304,31 @@ A row with `review=` and no `reviewed=` is a review in flight, and the tick coun
 - **The merge bot.** Named `merge-bot-<n>`; `ledger.mjs dispatch merge-bot` numbers it. Never two at once. Render `--member merge-bot-<n> --n <n> --scratch <scratch>`. Dispatch with the printed agent, omit `model`, and dispatch on the first `ready-to-merge` label without waiting for the finisher report.
 - **The finisher.** Its render and receives are in `references/finisher.md`.
 
+**A fleet member is never dispatched with omp's `isolated: true`.** See references/isolation.md.
+
+**A member's tree is the claimed worktree, addressed by absolute path.** See references/isolation.md.
+
+**The controller's own cwd stays the main checkout, unchanged.** See references/isolation.md.
+
+**Name every member.**
+Names follow the unit of work: `impl-<issue#>`, `fix-pr-<pr#>`,
+`review-pr-<pr#>`, `finisher-pr-<pr#>`, `merge-bot-<n>`. See
+references/member-lifecycle.md.
+
+**Fresh context per member.** One member, one unit of work, gone. Refill =
+**new** member, **new** name. See references/member-lifecycle.md.
+
+**The scratch root is computed, never invented and never recorded.** You run
+`~/.fleet/bin/fleet-run scratch-root.mjs`; a non-zero exit is an environment to
+fix, not a cue to pick another root.
+`<scratch>` in this file is the path it prints, resolved before you send anything: every
+brief that carries one carries the absolute path you passed it — an
+implementer's `<scratch>/impl-<N>/`, the recipe deriver's
+`<scratch>/derive-recipe/`, a fix-applier's, a finisher's and a merge bot's
+`<scratch>/pr<N>/…`, and a review runner's `scratch` argument, which is the
+root itself. A member whose prompt names no path asks you by name and never
+makes one up. See references/isolation.md.
+
 ### Reading a review result
 
 **You read the digest; the findings are the fix-applier's.**
@@ -386,6 +410,29 @@ treat as a live scratch write until you have checked it.
 
 **A refutation resting on an injection nothing proved landed is not a refutation — it is a cell that never ran.** See references/reviewers.md.
 
+**Guard: accumulate per PR, never conclude inside one run.** **Append one row to
+`docs/metrics/tier-outcomes.tsv` when you rule each PR's review, with
+`~/.fleet/bin/fleet-run tier-outcomes.mjs append <pr> --closed-own-ticket yes|no --minted-false-claim yes|no --note "<text>"`,
+never by hand** (that file's header carries the column meanings). The script
+fills `run_date`, `pr`, `ticket` and `tier` itself — `tier` from what actually
+ran, off the implementer's `tier-ok=` ledger verdict or else its one
+member-outcomes row (a `tier-unverifiable=` member has no ledger verdict, so
+its one member-outcomes row decides), and BLANK with a WARNING naming why
+when neither settles
+it; never type a tier in over that. That append is the whole duty. See references/pull.md.
+
+The row's last four fields are the ticket's difficulty, and they are what lets a
+tier comparison condition on the thing that swamps it. `sizing` is the
+**member's** own `light`/`heavy` verdict from its dispatched `sizing-a-ticket`
+run, which `append` reads itself off the member's report file
+(`<scratch>/reports/impl-<ticket>[-x].json`, its `sizing.verdict`, the highest
+retry letter's when there are several), so you pass no `--sizing`; the member
+also puts it in the PR body's `Sizing:` line, with the signal it turned on;
+`profile`, `loc` and `files` all come from `diff-stats.mjs` over the merged
+diff.
+
+**A verdict is a measurement only if it post-dates the run that produced it.** See references/reviewers.md.
+
 ### Nothing to do: arm the beat
 
 - **Nothing to do right now** → **do not end your turn.** Arm the heartbeat
@@ -417,6 +464,7 @@ It blocks, then prints one line. Which line it is, is the whole protocol:
 not a reason to end the run; they are the state a newly triaged ticket arrives
 into. The run ends when you drain it, when the budget goes, or when this
 context does — not because there was briefly nothing to do.
+Zeroes on the cockpit are not yet proof the pipeline is idle.
 
 **When you stop on purpose, say why — one command, and it is the last thing
 you owe the next run.** See references/ci-and-staleness.md.
@@ -463,6 +511,18 @@ Act on each line the tick prints as its row reads here, then stop: the next wake
 ~/.fleet/bin/fleet-run fleet-tick.mjs --apply [--in-flight <n>]
 ```
 
+Read the depth off the tick and never derive it by hand: act on the row it prints, and when it prints `SUGGEST /triage, hold idle`, hold the implementer row idle and suggest `/triage` in the report. See references/tick-rows.md.
+
+**The review backlog never gates, and the merge-queue depth is still no
+signal.** The only gate on a Pull is the In-flight count. A deep backlog is a
+`DISPATCH review` on the same tick, never a reason to idle an implementer.
+A starved implementer queue never stalls the review or merge side.
+For the merge queue, see references/pull.md.
+
+**Reconcile, do not wait for an event.** With the shortlist empty the tick's rows
+govern — refresh, and never Pull a ticket the shortlist does not hold.
+See references/pull.md.
+
 It reads the run itself, and nobody states a count. The In-flight count —
 every open PR that closes an issue off `gh`, plus every claimed ticket whose
 newest implementer is live or owed a replacement and has no such PR yet, off
@@ -482,12 +542,11 @@ row with `ledger.mjs row` and tick again. The In-flight bound defaults to 5
 and is fixed for the run: pass `--in-flight` on every tick when `$ARGUMENTS`
 set it, and never otherwise.
 
-It prints `actual/target` and a named ACTION per role, with the whole **Queue
-depth** guard table applied in code. Act on each line as it reads:
+It prints `actual/target` and a named ACTION per role. Act on each line as it reads:
 
 - `PULL #<N> …` — one Pull per named ticket, in the order printed: `pull.mjs next --head <N>`, or the `pull.mjs answer` the row names (phase 1), then the dispatch under **Dispatching the Pull's member**.
 - `REFRESHED shortlist: <n> entries; <k> lifted` — the tick refreshed the shortlist itself, and its `PULL` row already reads the result; `REFRESH FAILED` is yours, since `shortlist.mjs` could not run.
-- `SUGGEST /triage, hold idle` — nothing is admissible after the refresh: suggest `/triage` in the report, never run it.
+- `SUGGEST /triage, hold idle` — nothing is admissible after the refresh: suggest `/triage` in the report, never run it. The suggestion is a report, not a blocking prompt.
 - `specs-dropped=#<N> …` — never actionable: log those tickets as specs awaiting to-tickets, not as no work.
 - `DISPATCH fix-pr PR#<M> …` — a fix-applier for that PR (review findings, a dispositions mismatch no retry has answered, or a conflict hold): render its brief with `dispatch-prompt.mjs render fix-applier --kind <kind>`, `ledger.mjs dispatch <M> fix-pr-<M>` (the next suffix when that name is already on record), then the `task` call.
 - `DISPATCH review PR#<M> …` — a review per PR, oldest first, off your turn: record `review=member:review-pr-<M>` with `ledger.mjs review <M> …`, then dispatch `review-pr-<M>`.
@@ -1019,6 +1078,35 @@ report recovery, never the exit code alone.
 
 Each rule here is a judgement a driver stops for: answer it by the cause it names, then run the tick, and report to the maintainer what the evidence cannot settle.
 
+### A member's claims
+
+**Cross-check what members report about their environment.**
+
+**Distrust negative claims hardest.** Make members state their search scope. Negative claim
+vs specific finding with paths → paths win. See references/reviewers.md.
+
+Suspect a neighbour before a member's own diff — for unexplained failures, and
+equally for any **finding** that came from reading source.
+
+**Never read a member's silence as assent**, and require members to report their *confirmation state*
+alongside results — "I escalated X, received no ruling, proceeded on default Y".
+After any ruling
+you cannot confirm was received, re-check the artifacts it governed. See references/member-lifecycle.md.
+
+### Re-check the instruments before a gate
+
+**You read your instruments out of a tree every member can write to — re-check them before every gate decision.** See references/instruments.md.
+
+- **Re-check before you act on any instrument reading** — a SHA acceptance, a CI
+  verdict, the reconcile, a reap, a label gate — from the main checkout phase 0 pinned from:
+  `~/.fleet/bin/fleet-run instruments.sh`. **Exit 0 is the only code that
+  lets a gate proceed. Exit 1 (the set changed) and exit 2 (the check could not
+  answer) both refuse: report what it printed and do NOT re-read the
+  instrument** — a guard that fails open on "could not look" protects nothing.
+- **Re-pin only after a change you made deliberately.** **A mid-run tooling fix**
+  is the one legitimate writer. Re-pinning to clear a refusal you cannot
+  explain discards the check.
+
 ### Relabel causes
 
 - **Implementer bails before implementing** → `fleet-event.mjs impl-report impl-<N>`
@@ -1035,6 +1123,9 @@ Each rule here is a judgement a driver stops for: answer it by the cause it name
   The call comments the cause and releases the claim — never when `fixed` neither closes nor relabels N — then ticks:
   the head the tick names next is a *different* ticket.
 
+A member that bails demotes nothing itself; demotion by cause is yours
+(**Implementer bails before implementing**).
+
 ### Resolving a finisher halt
 
 A halt at duty 1 reads identical from a bare SHA mismatch whatever caused it,
@@ -1113,414 +1204,6 @@ and flag the PR for a human. A new review of the PR counts again from none.
 | Merge bot's gate finds the merge would remove lines `main` gained after the PR's work began (`main-gain-removed:<path>`, exit 1) | Relay `main-gain-removed:<path>-#<pr>` to a human with the hit list and the acknowledgement keys the bot printed. PR stays queued, label untouched, nothing written to the ledger, and no member is dispatched to restore the lines — the removal may be deliberate. It clears when the PR stops removing them or its body carries `main-gain-removal: <path> <key> - <why>` for each hit |
 | Merge bot's gate cannot answer the main-gain check (`main-gain-unanswerable`, exit 2) | Report `main-gain-unanswerable-#<pr>` with what it printed, PR stays queued, label untouched |
 
-## Rules that fail silently
-
-These rules fail silently when they are skipped: check each before you act on a member's silence, and stop reading silence as a report or as assent.
-
-Zeroes on the cockpit are not yet proof the pipeline is idle.
-
-**A report is delivered, not implied by ending a turn.** Every member owes
-the controller one report naming its outcome before it exits — including a
-member whose prompt carries no explicit report line. The "report the SHA",
-"report PR number" and "stop and report" instructions below *are* that
-report, not a second obligation on top of it. A member that does the work
-correctly and ends its turn has reported nothing: the controller learns the
-outcome only by re-reading artifacts and pinging, and a finding held only in
-that member's context is lost. Members did exactly this in one run —
-finishers, a reviewer and merge bots alike, the work done and only the
-delivery missing. Every brief's report paragraph says it. See
-references/member-lifecycle.md.
-
-**The implementer, fix-applier, finisher, merge-bot and review-runner briefs
-each tell the member you do not acknowledge reports; you never write that line
-yourself.** A member cannot see whether its report arrived, so silence
-from you is indistinguishable from loss and it re-sends — three members did in
-one run, each burning a turn, and in all three the original had in fact arrived.
-Each of those templates under `briefs/` carries the line: *"The controller does
-not acknowledge reports. Send once and exit; never re-send unless the controller
-asks by name."*
-
-So when a report is missing, **ask by name — that is what the "unless the controller asks by name" clause is for — and do not attribute the gap to the member until it answers.** See references/member-lifecycle.md.
-
-The ask is the controller's move, not the member's. See references/member-lifecycle.md.
-
-**Your OWN messages can vanish the same way, and that half is not recoverable by
-a re-send.** Two controller rulings were lost in one run, both with a
-`success: true` receipt: a member proceeded on its stated default and filed a
-tracker issue the lost ruling had said not to file. So **never read a member's
-silence as assent**, and require members to report their *confirmation state*
-alongside results — "I escalated X, received no ruling, proceeded on default Y".
-That sentence is the only thing that made either loss visible. After any ruling
-you cannot confirm was received, re-check the artifacts it governed.
-
-**Name every member.** The name is the ledger token and the hub address; omit
-it and the ledger cannot match the member.
-Names follow the unit of work: `impl-<issue#>`, `fix-pr-<pr#>`,
-`review-pr-<pr#>`, `finisher-pr-<pr#>`, `merge-bot-<n>`. See
-references/member-lifecycle.md.
-
-**Fresh context per member.** One member, one unit of work, gone. Refill =
-**new** member, **new** name.
-
-See references/member-lifecycle.md.
-
-**You read your instruments out of a tree every member can write to — re-check them before every gate decision.** See references/instruments.md.
-
-- **Pin once**, at phase 0 step 0 above, from the main checkout you are
-  running this from — never from a member's worktree, which is gitignored
-  and carries no baseline:
-  `~/.fleet/bin/fleet-run instruments.sh --pin`. On a workspace that does not
-  track `plugin/…`, the pin names the plugin checkout once — `--pin --audit
-  <plugin-checkout>` — and every check after it follows the recorded tree.
-- **Re-check before you act on any instrument reading** — a SHA acceptance, a CI
-  verdict, the reconcile, a reap, a label gate — from that same main checkout:
-  `~/.fleet/bin/fleet-run instruments.sh`. **Exit 0 is the only code that
-  lets a gate proceed. Exit 1 (the set changed) and exit 2 (the check could not
-  answer) both refuse: report what it printed and do NOT re-read the
-  instrument** — a guard that fails open on "could not look" protects nothing.
-  **A label gate and a CI verdict are also taken by dispatched members, not
-  only by you** — the finisher labels, and the merge bot merges on its own
-  reading — and neither is dispatched to read this file, so neither can be
-reached by stating the rule here. Each carries its own copy: the finisher's
-in the instrument re-check block of `agents/fleet-finisher.agent.md`, the merge bot's inside
-`merge-gate.mjs`, step 3 of `run-merge-bot.md`.
-- **Re-pin only after a change you made deliberately.** The mid-run tooling fix
-  below is the one legitimate writer. Re-pinning to clear a refusal you cannot
-  explain discards the check.
-
-It covers every tracked file under this repo's own plugin component directories
-— `plugin/commands/`, `plugin/scripts/`, `plugin/skills/`, `plugin/agents/`,
-`plugin/workflows/` — the probes, the libraries they source, and these runbooks,
-which you also read from that tree. Not the whole repo: `docs/metrics/` is
-appended by THIS run, so covering it would refuse on the run's own bookkeeping
-every time. It does not cover refs, deliberately: `claim-ticket.sh` creates a
-branch per ticket and `reap.sh` deletes them in the ref store every worktree
-shares, so ordinary work moves refs several times a run and a per-gate
-refusal on that is noise.
-
-**A member runs its test suite in the foreground and blocks on it.** See references/member-lifecycle.md.
-
-**The scratch root is computed, never invented and never recorded.** No harness
-supplies a scratch directory to a member, so a member left to name its own
-invents one — and the liveness read in **The tick's rows**, which looks at the files under the
-directory a member's own prompt assigned it, then watches a directory nobody
-else can find. You run `~/.fleet/bin/fleet-run scratch-root.mjs`: it prints one
-absolute path, `~/.fleet/scratch/<repo-key>/`, the same from the main checkout
-and from every linked worktree, and the same again when a compacted or
-re-invoked controller runs it, so nothing writes it down. It exits non-zero,
-with its reason, when the root would sit inside a git work tree that does not
-ignore it; that is an environment to fix, not a cue to pick another root.
-`<scratch>` in this file is that path, resolved before you send anything: every
-brief that carries one carries the absolute path you passed it — an
-implementer's `<scratch>/impl-<N>/`, the recipe deriver's
-`<scratch>/derive-recipe/`, a fix-applier's, a finisher's and a merge bot's
-`<scratch>/pr<N>/…`, and a review runner's `scratch` argument, which is the
-root itself. A member whose prompt names no path asks you by name and never
-makes one up.
-
-## Worktree and claim model
-
-Run none of this by hand: act through `claim-ticket.sh`, `release-ticket.sh`, `reap.sh` and `inflight.sh` as their phases say, and dispatch every member into its claimed worktree by absolute path.
-
-**Claim, release and reap are unchanged on omp.** `claim-ticket.sh`,
-`release-ticket.sh`, `reap.sh` and `inflight.sh` are git-native and operate on
-the single shared ref store every worktree and the main checkout read and
-write directly (**Phase 1**, the tick's reap, and `release-ticket.sh` under
-**Failure handling**); nothing in omp's `task` model touches that
-store, so none of the four scripts carries a dialect branch.
-
-**A fleet member is never dispatched with omp's `isolated: true`.** See references/isolation.md.
-
-**A member's tree is the claimed worktree, addressed by absolute path.** See references/isolation.md.
-
-**The one open gap that probe measured: `task` does not accept a per-dispatch working directory.** See references/isolation.md.
-
-**The same gap reaches past the filesystem: `task`-dispatched members share one `eval` kernel.** See references/isolation.md.
-
-**`release-ticket.sh` is not a no-op on omp, and `inflight.sh`'s probes are unaffected by a running member.** See references/isolation.md.
-
-**The controller's own cwd stays the main checkout, unchanged.** Nothing in
-this section's dispatch recipe — the cwd recipe above, the isolated-workspace
-measurement, or the teardown scoping — moves
-where the controller itself runs from.
-
-## Queue depth
-
-Read the depth off the tick and never derive it by hand: act on the row it prints, and when it prints `SUGGEST /triage, hold idle`, hold the implementer row idle and suggest `/triage` in the report.
-
-- **shortlist** — `.fleet/shortlist.json`'s entries with no `impl-` row and no
-  live `excluded` row: admissible, not yet pulled. The tick's `unclaimed=`.
-  Not after a refresh at unclaimed < B (below). A head whose Pull ended this
-  run is not counted, unless on a lifted exclusion.
-- **supply** — `scanned`, the open `ready-for-agent` tickets `shortlist.mjs`'s
-  candidate scan returned, before any filter. Only a Pull's full read judges
-  decided?, so a shortlist of undecided tickets is supply that every Pull
-  relabels away — and relabelling is what stops it being counted next scan.
-- **review backlog** — PRs owed a review. `fleet-tick.mjs` counts every
-  open PR without `ready-to-merge` **that closes an issue** and carries no `review=`
-  token on the ledger — one settled `=failed` is owed a review again, and so is
-  one whose latest finisher halted `past-pin` past its latest `reviewed=` head
-  (**Resolving a finisher halt**) — and it
-  prints them as `review-due=`. Exact, not a wider read: the ledger records
-  which PRs are under review or reviewed, so nothing about it is guesswork. The
-  closing-issue test is what keeps it from widening: a PR that closes no issue
-  — one you author yourself, for instance — is left unlabelled for the
-  maintainer, so no member of the fleet will ever review it, and counting it
-  floors the backlog at a depth nothing in the run can drain — the reviewer
-  row would then report a review owed for the rest of the run.
-  GitHub's own linked-issue set decides that, not a keyword regex over the body.
-  **That exemption is for a PR THIS run authors, never one a PRIOR run left
-  open** — step 0 folds those into this run's review queue, so count one when
-  you reason about backlog BY HAND. **The `fleet-tick.mjs` number still
-  excludes it**: nothing in its filter distinguishes an inherited PR from this
-  run's own, since a PR closing no issue fails the closing-issue test either
-  way — folding one in cannot reach the count. So the by-hand judgement and
-  the script's output differ here, and such a PR's review is dispatched by
-  hand.
-- **In flight** — a ticket between its Claim and its PR's merge: an implementer
-  live or owed a replacement on it, or an open PR closing it. A PR closing
-  nothing is never in flight, and a ticket whose newest implementer settled
-  `blocked` is not either. The tick's `n`; the implementer row's counts read it
-  as `implementers=<i> prs=<p>`, n being i + p.
-- **In-flight bound** — the most tickets a run lets be In flight at once, fixed
-  for the run, set by `/run-team`'s one argument. Reaching it holds every Pull
-  until a merge brings the count below it; reviewers, finishers and the merge
-  bot never slow for it. The tick's `B`.
-
-**Default: In-flight bound 5, fixed for the run.** See references/pull.md.
-
-**The review backlog never gates, and the merge-queue depth is still no
-signal.** The only gate on a Pull is the In-flight count. A deep backlog is a
-`DISPATCH review` on the same tick, never a reason to idle an implementer.
-For the merge queue, see references/pull.md.
-
-**Reconcile, do not wait for an event.** With the shortlist empty the table
-below governs — refresh, and never Pull a ticket the shortlist does not hold.
-See references/pull.md.
-
-**Do not re-derive this by hand — `fleet-tick.mjs` computes it.** One invocation
-prints per-role `actual/target` and an explicit ACTION with the backlog gate
-above and every row of the table below already applied; every wake
-ends in it. The deficit is then *computed, not remembered*, which is
-the whole point: a table you must remember to consult is one you will not
-consult under a merge-side event storm, and that is how implementers reached
-0/target with ~57 `ready-for-agent` in supply while nobody
-noticed (#3). What follows stays here as the explanation of what the script decides —
-never as a second, hand-run copy of it. The table's shortlist counts no head
-whose Pull ended this run, unless on a lifted exclusion. A refresh at unclaimed < B leaves `unclaimed=` at
-that count, so `SUGGEST /triage` can print it above 0.
-
-| shortlist (unclaimed) | implementer row prints |
-|---|---|
-| ≥ 1 | `PULL #N …`, one head per free slot — a Pull each (phase 1) |
-| below the In-flight bound, missing or empty | the tick refreshes first — `REFRESHED shortlist: n entries; k lifted` — and Pulls from what it found |
-| 0 after that refresh | `SUGGEST /triage, hold idle` |
-
-### Specs, the refresh bound and the holds
-
-Whatever the row prints, a `specs-dropped=#<N> (…)` at the end of its counts
-names the tickets the to-spec filter kept out of the shortlist — specs
-awaiting to-tickets, so an empty shortlist carrying one is not "no work".
-
-The refresh runs at unclaimed < B and, with every other refresh trigger, never
-while the bound holds: a refresh then cannot feed a Pull, and the first tick
-back under the bound refreshes and Pulls in the same tick. Unclaimed there
-counts no head whose Pull ended this run, unless on a lifted exclusion.
-
-Four holds outrank every row: `HOLD (draining)` once `ledger.mjs drain` has
-recorded the drain, `HOLD (tier mismatch impl-<N>)` until a replacement is
-dispatched at the right tier, `HOLD (tier unchecked impl-<N>)` until
-`tier-check.mjs` has written its verdict on the newest implementer —
-`tier-ok=`, `tier-mismatch=` or `tier-unverifiable=` — and
-`HOLD (in-flight <n>/<B>)` when n tickets are between Claim and merge and
-n ≥ B — refreshing to enable a Pull you are holding buys nothing.
-
-`HOLD (in-flight <n>/<B>)` ranks last of the four: the other three print in
-its place. Its detail is the implementer row's counts, `implementers=<i>
-prs=<p> unclaimed=<k> supply=<s>`. It is quiet — a merge brings n below B and
-the next tick Pulls — except for a ticket whose newest implementer settled
-`killed` or `tier-mismatch`: it counts as In flight with no PR that could
-merge, so the row asks for the replacement's dispatch and names it in the
-detail. The reviewer row reads `<units>/<B>`, its live review units against
-the same bound, and never holds on it.
-
-A main checkout that is not `clean` against its Phase 0 baseline outranks all
-of them, and every dispatching row besides: `HOLD (main checkout dirty)`,
-`HOLD (main checkout unknown)` or `HOLD (main checkout no baseline)` on the
-implementer, reviewer and merge-bot rows alike, beside the `MAIN-CHECKOUT-*`
-line that says why.
-
-`/triage` is user-invoked only — suggest, never run. The suggestion is a report,
-not a blocking prompt. Counts come from cheap `gh issue list --search`, no bodies.
-A starved implementer queue never stalls the review or merge side.
-
-## Tier outcomes guard
-
-This guard is done when you have run `tier-outcomes.mjs append` once for each PR whose review you rule; never conclude a tier result inside one run.
-
-**Guard: accumulate per PR, never conclude inside one run.** The unit is the PR —
-supply is one Pull per free slot, so there are no implementer batches. **Append one row to
-`docs/metrics/tier-outcomes.tsv` when you rule each PR's review, with
-`~/.fleet/bin/fleet-run tier-outcomes.mjs append <pr> --closed-own-ticket yes|no --minted-false-claim yes|no --note "<text>"`,
-never by hand** (that file's header carries the column meanings). The script
-fills `run_date`, `pr`, `ticket` and `tier` itself — `tier` from what actually
-ran, off the implementer's `tier-ok=` ledger verdict or else its one
-member-outcomes row (a `tier-unverifiable=` member has no ledger verdict, so
-its one member-outcomes row decides), and BLANK with a WARNING naming why
-when neither settles
-it; never type a tier in over that. A PR that already has a row is left
-untouched, so re-running it is safe. That append is the whole duty.
-
-The row's last four fields are the ticket's difficulty, and they are what lets a
-tier comparison condition on the thing that swamps it. `sizing` is the
-**member's** own `light`/`heavy` verdict from its dispatched `sizing-a-ticket`
-run, which `append` reads itself off the member's report file
-(`<scratch>/reports/impl-<ticket>[-x].json`, its `sizing.verdict`, the highest
-retry letter's when there are several), so you pass no `--sizing`; the member
-also puts it in the PR body's `Sizing:` line, with the signal it turned on;
-`profile`, `loc` and `files` all come from `diff-stats.mjs` over the merged
-diff. **Phase 0 does not size anything** — it shortlists, a Pull claims, and
-the sizing run happens inside the member after both, which is why the verdict
-has to travel in the member's report rather than being something you already hold.
-
-**A verdict is a measurement only if it post-dates the run that produced it.** See references/reviewers.md.
-
-The member-facts scrape, the drain of the pending ticket-features rows and the
-commit of the metrics files are steps of `closeout.mjs finish`, which **End of
-run** (**What a wake owes beyond its call**) drives. See references/close-out.md.
-
-**Why not decide inside one run.** A run holds 2-3 implementer PRs, and ticket
-difficulty swamps the tier effect — a gojq parity harness and a two-statement
-shell reorder are not comparable units. Finding-counts are not comparable either:
-`selectDimensions` trims the fan-out by diff profile, so one PR fields 29 agents
-over six dimensions and its sibling fields 8 over three. And the fleet is not
-stationary — this prompt gets edited mid-run when a defect earns it. Hence a
-binary outcome per PR, accumulating, rather than a per-run verdict.
-
-**Why the rows this guard fired on could not answer the tier question, and this
-is the load-bearing part.** Until the 2026-08-16 revert, `class` and `tier` were
-perfectly confounded: routine always ran `sonnet`, correction always ran top
-tier. So the comparison the file invites — routine-at-sonnet against
-correction-at-top-tier — measures **class, not tier**, because those classes fail
-in different ways by construction: corrections ship false claims in prose,
-routines ship incomplete or regressing code. A run that "mixes both" does not fix
-it. **Only a same-class comparison across tiers is informative**, and the old
-rule could not produce one, since no routine ticket ever ran at top tier.
-
-**That last sentence is no longer true, and this is the part to re-read.** Since
-the revert every routine ticket runs at top tier, so the file now holds 55
-`routine`/`opus` rows against 11 `routine`/`sonnet` (as of 2026-08-28, 103 rows
-— recount before citing). The same-class comparison the paragraph above calls
-the only informative one therefore EXISTS now. It is still not clean: the two
-groups are split almost entirely by calendar date, so it measures prompt
-evolution at least as much as tier. The counter-evidence paragraph earlier in
-this section carries the split and the three rows that cut against it. Recount
-both, and every other figure in this section, with:
-
-```bash
-grep -vc '^#' docs/metrics/tier-outcomes.tsv
-awk -F'\t' '!/^#/ && $4=="routine" {n++; d[$1]=1; if($6=="no") no++} \
-  END{print n, length(d), no+0}' docs/metrics/tier-outcomes.tsv
-awk -F'\t' '!/^#/ && $4=="routine" {t[$5]++; if($6=="no") f[$5]++} \
-  END{for(k in t) print k, t[k], f[k]+0}' docs/metrics/tier-outcomes.tsv
-```
-
-**These rows are the historical corpus, and nothing appended to them fixes the
-confound.** What fixes it is the exploration draw in the dispatch rule above:
-one implementer in every five — every one, during burn-in — runs at a drawn
-cell beside the policy cell's, against the same prompts on the same day, so
-the comparison stops depending on which tier history happened to leave in
-which week. Read each cell's comparisons, not the whole-file split, once there
-are enough of them.
-
-**So read what the guard actually established: routine tickets sometimes fail to
-close their own ticket. Not that `sonnet` caused it.** The revert is the
-pre-committed rule being honoured, not a measurement. Restoring a cheap tier is
-still the maintainer's call and still a change to the dispatch rule — but the
-deliberate control it used to require is no longer something anyone has to
-authorize one ticket at a time: the exploration draw above produces one in
-every five Pulls by construction. **Do not read a cell early.** A cell's
-comparison is one session holding an admissible row at that cell — its tier
-check passed and its resolved effort is the cell's level — and one at
-`slow-high` whose resolved model and effort differ. Count them per cell, never
-pooled across cells, and stop until
-there are at least ten of them across five or more distinct `run_date`s; below
-that, a comparison count is a number, not evidence, and the last guard fired
-with n=1 on the control side. **Report the count the per-cell readout prints,
-never one from any other query:** `~/.fleet/bin/fleet-run cell-readout.mjs`
-prints `<cell> <comparisons> <run_dates> <resolved models>` for each cell past
-that floor and a cell below it only as a count on stderr; a `mixed (…)` models
-column means the cell's history spans more than one model behind its role.
-The pre-cell pair query counted pairs that are no cell's comparisons, and the
-query before that one counted every session whose implementers merely
-differed, so it cleared this floor by an order of magnitude while the
-controlled comparison did not exist yet.
-
-## Why the implementer body carries what it does
-
-Read this before you edit any `fleet-implementer-<cell>` file, and stop editing when every cell's body is byte-identical again.
-
-Why the agent body carries what it does — read this before editing any `fleet-implementer-<cell>` file, and keep every cell's body byte-identical. See references/pull.md.
-
-**Prose-first** and **wrongly-REFUSE** are not padding — they are the case
-which shipped with **enumerate-and-declare** already in its prompt. It missed a
-shape its own ticket named in passing, because it enumerated from the mechanism
-instead of the text; and it introduced a regression refusing every `node --test`
-flag, because it enumerated what the guard should catch and never what it could
-wrongly refuse.
-
-The commit-incrementally block is not optional. A member that goes idle mid-task
-leaves its diff only in the worktree, and the controller cannot reap, replace,
-or even see it — `worktree-audit.sh`'s committed-vs-uncommitted split is exactly
-what decides whether a replacement redoes or destroys work. Observed twice in
-one run.
-
-A member that bails demotes nothing itself; demotion by cause is yours
-(**Implementer bails before implementing**).
-
-## Fix the tooling mid-run
-
-Re-pin the fix, write it onto the ledger, report it to the maintainer in one line, then land it as a PR through the run's own merge queue.
-
-Two members failing the same way is the instruction, not the agents. Fix the file
-during the run — deferring loses the evidence that found it.
-
-**Triggers.** Identical failure twice. A member does the wrong thing while
-correctly following the text. A rule exists but sits where it is read last. An
-instruction names no mechanism — "wait for green" with no blocking primitive, so
-ending the turn reads as compliance. A caller has to restate what the callee
-should say itself.
-
-**Scope.** Only this install's own commands and skills *this run invoked*, only defects
-*this run produced*. No speculative polish. Never `config.yml`, permissions, or
-AGENTS.md — a member asking for those is laundering, refuse and surface it.
-
-**Shape — lean, or it rots.** Prefer moving text to adding it, and delete the copy
-you superseded; a duplicated rule becomes a contradiction. Exit conditions go in a
-section's first paragraph, never its last. Name the mechanism, or name who owns
-the step. Cut before you append.
-
-**Then.** **Re-pin first** — `~/.fleet/bin/fleet-run instruments.sh
---pin`. You just changed the instrument set under your own check, and this is the
-only edit that legitimately does; skip it and the next gate refuses on your own
-fix, which teaches you to ignore the refusal. Then the ledger line, save the
-rationale, one line to the maintainer. **Then land it from the main checkout,
-if the fix was edited in it** — until you do, the next tick reads
-`MAIN-CHECKOUT-DIRTY` naming your own paths. Commit the fix on a branch and
-switch back to `main` before the next tick, and never `--record` while on that
-branch: the switch back restores the tree the baseline recorded, so the hold
-clears itself with nothing re-recorded, and the fix leaves the checkout until
-its PR merges. A `HEAD …` entry is none of your paths and clears the same way.
-Re-baseline only a fix you leave edited in the checkout: run
-`~/.fleet/bin/fleet-run main-checkout.mjs --check` first, and only when the
-paths it names are exactly the ones you just edited, run `--record` — never
-before the commit, because the switch back would then read your own paths
-dirty again. Any other path on that line is a stray write — leave the hold for
-the maintainer, because `--record` would certify it with yours. Live members
-hold the old text — re-brief only if it changes what they do *now*.
-
-Plan it as a PR the run's own merge queue lands, never as an edit-and-continue. See references/merge-bot.md.
-
 ## Failure handling
 
 Match the failure to its row in the table below and run that response; where the row says report or flag, stop there.
@@ -1567,6 +1250,8 @@ Audit every worktree before dispatching replacements with
 ahead-count and uncommitted files, the committed-vs-uncommitted distinction that
 decides whether a replacement redoes or destroys work.
 
+When a report is missing, **ask by name — that is what the "unless the controller asks by name" clause in every brief is for — and do not attribute the gap to the member until it answers.** See references/member-lifecycle.md.
+
 **A throw, an empty return, or a notification whose status is not `completed`
 is a failure event, not a clean review.** **Retry once
 under the next runner letter, then stop:** the `review-pr-<pr#>` runner
@@ -1578,10 +1263,6 @@ review-due. A
 runner member that is killed rather than failed follows **Failure
 handling** (fresh name, inherited state stated).
 
-## Guards
-
-Each guard here is a check to run before the step it guards: run it, and where it fails, stop and report rather than go on.
-
 **Verify every reported SHA.** `~/.fleet/bin/fleet-run verify-sha.sh
 <branch> <sha>` before enqueueing — a member can commit in a nested worktree,
 leaving the SHA on a stray branch while its report reads normally. Exit codes as
@@ -1597,14 +1278,7 @@ ticket over a failure a re-run would have cleared.
 
 **Never `--delete-branch` — the merge bot deletes the head branch itself.**
 `gh pr merge <n> --merge` alone: the flag's local cleanup errors on a `main`
-held by another worktree, or strands the feature worktree on `main`. After the
-merge, `delete-merged-branch.sh <pr>` deletes the branch from `origin` and reads
-the deletion back; `reap.sh` takes the `[gone]` local branch and its worktree.
-No repo setting is relied on to do it. A branch another open PR still
-uses as its head or base is kept instead — `branch-kept-#<that PR>` in the bot's
-report, a deliberate keep and not a failure.
-The branch-delete step also releases the claim label: it drops `in-progress` from
-every issue the PR closes.
+held by another worktree, or strands the feature worktree on `main`.
 
 **Never force a rebase to start.** No `git clean`, `git checkout .`,
 `git reset --hard`, `git stash`. Uncommitted changes may exist nowhere else.
@@ -1614,14 +1288,6 @@ empty answer here and licenses the rebase over work this check exists to
 protect. Stashing empties it either way, so that check and
 `no-undo-audit.sh` both go quiet on work nothing else holds.
 
-**Cross-check what members report about their environment.** Wrong often enough
-to matter, and a confident wrong report from a reviewer flips a verdict.
-
-**Distrust negative claims hardest.** "Nothing else references this", "the sweep
-is clean" — most likely false, least likely checked: a grep that found nothing
-looks like a grep never run. Make members state their search scope. Negative claim
-vs specific finding with paths → paths win.
-
 **Members share one filesystem, one docker stack and one process table**, and the
 failures arrive as *wrong findings*, not errors:
 
@@ -1640,70 +1306,61 @@ failures arrive as *wrong findings*, not errors:
   and the controller re-checks any measurement taken in the window.
 
   **Do not guess the victim — the blast radius is the machine, not the Pull.**
-  In that incident the controller reasoned from dispatch scope to "almost
-  certainly `impl-<N>`" and told the maintainer so; the named member then proved
-  it was not the victim (it had never invoked those files standalone, and its
-  mutation baselines post-dated the window). Idle members of *previous* runs,
-  other omp sessions on the same machine, and the maintainer's own shell are
-  all `pkill -f` targets and none of them appear in your ledger. Warn every live
+  Warn every live
   member, record the incident as unattributed, and re-check measurements by
-  timestamp rather than by who you think was running.
+  timestamp rather than by who you think was running. See references/isolation.md.
 
 - **A warning acted on silently is indistinguishable from one that never
-  arrived.** The same incident: the controller's warning DID reach the member,
-  which re-ran, found nothing changed, and said nothing — correctly reading
-  "send once, never re-send" as covering it. The controller then had to spend a
-  round trip asking whether its own outbox was lossy. So the briefs say that
-  **confirmation state includes warnings received and acted on, even
-  when the outcome is no change** — one line, in the report the member already
-  owes. That is the cheap half of the *never read silence as assent* rule, paid
-  by the member rather than by the controller's guesswork.
-
-- **Specialist tree isolation is `review-and-fix.md`'s job — do not restate it.**
-  It owns the object-store rule, the two-tree split, snapshot provisioning, and
-  which suites a snapshot cannot validly run. Your only duty is to *not*
-  contradict it.
-- **Filesystem isolation is not stack isolation.** A private copy of the
-  tree and a test command solve different problems; the compose project
-  name comes from the environment, not the working directory, so three
-  agents on three snapshots still collide on one postgres. "I'm on my own
-  copy" is exactly the intuition that skips the command — say both, every
-  time. Which command depends on the audience: a member in a worktree
-  uses `./agent-test`; a specialist on a snapshot does not, and takes the
-  one `review-and-fix.md` hands out. Which runner the worktree holds
-  decides why: the runner a claim writes is untracked, so a `git archive`
-  snapshot never carries it; one the repository tracks does ride along,
-  but no claim exported ports into it — its isolation is whatever that
-  repository built, not one triple per snapshot. See
-  references/isolation.md.
+  arrived.** See references/isolation.md.
+- **Specialist tree isolation is `review-and-fix.md`'s job — do not restate it.** See references/isolation.md.
+- **Filesystem isolation is not stack isolation.** See references/isolation.md.
 - **Scratchpad paths need two levels — the member's own partition, then one
-  directory per child it dispatches — and nothing outside them.** An
-  implementer partitions at `<scratch>/impl-<N>/`; the review side's partition
-  is `<scratch>/pr<N>/…`, which the review core creates itself, so a review
-  runner is handed the scratch root, never that partition; any member that
-  dispatches a child writes an absolute directory under its own partition into
-  that child's prompt, one per child and never shared, and a child never
-  derives its own. Finding ids restart at 1 every review, so two fix-appliers
-  on different PRs both reach for `unv1`; one
-  agent overwrote a sibling's `package.json`, and a probe built a git repo at
-  the *checkout root*. Read from the object store at a pinned ref, write only
-  under your own path. See references/isolation.md.
-- **IDE/harness diagnostics attribute by bare filename, with no path.** **Never
-  relay a diagnostic without reproducing it in that member's specific worktree**
-  (re-run the check that raised it from there): probe copies carry the real
-  tree's filenames, so a sibling's throwaway mutation reads exactly like a live
-  worktree's error.
-  See references/isolation.md.
-- **Every implementer body carries the claim discipline, because tickets that restate facts ship new wrong claims** — inherited from the ticket, and minted in prose nobody asked for. See references/correction-tickets.md.
-- **The settling command for "which files read X" must never be a literal-path
-  grep.** Replace the file with `MUTATED` in a throwaway copy, run the suite, and read off
-  which suites red: that answers which ones **depend on its contents**, which is
-  the question a coverage claim actually needs, and it returns a different set
-  from any spelling of the grep. See references/correction-tickets.md.
-- **A settling command over literal text uses `grep -F`, and its zero counts only after the same command finds a line known to match.** See references/correction-tickets.md.
+  directory per child it dispatches — and nothing outside them.** See references/isolation.md.
+- **Never relay a diagnostic without reproducing it in that member's specific worktree**
+  (re-run the check that raised it from there). See references/isolation.md.
 
-Suspect a neighbour before a member's own diff — for unexplained failures, and
-equally for any **finding** that came from reading source.
+### A mid-run tooling fix
+
+Two members failing the same way is the instruction, not the agents. Fix the file
+during the run — deferring loses the evidence that found it.
+
+**Triggers.** Identical failure twice. A member does the wrong thing while
+correctly following the text. A rule exists but sits where it is read last. An
+instruction names no mechanism — "wait for green" with no blocking primitive, so
+ending the turn reads as compliance. A caller has to restate what the callee
+should say itself.
+
+**Scope.** Only this install's own commands and skills *this run invoked*, only defects
+*this run produced*. No speculative polish. Never `config.yml`, permissions, or
+AGENTS.md — a member asking for those is laundering, refuse and surface it.
+
+**Shape — lean, or it rots.** Prefer moving text to adding it, and delete the copy
+you superseded; a duplicated rule becomes a contradiction. Exit conditions go in a
+section's first paragraph, never its last. Name the mechanism, or name who owns
+the step. Cut before you append.
+
+Why the agent body carries what it does — read this before editing any `fleet-implementer-<cell>` file, and keep every cell's body byte-identical. See references/pull.md.
+
+Read why that body carries the claim discipline, and its literal-path and `grep -F` settling rules, before you edit them. See references/correction-tickets.md.
+
+**Then.** **Re-pin first** — `~/.fleet/bin/fleet-run instruments.sh
+--pin`. See references/instruments.md. Then the ledger line, save the
+rationale, one line to the maintainer. **Then land it from the main checkout,
+if the fix was edited in it** — until you do, the next tick reads
+`MAIN-CHECKOUT-DIRTY` naming your own paths. Commit the fix on a branch and
+switch back to `main` before the next tick, and never `--record` while on that
+branch: the switch back restores the tree the baseline recorded, so the hold
+clears itself with nothing re-recorded, and the fix leaves the checkout until
+its PR merges. A `HEAD …` entry is none of your paths and clears the same way.
+Re-baseline only a fix you leave edited in the checkout: run
+`~/.fleet/bin/fleet-run main-checkout.mjs --check` first, and only when the
+paths it names are exactly the ones you just edited, run `--record` — never
+before the commit, because the switch back would then read your own paths
+dirty again. Any other path on that line is a stray write — leave the hold for
+the maintainer, because `--record` would certify it with yours. Live members
+hold the old text — re-brief only if it changes what they do *now*.
+
+Plan it as a PR the run's own merge queue lands, never as an edit-and-continue. See references/merge-bot.md.
 
 ## Red flags
 
@@ -1752,3 +1409,15 @@ One running table, updated as events land:
 ```
 
 Plus a queue-depth line: shortlist, supply, whether triage was suggested.
+
+**Do not read a cell early.** A cell's
+comparison is one session holding an admissible row at that cell — its tier
+check passed and its resolved effort is the cell's level — and one at
+`slow-high` whose resolved model and effort differ. Count them per cell, never
+pooled across cells, and stop until
+there are at least ten of them across five or more distinct `run_date`s; below
+that, a comparison count is a number, not evidence. **Report the count the per-cell readout prints,
+never one from any other query:** `~/.fleet/bin/fleet-run cell-readout.mjs`
+prints `<cell> <comparisons> <run_dates> <resolved models>` for each cell past
+that floor and a cell below it only as a count on stderr; a `mixed (…)` models
+column means the cell's history spans more than one model behind its role. See references/pull.md.

package/skills/run-team/references/correction-tickets.md

@@ -64,6 +64,12 @@ under `Verified:` its zero reads as a checked absence.
 
 ## The settling command for "which files read X" is never a literal-path grep
 
+**The settling command for "which files read X" must never be a literal-path
+grep.** Replace the file with `MUTATED` in a throwaway copy, run the suite, and read off
+which suites red: that answers which ones **depend on its contents**, which is
+the question a coverage claim actually needs, and it returns a different set
+from any spelling of the grep.
+
 The path is assembled in more than one spelling here, one of them behind
 a local `read` helper, so a grep for the path string answers with the files that
 merely *name* it — comments included — and misses the files that build it.

package/skills/run-team/references/instruments.md

@@ -1,6 +1,6 @@
 # Instruments: why they are re-checked
 
-Evidence for the rule SKILL.md states in **Rules that fail silently**, keyed by the rule it justifies.
+Evidence for the rule SKILL.md states in **Re-check the instruments before a gate**, keyed by the rule it justifies.
 
 ## Re-check your instruments before every gate decision
 
@@ -17,3 +17,28 @@ direction — a modified instrument raises no error, shows in no PR and leaves
 nothing in the ledger, and it still returns a verdict, just not necessarily the
 right one, so you have no reason to re-check a script you did not know had
 changed.
+
+**A label gate and a CI verdict are also taken by dispatched members, not
+only by you** — the finisher labels, and the merge bot merges on its own
+reading — and neither is dispatched to read SKILL.md, so neither can be
+reached by stating the rule there. Each carries its own copy: the finisher's
+in the instrument re-check block of `agents/fleet-finisher.agent.md`, the merge bot's inside
+`merge-gate.mjs`, step 3 of `run-merge-bot.md`.
+
+## What the instrument set covers
+
+It covers every tracked file under this repo's own plugin component directories
+— `plugin/commands/`, `plugin/scripts/`, `plugin/skills/`, `plugin/agents/`,
+`plugin/workflows/` — the probes, the libraries they source, and these runbooks,
+which you also read from that tree. Not the whole repo: `docs/metrics/` is
+appended by THIS run, so covering it would refuse on the run's own bookkeeping
+every time. It does not cover refs, deliberately: `claim-ticket.sh` creates a
+branch per ticket and `reap.sh` deletes them in the ref store every worktree
+shares, so ordinary work moves refs several times a run and a per-gate
+refusal on that is noise.
+
+## Re-pin first after a mid-run tooling fix
+
+You just changed the instrument set under your own check, and this is the
+only edit that legitimately does; skip it and the next gate refuses on your own
+fix, which teaches you to ignore the refusal.

package/skills/run-team/references/isolation.md

@@ -1,6 +1,6 @@
 # Isolation: filesystem vs stack
 
-Why isolation envelope file not briefing, why private filesystem not private stack. Assertions these justify live in references/pull.md Claiming section and SKILL.md Guards section; evidence here.
+Why isolation envelope file not briefing, why private filesystem not private stack. Assertions these justify live in references/pull.md Claiming section and SKILL.md Failure handling section; evidence here.
 
 ## Materialize the isolation envelope as a file, not a briefing
 
@@ -120,6 +120,13 @@ One flat namespace, generic filenames (`b.min.js`, `probe.mjs`) — one agent ov
 
 The axis is two-sided: the member partitions, and the parent assigns each child's path. `<scratch>` itself is assigned, never invented: the controller resolves it with `scratch-root.mjs` and writes the absolute path into each member's prompt. A member owns one directory — `<scratch>/impl-<N>/` for an implementer, `<scratch>/pr<N>/…` on the review side — and every agent it dispatches gets a directory under that one, unique to that child and never shared, written into the child's prompt as an absolute path; a child never derives its own. The review side is already laid out this way: `review-core.mjs` makes the run root `<scratch>/pr<N>/run-XXXXXXXX/` with `mktemp` — it appends `pr<N>/` to the scratch root it is handed and refuses a scratch already ending in one, so a review runner is given the root, never `<scratch>/pr<N>` — then writes `<run>/<dim>/` into each specialist's prompt and `<run>/verify-<dim>/f<i>-l<j>/` into each refuter's. A fix-applier makes its own run root the same way — `<scratch>/pr<N>/fix-XXXXXXXX/` with `mktemp` — then resolves `<run>/<finding>/` to an absolute path for the refuter it dispatches on a suggestion; the bare `<scratch>/pr<N>/<finding>/` is not that path, since finding ids restart at 1 each fix-applier round too, and a later round on the same PR would reach for the same directory a prior round's refuter left fixtures in. An implementer's child gets `<scratch>/impl-<N>/<childName>/`, named after its dispatch name. Refuters are grandchildren, not members, which is why the member partition alone is not the rule: the agents that actually collided were ones no member rule reaches, and a parent-assigned path is what reaches them. Read from the object store at a pinned ref, write only under own path.
 
+## The scratch root is computed, never invented and never recorded
+
+No harness supplies a scratch directory to a member, so a member left to name its own
+invents one — and the liveness read in **The tick's rows**, which looks at the files under the
+directory a member's own prompt assigned it, then watches a directory nobody
+else can find.
+
 ## IDE/harness diagnostics attribute by bare filename, with no path
 
 Probe copies carry same filenames as real tree, so specialist's throwaway mutation surfaces as errors that read exactly like live worktree's — and line numbers can plausibly line up with real in-flight edits. Never relay diagnostic without reproducing it in that member's specific worktree (re-run the check that raised it — the typechecker, the linter — from there). Ran twice in one session: clean first time (sibling's probe), genuinely broken second. Telling implementer to chase phantom in file it is mid-rewrite on is expensive failure.
@@ -129,6 +136,15 @@ Probe copies carry same filenames as real tree, so specialist's throwaway mutati
 Measured 2026-09-09 in a throwaway clone (`/tmp/fleet-probe`)
 that never touched the real checkout.
 
+## Claim, release and reap are unchanged on omp
+
+**Claim, release and reap are unchanged on omp.** `claim-ticket.sh`,
+`release-ticket.sh`, `reap.sh` and `inflight.sh` are git-native and operate on
+the single shared ref store every worktree and the main checkout read and
+write directly (**Phase 1**, the tick's reap, and `release-ticket.sh` under
+**Failure handling**); nothing in omp's `task` model touches that
+store, so none of the four scripts carries a dialect branch.
+
 ## A fleet member is never dispatched with omp's `isolated: true`
 
 **A fleet member is never dispatched with omp's `isolated: true`.** Measured:
@@ -220,6 +236,12 @@ the worktree, `git worktree list` and `git branch --list` from the main
 checkout reported the claim unchanged before, during and after — `inflight.sh`
 hides nothing from omp.
 
+## The controller's own cwd stays the main checkout
+
+Nothing in the dispatch recipe above — the cwd recipe, the
+isolated-workspace measurement, or the teardown scoping — moves
+where the controller itself runs from.
+
 ## A pattern kill reaches siblings
 
 **A pattern kill reaches siblings — the implementer, fix-applier and finisher briefs forbid it.** `pkill -f
@@ -262,3 +284,29 @@ get is not yours to choose — members are briefed on `./agent-test` with the
 arguments the Test entrypoint takes, and the runner hands them on exactly as
 its caller's shell expanded them. Clearing your own leftover process needs its
 PID, not a pattern.
+
+## Do not guess the victim — the blast radius is the machine, not the Pull
+
+In the `pkill -f` incident "A pattern kill reaches siblings" measures, the controller reasoned from dispatch scope to "almost
+certainly `impl-<N>`" and told the maintainer so; the named member then proved
+it was not the victim (it had never invoked those files standalone, and its
+mutation baselines post-dated the window). Idle members of *previous* runs,
+other omp sessions on the same machine, and the maintainer's own shell are
+all `pkill -f` targets and none of them appear in your ledger.
+
+## A warning acted on silently is indistinguishable from one that never arrived
+
+The same `pkill -f` incident: the controller's warning DID reach the member,
+which re-ran, found nothing changed, and said nothing — correctly reading
+"send once, never re-send" as covering it. The controller then had to spend a
+round trip asking whether its own outbox was lossy. So the briefs say that
+**confirmation state includes warnings received and acted on, even
+when the outcome is no change** — one line, in the report the member already
+owes. That is the cheap half of the *never read silence as assent* rule, paid
+by the member rather than by the controller's guesswork.
+
+## Specialist tree isolation is `review-and-fix.md`'s job
+
+It owns the object-store rule, the two-tree split, snapshot provisioning, and
+which suites a snapshot cannot validly run. Your only duty is to *not*
+contradict it.

package/skills/run-team/references/member-lifecycle.md

@@ -1,6 +1,6 @@
 # Member lifecycle: naming, fresh context, recovery
 
-Why member name load-bearing, why every member single-use, how a member's job outcome (`completed`/`failed`/`cancelled`) and peer liveness (`running`/`idle`/`parked`) decide its recovery. Assertions these justify live in SKILL.md's "Rules that fail silently", wake table, Reading a review result, Failure handling sections; evidence here.
+Why member name load-bearing, why every member single-use, how a member's job outcome (`completed`/`failed`/`cancelled`) and peer liveness (`running`/`idle`/`parked`) decide its recovery. Assertions these justify live in SKILL.md's wake table, Dispatching the members a wake names, Reading a review result, A member's claims, Failure handling sections; evidence here.
 
 ## Every member is named
 
@@ -58,6 +58,28 @@ Reviewers go idle waiting on CI, won't resume alone — rebased, pushed, stopped
 
 Liveness says nothing: `idle` means "not currently executing", not "done"; finished member's finding may never arrive. In one run every member that looked dead had its work in git or on PR — pushed commits, self-removed label, applied ruling. Read `gh pr view`, `gh run view`, `git -C <worktree> status` before messaging: one command settles what round-trip usually doesn't, and member that ignored one ping tends to ignore second. When you message, send specific next action, never "what is your status".
 
+## A report is delivered, not implied by ending a turn
+
+**A report is delivered, not implied by ending a turn.** Every member owes
+the controller one report naming its outcome before it exits — including a
+member whose prompt carries no explicit report line. A member that does the work
+correctly and ends its turn has reported nothing: the controller learns the
+outcome only by re-reading artifacts and pinging, and a finding held only in
+that member's context is lost. Members did exactly this in one run —
+finishers, a reviewer and merge bots alike, the work done and only the
+delivery missing. Every brief's report paragraph says it.
+
+## You never write the do-not-acknowledge line yourself
+
+**The implementer, fix-applier, finisher, merge-bot and review-runner briefs
+each tell the member you do not acknowledge reports; you never write that line
+yourself.** A member cannot see whether its report arrived, so silence
+from you is indistinguishable from loss and it re-sends — three members did in
+one run, each burning a turn, and in all three the original had in fact arrived.
+Each of those templates under `briefs/` carries the line: *"The controller does
+not acknowledge reports. Send once and exit; never re-send unless the controller
+asks by name."*
+
 ## A missing report is not evidence the member failed to send one
 
 **But a missing report is NOT evidence the member failed to send one — the
@@ -84,6 +106,15 @@ Note this cuts against the paragraph above only in appearance: the default stays
 *send once*, because unprompted re-sends were measured 2-to-1 false. The ask is
 the controller's move, not the member's.
 
+## Never read a member's silence as assent
+
+**Your OWN messages can vanish the same way, and that half is not recoverable by
+a re-send.** Two controller rulings were lost in one run, both with a
+`success: true` receipt: a member proceeded on its stated default and filed a
+tracker issue the lost ruling had said not to file. The confirmation-state
+sentence SKILL.md's **A member's claims** requires is the only thing that made
+either loss visible.
+
 ## A member runs its test suite in the foreground and blocks on it
 
 **A member runs its test suite in the foreground and blocks on it.**

package/skills/run-team/references/merge-bot.md

@@ -1,6 +1,6 @@
 # Landing a change on main
 
-Evidence for the rules SKILL.md states in **Fix the tooling mid-run** and in the `ready-to-merge` wake, keyed by the rule each justifies.
+Evidence for the rules SKILL.md states in **A mid-run tooling fix** and in the `ready-to-merge` wake, keyed by the rule each justifies.
 
 ## A mid-run tooling fix lands through a PR
 

package/skills/run-team/references/pull.md

@@ -426,6 +426,71 @@ is not enough either: the two rows must actually have RUN a different model or
 effort, because a deliberate dispatch whose two sides resolve to the same model
 (a `modelRoles` override, measured on omp 2026-09-12) controls nothing.
 
+## Accumulate per PR, never conclude a tier result inside one run
+
+The unit is the PR —
+supply is one Pull per free slot, so there are no implementer batches. The
+guard this section speaks of is SKILL.md's **Guard: accumulate per PR, never
+conclude inside one run**, under **Reading a review result**.
+
+**Why not decide inside one run.** A run holds 2-3 implementer PRs, and ticket
+difficulty swamps the tier effect — a gojq parity harness and a two-statement
+shell reorder are not comparable units. Finding-counts are not comparable either:
+`selectDimensions` trims the fan-out by diff profile, so one PR fields 29 agents
+over six dimensions and its sibling fields 8 over three. And the fleet is not
+stationary — this prompt gets edited mid-run when a defect earns it. Hence a
+binary outcome per PR, accumulating, rather than a per-run verdict.
+
+**Why the rows this guard fired on could not answer the tier question, and this
+is the load-bearing part.** Until the 2026-08-16 revert, `class` and `tier` were
+perfectly confounded: routine always ran `sonnet`, correction always ran top
+tier. So the comparison the file invites — routine-at-sonnet against
+correction-at-top-tier — measures **class, not tier**, because those classes fail
+in different ways by construction: corrections ship false claims in prose,
+routines ship incomplete or regressing code. A run that "mixes both" does not fix
+it. **Only a same-class comparison across tiers is informative**, and the old
+rule could not produce one, since no routine ticket ever ran at top tier.
+
+**That last sentence is no longer true, and this is the part to re-read.** Since
+the revert every routine ticket runs at top tier, so the file now holds 55
+`routine`/`opus` rows against 11 `routine`/`sonnet` (as of 2026-08-28, 103 rows
+— recount before citing). The same-class comparison the paragraph above calls
+the only informative one therefore EXISTS now. It is still not clean: the two
+groups are split almost entirely by calendar date, so it measures prompt
+evolution at least as much as tier. Recount
+both, and every other figure in this section, with:
+
+```bash
+grep -vc '^#' docs/metrics/tier-outcomes.tsv
+awk -F'\t' '!/^#/ && $4=="routine" {n++; d[$1]=1; if($6=="no") no++} \
+  END{print n, length(d), no+0}' docs/metrics/tier-outcomes.tsv
+awk -F'\t' '!/^#/ && $4=="routine" {t[$5]++; if($6=="no") f[$5]++} \
+  END{for(k in t) print k, t[k], f[k]+0}' docs/metrics/tier-outcomes.tsv
+```
+
+**These rows are the historical corpus, and nothing appended to them fixes the
+confound.** What fixes it is the exploration draw in the dispatch rule above:
+one implementer in every five — every one, during burn-in — runs at a drawn
+cell beside the policy cell's, against the same prompts on the same day, so
+the comparison stops depending on which tier history happened to leave in
+which week. Read each cell's comparisons, not the whole-file split, once there
+are enough of them.
+
+**So read what the guard actually established: routine tickets sometimes fail to
+close their own ticket. Not that `sonnet` caused it.** The revert is the
+pre-committed rule being honoured, not a measurement. Restoring a cheap tier is
+still the maintainer's call and still a change to the dispatch rule — but the
+deliberate control it used to require is no longer something anyone has to
+authorize one ticket at a time: the exploration draw above produces one in
+every five Pulls by construction.
+
+The last guard fired with n=1 on the control side. The pre-cell pair query
+counted pairs that are no cell's comparisons, and the query before that one
+counted every session whose implementers merely differed, so it cleared the
+cell floor SKILL.md's **Report** states — at least ten comparisons across five
+or more distinct `run_date`s — by an order of magnitude while the controlled
+comparison did not exist yet.
+
 ## Why the implementer body carries enumerate-and-declare
 
 Why the agent body carries what it does — read this before editing any
@@ -452,6 +517,19 @@ mention of the controller is not a statement that the reader is one of its
 members. That skill keeps its condition, so a solo session still runs the
 interactive path; this block is what puts a member on the fleet side of it.
 
+**Prose-first** and **wrongly-REFUSE** are not padding — they are the case
+which shipped with **enumerate-and-declare** already in its prompt. It missed a
+shape its own ticket named in passing, because it enumerated from the mechanism
+instead of the text; and it introduced a regression refusing every `node --test`
+flag, because it enumerated what the guard should catch and never what it could
+wrongly refuse.
+
+The commit-incrementally block is not optional. A member that goes idle mid-task
+leaves its diff only in the worktree, and the controller cannot reap, replace,
+or even see it — `worktree-audit.sh`'s committed-vs-uncommitted split is exactly
+what decides whether a replacement redoes or destroys work. Observed twice in
+one run.
+
 ## Default: In-flight bound 5
 
 **Default: In-flight bound 5, fixed for the run.** The level is set by load, not

package/skills/run-team/references/reviewers.md

@@ -27,6 +27,10 @@ in-between width cannot be told apart from a shifted one. The `note` field is
 free text and sits before those four, so the script refuses a tab or newline in
 it: one tab would shift all four for that row alone.
 
+**Phase 0 does not size anything** — it shortlists, a Pull claims, and
+the sizing run happens inside the member after both, which is why the verdict
+has to travel in the member's report rather than being something you already hold.
+
 ## Know the trim before you rely on it
 
 **Know the trim before you rely on it — it is wider than `docsOnly` suggests.**
@@ -135,3 +139,12 @@ reviewed and is not.
 ## The review's scratch is the scratch root, not its partition
 
 **`scratch` is the scratch root itself, the absolute path `scratch-root.mjs` prints, never the review side's `<scratch>/pr<N>` partition:** the review creates `pr<N>/` under it, so a `pr<N>` passed in nests every run root at `pr<N>/pr<N>/`, and the review refuses a `scratch` whose last component is `pr` plus digits before dispatching anything.
+
+## Cross-check what members report, and distrust negative claims hardest
+
+Wrong often enough
+to matter, and a confident wrong report from a reviewer flips a verdict.
+
+"Nothing else references this", "the sweep
+is clean" — most likely false, least likely checked: a grep that found nothing
+looks like a grep never run.

package/skills/run-team/references/tick-rows.md

@@ -14,7 +14,7 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   lifted), the implementer row's `unclaimed=` prints that same
   `<u>`, not the refreshed file's count.
 - `SUGGEST /triage, hold idle` — nothing is admissible after the refresh.
-  Suggest, never run (**Queue depth**). A head whose Pull already ended in
+  Suggest, never run. A head whose Pull already ended in
   this run is not counted toward the refresh, so a shortlist of only such
   heads triggers the refresh before this row prints. It is not printed while the
   refreshed shortlist holds a head whose Pull ended only on an exclusion whose
@@ -147,8 +147,8 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   HEAD is off the run's branch. Never revert the
   paths yourself, and never re-baseline over paths nobody has resolved. The
   changes of yours that trip it are a mid-run tooling fix edited in this
-  checkout and the close-out commit's round trip through a branch; **Fix the
-  tooling mid-run** and the commit section of references/close-out.md say how
+  checkout and the close-out commit's round trip through a branch; SKILL.md's
+  **A mid-run tooling fix** and the commit section of references/close-out.md say how
   each is cleared.
   The maintainer may instead ignore a stray path that is untracked and new since the baseline: an entry in `.git/info/exclude` or in the global excludes file hides it from the check, and the hold clears on the next tick with no re-baseline. Ignoring never clears a tracked or staged file's change, which `git status` reports whatever the excludes say, nor a pattern that also matches a path the baseline holds, which then reads as changed. Ignoring is the maintainer's decision; the controller never writes an exclude or a `.gitignore` entry. Keep the pattern narrow, because an ignored path is invisible to this check, so a member write that matches it is never seen.
 - `MAIN-CHECKOUT-UNKNOWN …` with `HOLD (main checkout unknown)` — the tick
@@ -245,3 +245,11 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   could-not-look (exit 2), never a mismatch. The settle runs neither command,
   and a repository whose Recipe cache is absent or refused has no gate; the
   record is the member's own word, at the trust level of its report.
+
+## Read the depth off the tick, never derive it by hand
+
+**Do not re-derive this by hand — `fleet-tick.mjs` computes it.** The deficit is then *computed, not remembered*, which is
+the whole point: a table you must remember to consult is one you will not
+consult under a merge-side event storm, and that is how implementers reached
+0/target with ~57 `ready-for-agent` in supply while nobody
+noticed.