@feigi/fleet-ctl 3.32.1 → 3.34.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1536,8 +1536,8 @@ for a token on a ticket's line — never a hand edit.
1536
1536
  | Wake | Record, then tick |
1537
1537
  |---|---|
1538
1538
  | Implementer report | `verify-sha.sh`; `ledger.mjs settle impl-<N>=PR#<M>`, or `=bailed` and relabel by cause (**Implementer bails before implementing**, below) |
1539
- | Review workflow notification / `review-pr-<n>` report | write `<scratch>/review-<pr>.json`; `reviewed=<head>:<survived>/<refuted>/<unverified>` on the PR's row (**Reviewers**) |
1540
- | Fix-applier report | `ledger.mjs settle fix-pr-<M>=…`; for a fix-applier that answered a review — not one that cleared a conflict hold, which has no review file — `~/.fleet/bin/fleet-run dispositions-check.mjs --member <that member> --scratch <scratch>`, from the checkout root: it judges `<scratch>/dispositions-<M>.json` against `<scratch>/review-<M>.json`, writes `dispositions-ok=`, `dispositions-mismatch=`, `dispositions-escalate=` or `dispositions-unchecked=<member>:<head>` onto the PR's row itself, and exits 1 on a mismatch, an escalation or an unchecked, naming each violating or escalated entry's bucket and index, a violation its rule too, and each entry whose filed issue `gh` could not read — **Then dispatch a fix-applier** says what a mismatch asks of you, the gate paragraph below what an escalation or an unchecked does; copy the refutations it reversed — the record's `refuted` entries — to `ruled`; `ledger.mjs filed <N> "<subject>"` for each `unrecorded:` line |
1539
+ | Review workflow notification / `review-pr-<n>` report | the result file is `<scratch>/pr<pr>/<run>/review.json`, `<run>` the review's own `run-XXXXXXXX` run root; `reviewed=<head>:<survived>/<refuted>/<unverified>:<run>` on the PR's row (**Reviewers**) |
1540
+ | Fix-applier report | `ledger.mjs settle fix-pr-<M>=…`; for a fix-applier that answered a review — not one that cleared a conflict hold, which has no review file — `~/.fleet/bin/fleet-run dispositions-check.mjs --member <that member> --scratch <scratch>`, from the checkout root: it judges that member's own record `<scratch>/dispositions-<member>.json` against the review file the PR's latest `reviewed=` names, `<scratch>/pr<M>/<run>/review.json`, writes `dispositions-ok=`, `dispositions-mismatch=`, `dispositions-escalate=` or `dispositions-unchecked=<member>:<run>` onto the PR's row itself, and exits 1 on a mismatch, an escalation or an unchecked, naming each violating or escalated entry's bucket and index, a violation its rule too, and each entry whose filed issue `gh` could not read — **Then dispatch a fix-applier** says what a mismatch asks of you, the gate paragraph below what an escalation or an unchecked does; copy the refutations it reversed — the record's `refuted` entries — to `ruled`; `ledger.mjs filed <N> "<subject>"` for each `unrecorded:` line |
1541
1541
  | Finisher report | `ledger.mjs settle finisher-pr-<M>=labelled` as reported, even when its read-back lacks `ready-to-merge` — the tick's `DISPATCH finisher PR#<M>` catches that next. A **repair** finisher's (one sent on that line) read-back lacking it also gets `gh pr comment <M>` with both finishers' read-backs: the one-shot escalation, where halts comment. `ledger.mjs filed <N> "<subject>"` for each `unrecorded:` line |
1542
1542
  | Finisher report (halted) | `ledger.mjs settle finisher-pr-<M>=halted:<cause>`; `gh pr comment <M>` with the finisher's halt report, cause and evidence; `ledger.mjs filed <N> "<subject>"` for each `unrecorded:` line; then the per-cause rule (**Resolving a finisher halt**, below) |
1543
1543
  | Finisher report (failed / killed) | `ledger.mjs settle finisher-pr-<M>=failed` for a finisher that crashed or gave up, `=killed` for one that was killed; no label, and the tick prints no dispatch for it. The cockpit flags the PR `finisher:failed` / `finisher:killed` at severity 4 and you resolve it by hand (**Resolving a finisher that died**, below) |
