@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.
- package/agents/fleet-review-runner.agent.md +1 -1
- package/agents/fleet-review-tests.agent.md +36 -4
- package/agents/fleet-review-verifier.agent.md +43 -7
- package/commands/review-and-fix.md +8 -7
- package/package.json +1 -1
- package/scripts/compute-board.mjs +4 -1
- package/scripts/dispositions-check.mjs +102 -48
- package/scripts/fleet-tick.mjs +41 -31
- package/scripts/ledger.mjs +6 -6
- package/scripts/review-core.mjs +84 -21
- package/scripts/review-eval.mjs +59 -11
- package/skills/run-team/SKILL.md +174 -55
package/skills/run-team/SKILL.md
CHANGED
|
@@ -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 |
|
|
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-<
|
|
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
|
|
2173
|
-
|
|
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
|
|
2177
|
-
is the whole of your read, and it is what you record: `reviewed=<head>:<survived>/<refuted>/<unverified>`,
|
|
2178
|
-
off `head
|
|
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.
|
|
2196
|
-
fix-applier with the rest, in the file; never rule on them yourself.
|
|
2197
|
-
**`refutersDispatched`, carried on every finding, is what tells
|
|
2198
|
-
apart** — zero is the policy skip, above zero with no
|
|
2199
|
-
|
|
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
|
|
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>:<
|
|
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
|
|
2300
|
-
`<scratch>/review
|
|
2301
|
-
it
|
|
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
|
|
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:<
|
|
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
|
|
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
|
|
2404
|
-
> `refutersDispatched`, never off severity and never
|
|
2405
|
-
>
|
|
2406
|
-
>
|
|
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*
|
|
2409
|
-
> review re-dispatched each crash once already and
|
|
2410
|
-
> a deferral that names the crash can still be
|
|
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.
|
|
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
|
|
2534
|
-
> green** — else you proved it fails, not
|
|
2535
|
-
> whole-file text clears "it and only it
|
|
2536
|
-
> (measured). A green suite says nothing
|
|
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-<
|
|
2587
|
-
>
|
|
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": [ … ]}
|
|
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
|
|
2662
|
-
`dispositions-*=fix-pr-<M>[-x]:<
|
|
2663
|
-
from the highest-suffixed fix-applier
|
|
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
|
|
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
|
|
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.
|
|
2690
|
-
|
|
2691
|
-
|
|
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
|
-
|
|
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
|
|
2919
|
-
>
|
|
2920
|
-
>
|
|
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
|
|
3132
|
-
|
|
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
|
|
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
|