@@ -2109,7 +2109,7 @@ report recovery, never the exit code alone.
2109
2109
  The tick names every PR owed one — `DISPATCH review PR#<M>`, oldest first —
2110
2110
  and each gets one review, once per PR:
2111
2111
 
2112
- a `task` member named `review-pr-<pr#>`, agent `fleet-review-runner`, its prompt the five args `pr`, `branch`, `worktree`, `testCmd` and `scratch` — it loads `review-eval.mjs` through the Resolver (`~/.fleet/bin/fleet-run --path review-eval.mjs`), awaits `runReviewOnOmp` in its own kernel, writes the result file and reports; record `review=member:review-pr-<pr#>` on the PR's row before the dispatch call. **`scratch` is the scratch root itself, 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.
2112
+ a `task` member named `review-pr-<pr#>`, agent `fleet-review-runner`, its prompt the five args `pr`, `branch`, `worktree`, `testCmd` and `scratch` — it loads `review-eval.mjs` through the Resolver (`~/.fleet/bin/fleet-run --path review-eval.mjs`), awaits `runReviewOnOmp` in its own kernel, writes the result file into the review's own run root and reports its path and `reviewed=` token; record `review=member:review-pr-<pr#>` on the PR's row before the dispatch call. **`scratch` is the scratch root itself, 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.
2113
2113
 
2114
2114
  Write the `review=` token with `ledger.mjs row`, which **replaces the whole
2115
2115
  line**, so carry every other field. The tick counts in-flight reviews off the
@@ -2169,13 +2169,19 @@ slots a review does not hold still serve fix-appliers.
2169
2169
 
2170
2170
  It returns `{pr, head, resume, testEnvironment, dimensionsRun, dimensionsUnrun, cwdAudit, counts, snapshot, survived, refuted, unverified}` —
2171
2171
  the **digest** first, then the snapshot and the findings — and it lands as
2172
- one artefact, `<scratch>/review-<pr>.json`, holding that bare object: the
2173
- `review-pr-<pr#>` runner writes it and reports the digest and the path.
2172
+ one artefact, `<scratch>/pr<pr>/<run>/review.json`, holding that bare object.
2173
+ `<run>` is the review's own `run-XXXXXXXX` run root, the one its snapshot sits
2174
+ in, so a second review of the PR — at the same head or another — writes a file
2175
+ of its own and never replaces the first. The `review-pr-<pr#>` runner writes it
2176
+ and reports the digest, the path and the `reviewed=` token naming that run.
2174
2177
 
2175
2178
  **You read the digest; the findings are the fix-applier's.**
2176
- `jq '{pr, head, resume, testEnvironment, dimensionsRun, dimensionsUnrun, cwdAudit, counts}' <scratch>/review-<pr>.json`
2177
- is the whole of your read, and it is what you record: `reviewed=<head>:<survived>/<refuted>/<unverified>`,
2178
- off `head` and `counts`, on the PR's row. Findings never enter your context —
2179
+ `jq '{pr, head, resume, testEnvironment, dimensionsRun, dimensionsUnrun, cwdAudit, counts}' <scratch>/pr<pr>/<run>/review.json`
2180
+ is the whole of your read, and it is what you record: `reviewed=<head>:<survived>/<refuted>/<unverified>:<run>`,
2181
+ off `head`, `counts` and the run root's name — the runner's `ledger` field — on
2182
+ the PR's row. Every later path to the review is built from that token, before a
2183
+ restart or after one: `<scratch>/pr<pr>/<run>/review.json`, `<run>` off the PR's
2184
+ latest `reviewed=`. Findings never enter your context —
2179
2185
  a result runs 26-61 KB, 7-15k tokens that used to land in yours and then again,
2180
2186
  up to ~10k characters, in every fix-applier prompt you wrote. The fix-applier
2181
2187
  reads every one off the file and makes every ruling on them
@@ -2192,11 +2198,13 @@ the environment, and this field carries which line of the cut failed. The
2192
2198
  fix-applier reads it before acting on any count from the shared test run; you
2193
2199
  read it so a degraded review never passes for a clean one.
2194
2200
  `unverified` is *not* "checked and cleared" — a `suggestion` skips the pass by
2195
- policy, and a finding whose refuters all crashed lands there too. Both go to the
2196
- fix-applier with the rest, in the file; never rule on them yourself.
2197
- **`refutersDispatched`, carried on every finding, is what tells those two
2198
- apart** — zero is the policy skip, above zero with no surviving vote is the
2199
- crash — so the population is read off that field rather than off severity,
2201
+ policy, and a finding whose refuters all crashed or abstained lands there too.
2202
+ All go to the fix-applier with the rest, in the file; never rule on them yourself.
2203
+ **`refutersDispatched`, carried on every finding, is what tells the skip
2204
+ apart** — zero is the policy skip, above zero with no deciding vote is a
2205
+ refuter pass that decided nothing — and `refutersInconclusive` splits that
2206
+ one: the refuters it counts abstained, every other one dispatched crashed. So
2207
+ the population is read off those fields rather than off severity,
2200
2208
  which records only how much a finding would matter if true. `resume` is
2201
2209
  non-null exactly when a specialist or a refuter pair crashed again after the
2202
2210
  review's own in-run retry, and **resume beats handing a crash-heavy review
@@ -2258,8 +2266,8 @@ named member per PR, `fix-pr-<pr#>` (the next suffix when that name is already
2258
2266
  on record), never the PR's
2259
2267
  implementer, recorded with `ledger.mjs dispatch <pr#> fix-pr-<pr#>` before the
2260
2268
  call. Its prompt carries the PR number, the worktree abs path, the PR's branch,
2261
- the same `testCmd` you passed the review, and the **path** `<scratch>/review-<pr>.json`
2262
- — never the findings. The fix-applier owns every per-PR ruling you once made
2269
+ the same `testCmd` you passed the review, and the **path** `<scratch>/pr<pr>/<run>/review.json`,
2270
+ `<run>` off the PR's latest `reviewed=` — never the findings. The fix-applier owns every per-PR ruling you once made
2263
2271
  before dispatch: both mutual-exclusion scans, the suggested-fix re-derivation,
2264
2272
  `refuted=false` ≠ apply, per-site measurement for a sibling-site extension, and
2265
2273
  `testEnvironment`/`cwdAudit` before any result of the shared test run. It
@@ -2293,17 +2301,17 @@ bot refuses it `head-moved-after-label-#<M>`: a fresh finisher, per **Failure
2293
2301
  handling**.
2294
2302
 
2295
2303
  **A `DISPATCH fix-pr PR#<M>` on a dispositions mismatch** — the PR's row carries
2296
- `dispositions-mismatch=<member>:<head>` for its latest review, and no later
2304
+ `dispositions-mismatch=<member>:<run>` for its latest review's run, and no later
2297
2305
  fix-applier has landed — is one automatic retry, a review fix-applier named the
2298
2306
  next suffix (`fix-pr-<M>-b`) and dispatched like the first. Its prompt is the
2299
- first one's, with two paths and a list copied in: the review file
2300
- `<scratch>/review-<M>.json`, the disposition record `<scratch>/dispositions-<M>.json`
2301
- it rewrites, and the check's violation list **verbatim** — the lines
2307
+ first one's, with three paths and a list copied in: the review file
2308
+ `<scratch>/pr<M>/<run>/review.json`, the mismatched member's record `<scratch>/dispositions-<member>.json`
2309
+ it starts from, its own record `<scratch>/dispositions-<its own name>.json` it writes, and the check's violation list **verbatim** — the lines
2302
2310
  `dispositions-check.mjs` printed, each naming a bucket, an index and a rule;
2303
- re-run the check for the mismatched member to reprint them. It rewrites the
2311
+ re-run the check for the mismatched member to reprint them. It writes its own
2304
2312
  record, and when it reports you run the check for it exactly as for the first
2305
2313
  one. `ok` ends it. A second failure on the same review is written as
2306
- `dispositions-escalate=fix-pr-<M>-b:<head>` in place of a mismatch: the tick
2314
+ `dispositions-escalate=fix-pr-<M>-b:<run>` in place of a mismatch: the tick
2307
2315
  prints no `DISPATCH fix-pr` for it, `dispatch` refuses the finisher naming
2308
2316
  `dispositions escalate`, and you post the check's output with `gh pr comment <M>`
2309
2317
  and flag the PR for a human. A new review of the PR counts again from none.
@@ -2378,7 +2386,7 @@ all.
2378
2386
  > review already ran — and steps 4 and 6: the controller owns the CI wait and
2379
2387
  > dispatches the finisher.
2380
2388
  >
2381
- > **The review's result is `<scratch>/review-<pr>.json`** — the digest first
2389
+ > **The review's result is `<scratch>/pr<pr>/<run>/review.json`** — the digest first
2382
2390
  > (`jq '{pr, head, resume, testEnvironment, dimensionsRun, dimensionsUnrun, cwdAudit, counts}'`),
2383
2391
  > then every finding (`jq '.survived'`, `jq '.unverified'`, `jq '.refuted'`).
2384
2392
  > Read it through `review-and-fix.md`'s **The review result file**, which holds
@@ -2400,14 +2408,18 @@ all.
2400
2408
  > its zero counts only after the same command finds a line known to match.**
2401
2409
  >
2402
2410
  > **Apply `survived` findings. A finding in `unverified` whose refuters ran and
2403
- > crashed always defers** — and which of the two it is, you read off
2404
- > `refutersDispatched`, never off severity and never off an empty vote list:
2405
- > above zero with nothing surviving means every refuter dispatched against it
2406
- > died, and at `critical` that is every one of them. Severity records how much a
2411
+ > crashed or abstained always defers** — and which it is, you read off
2412
+ > `refutersDispatched` and `refutersInconclusive`, never off severity and never
2413
+ > off an empty vote list: `refutersDispatched` above zero with nothing decided
2414
+ > means every refuter dispatched against it died or abstained, and
2415
+ > `refutersInconclusive` counts the ones that abstained. Severity records how much a
2407
2416
  > finding would matter if true, never whether anything looked. Say *in the
2408
- > deferral* that its refuters crashed rather than that it went unchecked — the
2409
- > review re-dispatched each crash once already and reports what died again, so
2410
- > a deferral that names the crash can still be re-verified. **A `suggestion` is also in `unverified`,
2417
+ > deferral* which it was rather than that it went unchecked. Name a crash as
2418
+ > crashed refuters — the review re-dispatched each crash once already and
2419
+ > reports what died again, so a deferral that names the crash can still be
2420
+ > re-verified. An abstention is not a crash: cite the inconclusive runs each
2421
+ > abstaining refuter named in its `reason`, and never describe its refuters as
2422
+ > crashed. **A `suggestion` is also in `unverified`,
2411
2423
  > for a different reason — `refutersDispatched` of zero, the 0-refuter budget
2412
2424
  > the review gives that band by policy — and the rule below, not this one,
2413
2425
  > covers it.**
@@ -2439,7 +2451,43 @@ all.
2439
2451
  > > empty still enables color, so it is not a control. State your search scope
2440
2452
  > > AND what your pattern would have missed. A grep over one ref does not
2441
2453
  > > support a claim about history; a pattern built from the token a diff removed
2442
- > > does not support a claim that the category is empty. A failure injection with
2454
+ > > does not support a claim that the category is empty.
2455
+ > >
2456
+ > > When your check scores a mutant killed or a test red, run only in your own
2457
+ > > copy of the tree, and these rules decide it and nothing else:
2458
+ > >
2459
+ > > **Valid red:** a run that completed — the command returned on its own, with no
2460
+ > > signal and no timeout, deadline or kill having fired — in which the test the
2461
+ > > claim names is reported failing. An exit ≠ 0 with no failing test is not red,
2462
+ > > and a different test failing is not red for this claim. A red in the full
2463
+ > > suite only triggers a narrowed run; it is never evidence on its own.
2464
+ > >
2465
+ > > **Narrowed run:** the Test entrypoint with arguments appended, `<testCmd>
2466
+ > > <args>`. That appended arguments reach the Test entrypoint is all that is
2467
+ > > promised about them, so a narrowed run counts only if it reports `tests` > 0
2468
+ > > and its output names the claimed test. If no narrowing can be proven, run the
2469
+ > > full `<testCmd>` and read the named test's own result from its output.
2470
+ > >
2471
+ > > **Kill:** the mutant produced a valid red in a narrowed run, and the same
2472
+ > > narrowed command, in the same tree with the mutant reverted, ran a valid green
2473
+ > > with the named test passing — completed, exit 0, `tests` > 0, `cancelled` 0. A
2474
+ > > completed exit ≠ 0 with the named test not failing is not a kill, and no kill
2475
+ > > stands without that green run on the unmutated tree. The result is
2476
+ > > inconclusive, never a kill, when the red does not reproduce in the narrowed
2477
+ > > run, when the unmutated tree is red too, or when no usable run exists.
2478
+ > >
2479
+ > > **Evidence line:** every kill and every valid red you claim carries one line
2480
+ > > in the claim's own free-text field: `red: <cmd> → exit N, fail K incl <test>;
2481
+ > > baseline: <cmd> → exit 0, <test> pass`. A failing-test finding filed off the
2482
+ > > review's shared run carries the `red:` half alone.
2483
+ > >
2484
+ > > This refuter has no abstain: a run that could not decide — neither a valid red
2485
+ > > nor a valid green — is no kill and no refutation, so name the runs in
2486
+ > > `reason`, each with its evidence line, and leave `refuted` true, so the
2487
+ > > suggestion defers on the record instead of applying on a check that decided
2488
+ > > nothing.
2489
+ > >
2490
+ > > A failure injection with
2443
2491
  > > no positive control has produced NO result, never a negative one. Before you
2444
2492
  > > read an injected fault — an env var, an argv word, a mutant — as having had
2445
2493
  > > no effect, prove the injection reached the child: one run whose output
@@ -2530,11 +2578,42 @@ all.
2530
2578
  > claim, never your patch.
2531
2579
  >
2532
2580
  > **A test you ADD must kill its own mutant** — break what it pins, confirm it and
2533
- > only it goes red, restore. **Then a change it should *not* catch, staying
2534
- > green** — else you proved it fails, not that it discriminates: a pin asserting
2535
- > whole-file text clears "it and only it goes red" and still reddens on any edit
2536
- > (measured). A green suite says nothing about a new test: one pin this run
2537
- > survived the exact mutation it was named for.
2581
+ > only it goes red and that the red is a kill by the rules below, restore. **Then
2582
+ > a change it should *not* catch, staying green** — else you proved it fails, not
2583
+ > that it discriminates: a pin asserting whole-file text clears "it and only it
2584
+ > goes red" and still reddens on any edit (measured). A green suite says nothing
2585
+ > about a new test: one pin this run survived the exact mutation it was named for.
2586
+ >
2587
+ > **Valid red:** a run that completed — the command returned on its own, with
2588
+ > no signal and no timeout, deadline or kill having fired — in which the test
2589
+ > the claim names is reported failing. An exit ≠ 0 with no failing test is not
2590
+ > red, and a different test failing is not red for this claim. A red in the full
2591
+ > suite only triggers a narrowed run; it is never evidence on its own.
2592
+ >
2593
+ > **Narrowed run:** the Test entrypoint with arguments appended,
2594
+ > `<testCmd> <args>`. That appended arguments reach the Test entrypoint is all
2595
+ > that is promised about them, so a narrowed run counts only if it reports
2596
+ > `tests` > 0 and its output names the claimed test. If no narrowing can be
2597
+ > proven, run the full `<testCmd>` and read the named test's own result from its
2598
+ > output.
2599
+ >
2600
+ > **Kill:** the mutant produced a valid red in a narrowed run, and the same
2601
+ > narrowed command, in the same tree with the mutant reverted, ran a valid green
2602
+ > with the named test passing — completed, exit 0, `tests` > 0, `cancelled` 0. A
2603
+ > completed exit ≠ 0 with the named test not failing is not a kill, and no kill
2604
+ > stands without that green run on the unmutated tree. The result is
2605
+ > inconclusive, never a kill, when the red does not reproduce in the narrowed
2606
+ > run, when the unmutated tree is red too, or when no usable run exists.
2607
+ >
2608
+ > **Evidence line:** every kill and every valid red you claim carries one line
2609
+ > in the claim's own free-text field:
2610
+ > `red: <cmd> → exit N, fail K incl <test>; baseline: <cmd> → exit 0, <test> pass`.
2611
+ > A failing-test finding filed off the review's shared run carries the `red:`
2612
+ > half alone.
2613
+ >
2614
+ > An inconclusive result proves nothing about the test: do not report the test
2615
+ > as proven, and measure again in a clean state. Put each kill's evidence line in
2616
+ > your report, beside the test result.
2538
2617
  >
2539
2618
  > **A mutation that never landed is not a green — it is a cell that did not
2540
2619
  > run.** Same rule for any fault you inject to see what breaks: prove the
@@ -2583,10 +2662,13 @@ all.
2583
2662
  > that was two commits stale, and a finisher dispatched on either would have
2584
2663
  > halted on a diverged head.
2585
2664
  >
2586
- > **Before you report, write every ruling to `<scratch>/dispositions-<pr>.json`**,
2587
- > beside the review file — the record the controller checks with
2665
+ > **Before you report, write every ruling to `<scratch>/dispositions-<your name>.json`**,
2666
+ > `<your name>` the `fix-pr-<pr>[-x]` you were dispatched as — the record the controller checks with
2588
2667
  > `dispositions-check.mjs` before it dispatches any finisher. It is
2589
- > `{"head": "<the review file's head>", "entries": [ … ]}`: one entry per
2668
+ > `{"head": "<the review file's head>", "run": "<the run root's name in the review path>", "entries": [ … ]}`
2669
+ > — `run` the `<run>` of the review path above, which the check holds against the
2670
+ > review the PR's latest `reviewed=` names: a record written against an earlier
2671
+ > review, a same-head one included, is a mismatch. One entry per
2590
2672
  > `survived` finding and per `unverified` finding, plus one per `refuted`
2591
2673
  > finding you reverse. Each entry carries `bucket`
2592
2674
  > (`survived|unverified|refuted`), `index` (its position in that bucket of the
@@ -2658,14 +2740,15 @@ and will act on it. Relay everything — reversals too — then dispatch.
2658
2740
 
2659
2741
  **That `dispatch` refuses a finisher — exit 2, nothing written — on a PR whose
2660
2742
  latest `reviewed=` counts a survived or unverified finding, unless the
2661
- dispositions verdict answering that review's head is `ok`**: among the
2662
- `dispositions-*=fix-pr-<M>[-x]:<head>` tokens whose head matches it, the one
2663
- from the highest-suffixed fix-applier. A PR whose latest review counts
2743
+ dispositions verdict answering that review's run is `ok`**: among the
2744
+ `dispositions-*=fix-pr-<M>[-x]:<run>` tokens naming its run, the one
2745
+ from the highest-suffixed fix-applier — so a second review at the same head is
2746
+ answered by none of the first one's verdicts. A PR whose latest review counts
2664
2747
  `0/<n>/0` is not gated. One counting `0/<n>/<u>` with `<u>` above zero is
2665
2748
  gated like survivors, and the tick prints `DISPATCH fix-pr PR#<M>` for it: that
2666
2749
  fix-applier's `no-op` and its `ok` verdict are what open the finisher. The
2667
2750
  refusal names its cause. `dispositions
2668
- unchecked` — no verdict answers that head: run `dispositions-check.mjs` for
2751
+ unchecked` — no verdict answers that review: run `dispositions-check.mjs` for
2669
2752
  the fix-applier that answered the review, as the Fix-applier report edge
2670
2753
  states, then dispatch again. It names a `dispositions-unchecked=` verdict too —
2671
2754
  no rule broke, but the check could not read where a deferral was filed, `gh`
@@ -2681,15 +2764,14 @@ deferred `remedy-outside-diff`, or a second mismatch was drawn on one review, an
2681
2764
  only a human can rule on either. Post the check's output, which names each
2682
2765
  escalated finding or violating entry, with `gh pr comment <M>`, and flag the PR
2683
2766
  for a human; re-running the check reprints it. Dispatch no fix-applier and no
2684
- finisher for that review's head, and expect no `fix-due` row for it; a new
2767
+ finisher for that review, and expect no `fix-due` row for it; a new
2685
2768
  review of the PR starts the check again. **On any PR with a
2686
2769
  returned review, `0/<n>/0` included, it refuses too while a fix-applier on the
2687
2770
  PR is still live, verdict or not** —
2688
2771
  `fix-pr-<M>[-x] still live`: settle it, run the check for it, then dispatch
2689
- again. That is what keeps a re-review at the same head from being answered by
2690
- the earlier round's verdict while the fix-applier answering the new round is
2691
- still working; once its check has run, its verdict, from the higher suffix, is
2692
- the current one.
2772
+ again. A re-review at the same head is a run of its own, so the earlier
2773
+ round's verdict never answers it; once the check has run for the fix-applier
2774
+ answering the new round, its verdict is the current one.
2693
2775
 
2694
2776
  **It refuses a finisher, too, while the PR sits on a conflict hold no
2695
2777
  fix-applier has cleared** — the same per-PR fold the tick prints `DISPATCH
@@ -2787,7 +2869,7 @@ a minute apart showed *different* mutants, so a member's report and any single
2787
2869
  **Whatever you verify by RUNNING, run in a tree nobody else owns.**
2788
2870
  Independently re-running the ticket's acceptance mutation — loosen the
2789
2871
  regex, delete the guard clause, flip the per-entry reset, run `<testCmd>`,
2790
- watch it redden, discard — is the half of this duty reading a diff cannot
2872
+ confirm a kill by the test-run verdict rule below, discard — is the half of this duty reading a diff cannot
2791
2873
  do, and it stays. But it **writes**, and the PR's worktree belongs to
2792
2874
  another member. Measured once: a finisher was inside that worktree at the
2793
2875
  instant the fix-applier announced one more clause to land, and neither
@@ -2915,11 +2997,43 @@ it reached, so reading that summary alone reads a partial suite as a whole one:
2915
2997
  > `other` and the exit code plus the summary line as evidence; label nothing.
2916
2998
  > The same holds for the mutation gate: a killed run is not a mutant that
2917
2999
  > reddened, and the files it cancelled are not failures — only a run that
2918
- > completed can kill a mutant. A completed run that exits 1 is a plain failure,
2919
- > not a killed run, whatever its `cancelled` count, and exit 0 with `tests 0`
2920
- > stays FAILED.
3000
+ > completed can kill a mutant. A completed run that exits 1 is not a killed run
3001
+ > either, whatever its `cancelled` count, and not a killed mutant on its exit
3002
+ > status alone: the acceptance mutation scores a kill only by the rules below.
3003
+ > Exit 0 with `tests 0` stays FAILED.
2921
3004
  > Do not wrap `<testCmd>` in an external `timeout`. Run a long suite in one
2922
3005
  > `eval` cell with `timeout: 0`, as the review runner does, and wait for it.
3006
+ >
3007
+ > **Valid red:** a run that completed — the command returned on its own, with
3008
+ > no signal and no timeout, deadline or kill having fired — in which the test
3009
+ > the claim names is reported failing. An exit ≠ 0 with no failing test is not
3010
+ > red, and a different test failing is not red for this claim. A red in the full
3011
+ > suite only triggers a narrowed run; it is never evidence on its own.
3012
+ >
3013
+ > **Narrowed run:** the Test entrypoint with arguments appended,
3014
+ > `<testCmd> <args>`. That appended arguments reach the Test entrypoint is all
3015
+ > that is promised about them, so a narrowed run counts only if it reports
3016
+ > `tests` > 0 and its output names the claimed test. If no narrowing can be
3017
+ > proven, run the full `<testCmd>` and read the named test's own result from its
3018
+ > output.
3019
+ >
3020
+ > **Kill:** the mutant produced a valid red in a narrowed run, and the same
3021
+ > narrowed command, in the same tree with the mutant reverted, ran a valid green
3022
+ > with the named test passing — completed, exit 0, `tests` > 0, `cancelled` 0. A
3023
+ > completed exit ≠ 0 with the named test not failing is not a kill, and no kill
3024
+ > stands without that green run on the unmutated tree. The result is
3025
+ > inconclusive, never a kill, when the red does not reproduce in the narrowed
3026
+ > run, when the unmutated tree is red too, or when no usable run exists.
3027
+ >
3028
+ > **Evidence line:** every kill and every valid red you claim carries one line
3029
+ > in the claim's own free-text field:
3030
+ > `red: <cmd> → exit N, fail K incl <test>; baseline: <cmd> → exit 0, <test> pass`.
3031
+ > A failing-test finding filed off the review's shared run carries the `red:`
3032
+ > half alone.
3033
+ >
3034
+ > An inconclusive acceptance mutation is neither a kill nor a pass: halt with
3035
+ > cause `other`, with both runs — the mutant's and the unmutated tree's — as
3036
+ > evidence; label nothing. A kill's evidence line goes in your report.
2923
3037
 
2924
3038
  **Give the finisher duty 3 verbatim as well, as its two steps.** The finisher's
2925
3039
  agent definition carries no duty text, so this brief is the whole of duty 3 it
@@ -3128,8 +3242,12 @@ guaranteed the way skill availability is. Tell it to check every added
3128
3242
  assertion against the tree, including comments in files the diff does not
3129
3243
  touch, and to read each corrected sentence literally, clause by clause. It then
3130
3244
  does the fix-applier's job too:
3131
- apply, defer, file, push, report, exit. On its report, record
3132
- `reviewed=<head>:0/<refuted>/<deferred>` against the head it pushed — it applied
3245
+ apply, defer, file, push, report, exit — and before it reports, it writes its
3246
+ findings as a review result file in a run root of its own, made with
3247
+ `mktemp -d "<scratch>/pr<pr>/run-XXXXXXXX"`, in the shape `review-and-fix.md`'s
3248
+ **The review result file** describes, and reports that file's path. On its
3249
+ report, record `reviewed=<head>:0/<refuted>/<deferred>:<run>`, `<run>` that run
3250
+ root's name, against the head it pushed — it applied
3133
3251
  its own survivors, so the zero is what tells the tick no fix-applier is owed for
3134
3252
  them; a nonzero `<deferred>` is still fix-due, as any review's unverified band is —
3135
3253
  and it reaches a finisher through the same gate as any other PR.
@@ -3874,8 +3992,9 @@ any other, never a section of its own.
3874
3992
  A PR's review is not a member, so it carries its own pair of row tokens,
3875
3993
  written with `row` (**Reviewers**): `review=wf:<runId>` |
3876
3994
  `review=member:review-pr-<n>` | `review=fallback:review-pr-<n>[-b]` at launch,
3877
- settled dead as `…=failed`, then `reviewed=<head>:<survived>/<refuted>/<unverified>`
3878
- when the result lands. A row with `review=` and no `reviewed=` is a review in
3995
+ settled dead as `…=failed`, then `reviewed=<head>:<survived>/<refuted>/<unverified>:<run>`
3996
+ when the result lands, `<run>` the review's `run-XXXXXXXX` run root under
3997
+ `<scratch>/pr<n>/`, which holds its `review.json`. A row with `review=` and no `reviewed=` is a review in
3879
3998
  flight, and the tick counts it against the reviewer cap unless gh reports its PR
3880
3999
  MERGED or CLOSED. `ci=<run-id>:<attempt>:<conclusion>`
3881
4000
  and `held-behind:#<lower>` are row tokens the same way (Phase 3), and so is