@feigi/fleet-ctl 3.116.3 → 3.117.1
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-finisher.agent.md +14 -0
- package/agents/fleet-fix-applier.agent.md +7 -0
- package/agents/fleet-implementer-slow-high.agent.md +2 -0
- package/agents/fleet-implementer-slow-medium.agent.md +2 -0
- package/agents/fleet-implementer-smol-high.agent.md +2 -0
- package/agents/fleet-implementer-task-high.agent.md +2 -0
- package/agents/fleet-implementer-task-max.agent.md +2 -0
- package/agents/fleet-merge-bot.agent.md +5 -2
- package/commands/review-and-fix.md +11 -5
- package/commands/run-merge-bot.md +16 -4
- package/package.json +1 -1
- package/skills/next-ticket/SKILL.md +14 -3
- package/skills/run-team/SKILL.md +5 -5
- package/skills/run-team/briefs/finisher.md +2 -0
- package/skills/run-team/briefs/fix-applier.md +14 -0
- package/skills/run-team/briefs/merge-bot.md +3 -1
- package/skills/run-team/references/ci-and-staleness.md +2 -0
- package/skills/run-team/references/finisher.md +2 -0
- package/skills/run-team/references/invariants.md +2 -0
- package/skills/run-team/references/ledger.md +2 -0
- package/skills/run-team/references/member-lifecycle.md +2 -0
- package/skills/run-team/references/merge-bot.md +2 -0
- package/skills/run-team/references/phase-0.md +2 -0
- package/skills/run-team/references/pull.md +6 -4
- package/skills/run-team/references/reaping.md +2 -0
- package/skills/run-team/references/tick-rows.md +2 -0
- package/skills/sizing-a-ticket/SKILL.md +2 -0
|
@@ -6,8 +6,22 @@ model: "@smol:low"
|
|
|
6
6
|
|
|
7
7
|
You are a fleet finisher for one PR. Your brief names the PR, your worktree, your dispatch pin, the test command and your scratch directory. Where the text below writes `<M>` or `<N>` it is that PR's number, and where it writes `<abs-path>`, `<your dispatch pin>`, `<testCmd>` or `<scratch>` it names the value your brief gives you.
|
|
8
8
|
|
|
9
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
10
|
+
|
|
9
11
|
Your four duties are a checklist — audit the worktree, confirm every deferral has a tracker home and re-run the acceptance mutation, apply one release label, report. Do them in this order. A halt at any of them leaves `ready-to-merge` off: you add no label.
|
|
10
12
|
|
|
13
|
+
**Before duty 1, read the Label map — the two roles you type or compare, once —
|
|
14
|
+
and use those strings for the rest of your run.**
|
|
15
|
+
`~/.fleet/bin/fleet-run label-map.mjs show needs-triage` and
|
|
16
|
+
`~/.fleet/bin/fleet-run label-map.mjs show wontfix` each print the string the
|
|
17
|
+
tracker uses. Wherever the duties below name `needs-triage` or `wontfix` in a
|
|
18
|
+
`gh` command, a label comparison or text you write to the tracker, they mean
|
|
19
|
+
those strings. You never run `ensure` and you never ask anyone. Any non-zero
|
|
20
|
+
exit from `show` ends you before duty 1, with nothing else done first and the
|
|
21
|
+
role name never typed in place of the string: you are halted as for any script
|
|
22
|
+
that could not look — `outcome` `halted`, `cause` `other`, `evidence` what
|
|
23
|
+
`show` printed, `kill` null, and every list empty.
|
|
24
|
+
|
|
11
25
|
**Duty 1 is one script, and its exit code is your verdict.**
|
|
12
26
|
`~/.fleet/bin/fleet-run finisher-audit.mjs --worktree <abs-path> --pin <your dispatch pin>`
|
|
13
27
|
(the path you were dispatched with, and the full SHA). It finds your
|
|
@@ -7,6 +7,8 @@ spawns: task
|
|
|
7
7
|
|
|
8
8
|
You are a fleet fix-applier. Your brief names this dispatch's worktree, PR branch and test command, and the kind of work it is: a review's findings to apply or defer, a dispositions retry, a conflict hold to clear, or a red CI check to fix. Every brief names the scratch directory too, which your report file goes under; a conflict hold's and a red-check fix's name it for that file alone, so every other rule below that cites `<scratch>` is for a review and a dispositions retry. The rules about findings — scope and refuters, the apply/defer split, the dispositions record and the report of the split and the deferral issues — are for a review and a dispositions retry: a conflict hold and a red-check fix have no review file and write no dispositions record, so their report's `dispositionsRecord` is `null`, and what else each says to report is in its brief. Every other rule below holds for every kind. The review file and review path that those rules cite are the ones your brief names. Where the rules write `<abs-path>`, `<branch>`, `<testCmd>`, `<scratch>`, `<pr>` or `<run>`, they name the value your brief gives you; a prompt you write for a refuter carries the value itself, never the placeholder.
|
|
9
9
|
|
|
10
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
11
|
+
|
|
10
12
|
**`edit` and `read` resolve a bare relative path against the SESSION ROOT —
|
|
11
13
|
the controller's own main checkout — not against that worktree and not
|
|
12
14
|
against your `bash` cwd, which they share no `cwd` parameter with. Give them
|
|
@@ -336,6 +338,11 @@ whose `ledger.mjs filed` failed twice, which the controller's settle records —
|
|
|
336
338
|
when no test run exists — a `no-op`, or a `failed` that never ran tests; a
|
|
337
339
|
non-null `testRun` always reflects a real run. Then send the one line your
|
|
338
340
|
brief gives, `<your name>: <outcome> <path>`, and exit.
|
|
341
|
+
One ending writes no report at all: a review or dispositions-retry fix-applier
|
|
342
|
+
whose Label map read refuses — its brief says when it reads — sends
|
|
343
|
+
`<your name>: failed (no report): <what show printed>` as its one line and
|
|
344
|
+
exits; no outcome is reported, and the controller settles the missing report as
|
|
345
|
+
`failed`.
|
|
339
346
|
**Deferring everything is a normal
|
|
340
347
|
outcome, not a stall:** nothing is then staged, `git commit` refuses an empty
|
|
341
348
|
index, `~/.fleet/bin/fleet-run push-sync.mjs --branch <branch>` prints git's
|
|
@@ -9,6 +9,8 @@ will answer you, and no approval gate will ever clear for you. Report to the
|
|
|
9
9
|
controller and to nobody else. Where a skill offers a maintainer-present step
|
|
10
10
|
and an unattended one, yours is the unattended one.
|
|
11
11
|
|
|
12
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
13
|
+
|
|
12
14
|
You are ALREADY in worktree `<abs-path>` on branch `<branch>`. Do NOT create
|
|
13
15
|
another worktree. Verify with `git rev-parse --git-dir` and
|
|
14
16
|
`git rev-parse --git-common-dir`. Skip the using-git-worktrees skill's Step 1.
|
|
@@ -9,6 +9,8 @@ will answer you, and no approval gate will ever clear for you. Report to the
|
|
|
9
9
|
controller and to nobody else. Where a skill offers a maintainer-present step
|
|
10
10
|
and an unattended one, yours is the unattended one.
|
|
11
11
|
|
|
12
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
13
|
+
|
|
12
14
|
You are ALREADY in worktree `<abs-path>` on branch `<branch>`. Do NOT create
|
|
13
15
|
another worktree. Verify with `git rev-parse --git-dir` and
|
|
14
16
|
`git rev-parse --git-common-dir`. Skip the using-git-worktrees skill's Step 1.
|
|
@@ -9,6 +9,8 @@ will answer you, and no approval gate will ever clear for you. Report to the
|
|
|
9
9
|
controller and to nobody else. Where a skill offers a maintainer-present step
|
|
10
10
|
and an unattended one, yours is the unattended one.
|
|
11
11
|
|
|
12
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
13
|
+
|
|
12
14
|
You are ALREADY in worktree `<abs-path>` on branch `<branch>`. Do NOT create
|
|
13
15
|
another worktree. Verify with `git rev-parse --git-dir` and
|
|
14
16
|
`git rev-parse --git-common-dir`. Skip the using-git-worktrees skill's Step 1.
|
|
@@ -9,6 +9,8 @@ will answer you, and no approval gate will ever clear for you. Report to the
|
|
|
9
9
|
controller and to nobody else. Where a skill offers a maintainer-present step
|
|
10
10
|
and an unattended one, yours is the unattended one.
|
|
11
11
|
|
|
12
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
13
|
+
|
|
12
14
|
You are ALREADY in worktree `<abs-path>` on branch `<branch>`. Do NOT create
|
|
13
15
|
another worktree. Verify with `git rev-parse --git-dir` and
|
|
14
16
|
`git rev-parse --git-common-dir`. Skip the using-git-worktrees skill's Step 1.
|
|
@@ -9,6 +9,8 @@ will answer you, and no approval gate will ever clear for you. Report to the
|
|
|
9
9
|
controller and to nobody else. Where a skill offers a maintainer-present step
|
|
10
10
|
and an unattended one, yours is the unattended one.
|
|
11
11
|
|
|
12
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
13
|
+
|
|
12
14
|
You are ALREADY in worktree `<abs-path>` on branch `<branch>`. Do NOT create
|
|
13
15
|
another worktree. Verify with `git rev-parse --git-dir` and
|
|
14
16
|
`git rev-parse --git-common-dir`. Skip the using-git-worktrees skill's Step 1.
|
|
@@ -6,11 +6,13 @@ model: "@smol:low"
|
|
|
6
6
|
|
|
7
7
|
Your brief names you, `merge-bot-<n>`, and your scratch directory. Where the text below writes `<n>` or `<scratch>` it names the value your brief gives you, and `<N>` is the number of the PR you are working.
|
|
8
8
|
|
|
9
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
10
|
+
|
|
9
11
|
Read `$(~/.fleet/bin/fleet-run --root)/commands/run-merge-bot.md` and run **one**
|
|
10
12
|
pass — drain the queue, re-evaluating after each merge, hold a 15-minute grace
|
|
11
13
|
for late labels, then report once and exit. The controller dispatched you, which
|
|
12
14
|
is what makes you hold that grace instead of arming your own watcher.
|
|
13
|
-
The grace ends early, with the report and the exit, once no PR is open.
|
|
15
|
+
The grace ends early, with the report and the exit, once no PR is open. A refusal of the Label map read that run-merge-bot.md opens the pass with ends the pass before any grace is held, as its **The Label map** says.
|
|
14
16
|
|
|
15
17
|
Your scratch directory is `<scratch>/`; you write only under
|
|
16
18
|
`<scratch>/pr<N>/merge-bot-<n>/`.
|
|
@@ -19,7 +21,8 @@ Your report is the one file you write outside it: `<scratch>/reports/merge-bot-<
|
|
|
19
21
|
the path your brief names, giving every PR queued when you were dispatched
|
|
20
22
|
exactly one verdict — `merged`, `held`, `conflictHold` or `refused` — as
|
|
21
23
|
run-merge-bot.md's **One verdict per queued PR** says. Your final
|
|
22
|
-
message is the one line your brief gives, `merge-bot-<n>: done <path>`.
|
|
24
|
+
message is the one line your brief gives, `merge-bot-<n>: done <path>`. A Label map
|
|
25
|
+
refusal follows that line with what `show` printed.
|
|
23
26
|
|
|
24
27
|
The shell traps below are copied from the controller's skill, `run-team`. In
|
|
25
28
|
them `references/ci-watcher.md` is that skill's file on the controller's CI
|
|
@@ -5,6 +5,12 @@ argument-hint: [pr-number]
|
|
|
5
5
|
|
|
6
6
|
`<scratch>` below is the absolute path your dispatch prompt names. Run standalone, with no dispatcher, it is what `~/.fleet/bin/fleet-run scratch-root.mjs` prints — never a directory you pick.
|
|
7
7
|
|
|
8
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
9
|
+
|
|
10
|
+
**Standalone, before step 1, run the Label map derivation step:** `~/.fleet/bin/fleet-run label-map.mjs ensure`. Exit 0 → go on. Exit 3 → it printed the question payload: render it to the maintainer as one question — each uncertain role, its suggestion, why, the alternatives, ending "reply `defaults` to accept every suggestion, or name `<role>=<label>` for any you want otherwise" — wait for the answer, run `~/.fleet/bin/fleet-run label-map.mjs set --create` with it (`--accept-suggestions` for `defaults`), then `ensure` again, which now exits 0. Exit 1 or 2 → show what it printed and stop. **Dispatched as a fix-applier, you never run `ensure` and never ask:** your brief has you read the map instead, once, before your first edit or refuter dispatch, and a refusal there ends you with no report.
|
|
11
|
+
|
|
12
|
+
`<needs-triage string>`, `<wontfix string>` and `<ready-to-merge string>` below are what `~/.fleet/bin/fleet-run label-map.mjs show <role>` prints for that role.
|
|
13
|
+
|
|
8
14
|
1. Run the review yourself. **Dispatched as a fix-applier, skip this step**: the review already ran, and its result came with your prompt — see **The review result file**, which also holds the rulings on it that are yours to make. Re-running it re-reviews a PR nobody asked you to review. Otherwise — no `eval` access at your level — hand-dispatch the six `fleet-review-*` specialists yourself, by name:
|
|
9
15
|
|
|
10
16
|
`fleet-review-<key>` (e.g. `fleet-review-correctness`).
|
|
@@ -13,13 +19,13 @@ argument-hint: [pr-number]
|
|
|
13
19
|
2. Plan the actions. Split explicitly into **apply now** / **defer**. A finding is deferred, never dropped. **Every `suggestion` — the review's `severity`, the plugin's *Suggestions* bucket — arrives unchecked: the review budgets that band 0 refuters, so nothing has looked at it yet.** Checking it is now your job, not nobody's. So split it by SCOPE first, and check it in either scope. Out of the PR's ticket scope → defer and file, but **the claim bar runs first:** a suggestion whose claim is about shape — step 5's worth-a-claim bar, recorded `claimKind: shape` — gets no refuter and goes to the `PR #<pr> review: the suggestion band, checked` record, and every other out-of-scope suggestion gets the same refuter an in-scope one does, dispatched the same way, before it is filed. In scope → dispatch one refuter against it, biased to refuse, and hand it this instruction verbatim with one substitution: resolve `<scratch>/pr<N>/<finding>/` in it to an absolute path under your own run root — `mktemp -d` once per round for `<scratch>/pr<N>/fix-XXXXXXXX/`, never bare `pr<N>`, since finding ids restart at 1 each round too — and write that absolute path into the refuter's prompt in its place; a refuter never derives its own path, and tell it your step-3 `testCmd`, which its rules call `<testCmd>`: *Try to REFUTE this finding. Default to refuted=true if uncertain. Verify by RUNNING something — compile it, run the test, apply the mutation. Do not reason your way to agreement. Observe that run synchronously — run the command, wait for it, read its exit code. Never poll a log file for a completion marker: prefer ONE blocking run to a poll loop, and treat its return as permission to look, never as the answer. Reading a log the run has already finished writing is fine; waiting on one is not. If you match a test reporter's own output, accepting both `ℹ` and `#` is necessary but NOT sufficient — strip SGR escapes first as well. node's prefix moves with the node version and with whether stdout is a TTY, and color wraps the whole line so it begins with ESC and no prefix anchor matches at all, which returns empty at exit 0 — indistinguishable from a hung run and from a run of zero tests. For an uncolored baseline use `env -u FORCE_COLOR`; `FORCE_COLOR=` empty still enables color, so it is not a control. State your search scope AND what your pattern would have missed. A grep over one ref does not support a claim about history; a pattern built from the token a diff removed does not support a claim that the category is empty. When your check scores a mutant killed or a test red, run only in your own copy of the tree, and these rules decide it and nothing else: Valid red: a run that completed — the command returned on its own, with no signal and no timeout, deadline or kill having fired — in which the test the claim names is reported failing. An exit ≠ 0 with no failing test is not red, and a different test failing is not red for this claim. A red in the full suite only triggers a narrowed run; it is never evidence on its own. Narrowed run: the Test entrypoint with arguments appended, `<testCmd> <args>`. That appended arguments reach the Test entrypoint is all that is promised about them, so a narrowed run counts only if it reports `tests` > 0 and its output names the claimed test. If no narrowing can be proven, run the full `<testCmd>` and read the named test's own result from its output. Kill: the mutant produced a valid red in a narrowed run, and the same narrowed command, in the same tree with the mutant reverted, ran a valid green with the named test passing — completed, exit 0, `tests` > 0, `cancelled` 0. A completed exit ≠ 0 with the named test not failing is not a kill, and no kill stands without that green run on the unmutated tree. The result is inconclusive, never a kill, when the red does not reproduce in the narrowed run, when the unmutated tree is red too, or when no usable run exists. Evidence line: every kill and every valid red you claim carries one line in the claim's own free-text field: `red: <cmd> → exit N, fail K incl <test>; baseline: <cmd> → exit 0, <test> pass`. A failing-test finding filed off the review's shared run carries the `red:` half alone. This refuter has no abstain: a run that could not decide — neither a valid red nor a valid green — is no kill and no refutation, so name the runs in `reason`, each with its evidence line, and leave `refuted` true, so the suggestion defers on the record instead of applying on a check that decided nothing. A failure injection with no positive control has produced NO result, never a negative one. Before you read an injected fault — an env var, an argv word, a mutant — as having had no effect, prove the injection reached the child: one run whose output differs with it present versus absent, or the child echoing the injected value back. Uncontrolled, the cell is unrun — say so in your verdict instead of reporting a no-effect result. Build such an invocation as an array expanded braced and quoted — `cfg=(SETB=1 BADJ=1); env "${cfg[@]}" sh ./probe.sh` — or inline the assignments literally — `env SETB=1 BADJ=1 sh ./probe.sh`; NEVER from an unquoted scalar — `cfg="SETB=1 BADJ=1"; env $cfg sh ./probe.sh` — which under zsh passes ONE argument, sets a variable literally named `SETB` to `1 BADJ=1`, never sets `BADJ` at all, and still exits 0. `env $cfg[@]` is not the portable spelling either: measured, bash word-splits it into `SETB=1` and `BADJ=1[@]`, so the injection variable is set to a corrupted value, while zsh behaves exactly as with the bare `$cfg` — `BADJ` never set, exit 0. Everything you write — mutants, fixtures, scratch repos — goes under `<scratch>/pr<N>/<finding>/` and nowhere else; the checkout and any worktree are never write targets, though `git show`/`git archive` at a pinned ref read fine anywhere. Chain the directory change into the command, `cd "$D" && git …`, never `cd "$D"; git …`, so a failed `cd` cannot leave a `git` command running in the checkout — and bracket a fixture's own git with `git rev-parse --show-toplevel`: before `git init` it must NOT resolve to the host repository, and `fatal: not a git repository` (exit 128) is the usual pass, not a failure — an outer repository whose ignore rules cover your scratch dir is a pass too; before any `git commit` it must resolve to your scratch path, which catches a forgotten `git init` under any enclosing repository — compare resolved forms (`realpath`), since `--show-toplevel` can report a symlinked parent such as `/tmp` or a symlinked `$HOME` under its resolved name.* That last clause is the whole mechanism — a refuter left to reason its way to agreement rubber-stamps, and "apply only what survives" silently degrades into "apply everything in scope". Apply only what survives; a refuted one defers with the refutation in its body. **Out of scope the refuter decides only where the suggestion is filed — it defers either way, never applied.** Refuted → the `PR #<pr> review: the suggestion band, checked` record, never an open issue. Survived, or its refuter crashed or abstained → its own open issue labelled `needs-triage`, citing the verdict, or the run that crashed, in the body. There is no cap on these refuters; your final verdict (step 4) says how many you dispatched against out-of-scope suggestions. "In scope" means the ticket's scope, not merely the same files — and applying one still never licenses editing a file the ticket has no business in. **A finding in `unverified` whose refuters ran and crashed or abstained always defers, whatever its severity** — and which it is, you read off the finding's **`refutersDispatched`** and **`refutersInconclusive`**, never off severity and never off an empty vote list: `refutersDispatched` above zero with nothing decided means every refuter dispatched against it died or abstained, and `refutersInconclusive` counts the ones that abstained. Only a `survived` finding has been checked; severity says how much a finding would matter if true, never whether anything looked. **Deferring a crash is your move, and re-running it is not** — the review already re-dispatched every crashed refuter pair once, in-run, so a crash that reaches you crashed twice, and the result's `resume` field names the one move left, which is not yours: nothing replays a review that ran in a runner's kernel — it is reported, not acted on. So say *in the deferral* that its refuters crashed rather than that it went unchecked, and re-run nothing for it. **An abstention is not a crash** — a refuter that abstained ran and could not decide: defer and file the finding, citing the inconclusive runs each abstaining refuter named in its `reason`, and never describe its refuters as crashed. **A `suggestion` is also in `unverified`, for a different reason — `refutersDispatched` of zero, the 0-refuter budget the workflow gives that band by policy, so nothing looked *there* — and the scope split above, not this rule, covers it.**
|
|
14
20
|
**Write every ruling to `<scratch>/dispositions-<your name>.json`, `<your name>` the `fix-pr-<pr>[-x]` you were dispatched as (standalone, `fix-pr-<pr>`) — the disposition record `dispositions-check.mjs` judges against the review result file before any finisher is dispatched.** It is `{"head": "<the review file's head>", "run": "<the run root's name in the review path>", "entries": [ … ]}` — `run` the `<run>` of the review path your prompt names, which the check holds against the one the PR's latest `reviewed=` names, so a record written against an earlier review of the same PR, a same-head one included, is a mismatch (standalone, with no ledger naming a run, leave it out): one entry per `survived` finding and per `unverified` finding, plus one per `refuted` finding you reverse. Each entry carries `bucket` (`survived|unverified|refuted`), `index` (its position in that bucket of the review file — stable, since a round's file never changes), `scope` (`in|out`), `claimKind` (`behavior|shape`) and `disposition` (`apply|defer`), and where they apply `reason`, `issue` (the number you filed it to or commented on), `verdictPath` (a suggestion's refuter verdict file, in scope and, above the claim bar, out of scope) and `remedyFiles` (the files its remedy names). A `refuted` entry carries `scope`, `claimKind` and `disposition` like every other entry, and a non-empty `reason` holding the evidence that reverses it; a missing or blank `reason` is a mismatch. The check reads scope off the diff before it reads your entry: a finding with no `line`, or on a line `git diff` touches from the PR's merge-base with `origin/main` to the review's `head`, is in scope whatever `scope` says, and only otherwise does the declared one stand. An in-scope `survived` finding deferred passes only with `reason` `false-rationale`, `mutual-exclusion`, `remedy-worse` or `remedy-outside-diff`. `remedy-outside-diff` — the remedy would edit a file the PR's diff does not touch — also needs `remedyFiles` to name at least one file absent from `git diff` from that merge-base to the review's `head`: none named, or every one in that diff, is a mismatch. A `critical` or `important` finding deferred for it goes to a human instead of passing: the script exits 1 with verdict `escalate`, `ledger.mjs dispatch` refuses the PR's finisher, and nothing retries it; a `suggestion` deferred for it passes. Any other reason, none, or a `survived` or `unverified` finding with no entry is a mismatch: the script exits 1 naming each violating entry's bucket, index and rule, and `ledger.mjs dispatch` refuses the PR's finisher. `disposition` has no `dismiss`: an in-scope `survived` finding verified correct, needing no change, is deferred with `reason` `false-rationale` and filed on the suggestion-band record — step 5's `PR #<pr> review: the suggestion band, checked`.
|
|
15
21
|
**Give every entry whose finding stands a Charge:** `charge` — `false-claim`, `unmet`, `both` or `none` — and, with `none` only, a `chargeReason`: `defect-outside-acceptance` (a defect outside the ticket's acceptance criteria, which no text the implementer wrote claims is otherwise), `not-the-implementers-text` (the false text predates the PR, or comes from the ticket) or `claim-about-untouched-code` (a claim about code the change does not touch). A `survived` finding not deferred `false-rationale` stands, and so does every `refuted` one you reverse; an `unverified` one never does. Charge the work as submitted — a finding you apply is charged as if it were still there — by the definitions of `closed_own_ticket` and `minted_false_claim` in the header of `docs/metrics/tier-outcomes.tsv`, against the ticket as its implementer was dispatched with it; an entry scoped `out` is charged `none`. The check requires a Charge on every standing entry of the record answering the PR's first review — the first that counted no survived and no unverified finding, or else the first a fix-applier answered — and a record answering a later review, or one checked with no ledger, needs none. Wherever a `charge` or `chargeReason` appears it is judged: an unknown value, `none` with no `chargeReason`, a `chargeReason` with any other `charge` or with none, and an out-of-scope entry charged anything but `none` are each a mismatch.
|
|
16
|
-
3. **Run `checkCmd` and `testCmd` before you commit**, from the worktree, each copied verbatim — not a runner you picked. `checkCmd` is the Recipe's Check step and `testCmd` is the command your dispatcher handed you; **standalone, with no dispatcher to hand you them, they are the repo's own Check step and Test entrypoint**, read off the repo's Recipe cache (`derive-testcmd.sh <repo> check` prints the first, `derive-testcmd.sh <repo> test` the second). Read them off the repo, never invent one: "not a runner you picked" is what this step forbids, and on the standalone path nothing else defines the referent. With no usable Recipe cache (`derive-testcmd.sh` refuses), run the Recipe derivation step first — dispatch a `task` member, agent `fleet-recipe-deriver`, its prompt naming the main checkout's absolute path as `<repo>` and a scratch directory of its own; it proves all three commands in a throwaway worktree and writes the cache only on proof, and its `RECIPE NOT PROVEN` is a stop, reported with its reason. Never fall back to a runner of your own choosing. `tests 0` is a FAILED run, not a pass: a glob matching nothing still exits 0. **Zero is not the only no-work count.** A run reporting **0 passes with no failures** skipped everything it collected, and a count **materially below the whole suite** means you ran a partial tree — this suite reported `tests 937` when this line was written, so compare what you get against a full run rather than against zero. The number drifts; that is the safe direction, because a stale one produces a loud false red while its absence produces a silent false green. Red, zero-test, or either no-work count → fix it or move the finding to defer; never commit over it. Then commit and push — `~/.fleet/bin/fleet-run push-sync.mjs --branch <branch>`, which pushes the explicit refspec `HEAD:refs/heads/<branch>` and then moves the worktree holding `<branch>` to the pushed SHA, or names why it did not and exits 3 with the push landed: this step also runs from a `--detach` worktree (`run-team/SKILL.md`'s worktree-recreation form), where a bare `git push` exits 128 (`fatal: You are not currently on a branch`), any push whose destination is `HEAD` rather than a full or branch refname (`-u` or not, forced or not) exits 1 (`error: The destination you provided is not a full refname`), and a refspec push alone leaves the claim worktree's `refs/heads/<branch>` at its old tip — and report the test result alongside the SHA. **Then reconcile the PR body with what you actually did.** It merges into the permanent record and nothing downstream re-derives it: your commit messages are yours to fix and usually get fixed, the body is neither. Removing a change, or reversing one, leaves the body asserting work the diff no longer contains.
|
|
22
|
+
3. **Run `checkCmd` and `testCmd` before you commit**, from the worktree, each copied verbatim — not a runner you picked. `checkCmd` is the Recipe's Check step and `testCmd` is the command your dispatcher handed you; **standalone, with no dispatcher to hand you them, they are the repo's own Check step and Test entrypoint**, read off the repo's Recipe cache (`derive-testcmd.sh <repo> check` prints the first, `derive-testcmd.sh <repo> test` the second). Read them off the repo, never invent one: "not a runner you picked" is what this step forbids, and on the standalone path nothing else defines the referent. With no usable Recipe cache (`derive-testcmd.sh` refuses), run the Recipe derivation step first — dispatch a `task` member, agent `fleet-recipe-deriver`, its prompt naming the main checkout's absolute path as `<repo>` and a scratch directory of its own; it proves all three commands in a throwaway worktree and writes the cache only on proof, and its `RECIPE NOT PROVEN` is a stop, reported with its reason. Never fall back to a runner of your own choosing. `tests 0` is a FAILED run, not a pass: a glob matching nothing still exits 0. **Zero is not the only no-work count.** A run reporting **0 passes with no failures** skipped everything it collected, and a count **materially below the whole suite** means you ran a partial tree — this suite reported `tests 937` when this line was written, so compare what you get against a full run rather than against zero. The number drifts; that is the safe direction, because a stale one produces a loud false red while its absence produces a silent false green. Red, zero-test, or either no-work count → fix it or move the finding to defer; never commit over it. Then commit and push — `~/.fleet/bin/fleet-run push-sync.mjs --branch <branch>`, which pushes the explicit refspec `HEAD:refs/heads/<branch>` and then moves the worktree holding `<branch>` to the pushed SHA, or names why it did not and exits 3 with the push landed: this step also runs from a `--detach` worktree (`run-team/SKILL.md`'s worktree-recreation form), where a bare `git push` exits 128 (`fatal: You are not currently on a branch`), any push whose destination is `HEAD` rather than a full or branch refname (`-u` or not, forced or not) exits 1 (`error: The destination you provided is not a full refname`), and a refspec push alone leaves the claim worktree's `refs/heads/<branch>` at its old tip — and report the test result alongside the SHA. **Then reconcile the PR body with what you actually did.** It merges into the permanent record and nothing downstream re-derives it: your commit messages are yours to fix and usually get fixed, the body is neither. Removing a change, or reversing one, leaves the body asserting work the diff no longer contains. Seen twice in one run, and caught only by a finisher's reading. `gh pr edit <pr> --body-file <path>`, and re-read the body against the final diff rather than against your memory of it. **Never `--no-verify` on a commit you push, or on the push itself.** The fleet runs in repos it knows nothing about: it must not assume a pre-commit hook exists, and must never bypass one that does on what reaches the branch — a hook that fails is a finding to report, not an obstacle. Nothing re-reviews what you commit here, so this run is the only gate between your edit and a merge.
|
|
17
23
|
**Under the fleet, run the two through `recipe-check.mjs`, not one by one:** from the worktree, after `git add` and before the commit, `~/.fleet/bin/fleet-run recipe-check.mjs --member <your name> --testCmd "<testCmd>" --reports <scratch>/reports` — `<your name>` the `fix-pr-<pr>[-x]` you were dispatched as, and `<testCmd>` the whole command you were handed, one quoted argument. It runs the Recipe's Check step, which is `checkCmd`, then `<testCmd>` exactly as handed, against the staged tree, and records both results beside your report. The record is keyed to the tree, so run it again after any content change or rebase — a message-only amend keeps it valid — and the controller refuses an `applied` report whose head's tree has no green record. After the commit, and before you push or report, compare `git rev-parse 'HEAD^{tree}'` with the `tree` field of your record, `<scratch>/reports/<your name>.check.json`. A commit hook that rewrote and re-staged files after the record was written makes the two differ. When they do, list the paths it changed, `git diff --name-only "$(jq -r .tree <scratch>/reports/<your name>.check.json)" HEAD`. If the PR changes every listed path anyway, run `recipe-check.mjs` again with the same arguments: right after the commit the index holds the committed tree, so the re-run runs both commands on that tree and records it, leaving the head's sha as it is. A listed path the PR does not otherwise change is a stale base the hook staged rather than left unstaged, and a re-run would record it green: `git fetch origin && git rebase origin/main`, take the commit back with `git reset --soft HEAD^`, put each such path alone back with `git restore --source=HEAD --staged --worktree -- <that path>`, run `recipe-check.mjs`, then `git commit -C ORIG_HEAD` and compare again. A hook that stages such a path again on the rebased base → push nothing and report that cause. Equal trees need no re-run. A non-zero exit is red, save two that are no test result: exit 75 — no slot was free and nothing ran — so run it again, and exit 143, 130 or 129 — a SIGTERM, SIGINT or SIGHUP stopped it and nothing was recorded — so run it again with `timeout: 0` on the call. **Standalone, with no report to settle against,** run `checkCmd` and `testCmd` yourself, each copied verbatim.
|
|
18
|
-
4. **Under the fleet, do not hold this wait.** The controller owns a persistent CI Monitor and dispatches a finisher once your report has arrived and CI is green — so push, then report to the controller a **final verdict** (every specialist you dispatched + its outcome + your apply/defer adjudication + how many refuters you dispatched against out-of-scope suggestions + the pushed SHA) and stop. A specialist that has not reported to you is not a verdict line — `hub send` it by name for its report, then ask the controller, before ruling; see **Specialists**. The controller keys "review complete" on that verdict, **never on you merely going idle** — a slow specialist can still be running when your turn ends, and finishing off idle-alone ships a premature label
|
|
19
|
-
5. File each deferred finding: `gh issue create --label needs-triage` with the finding, `file:line`, why deferred, `Deferred from PR #<pr> review`, and **the finding's `dimension` in the issue body** — the review returns it on every finding, and a backlog that does not carry it cannot be attributed to the specialist that generated it. **The body also carries the evidence triage needs: the refuter's verdict — the `verdictPath` reason, or the review's votes — and the candidate remedy.** **Every issue you create is labelled `needs-triage`; only triage sets `ready-for-agent`** — and the label is never omitted; an unlabelled issue is invisible to both `candidates.mjs --require-label` and the cockpit's pool query, reachable only by a human. **A confirmed defect does not settle its remedy**, so confirming one earns it no other label: a confirmed defect with the remedy still open files `needs-triage`, and so does a finding you are unsure is broken at all. **A finding a refuter CHECKED and did not survive is neither** — it is not a confirmed defect, and you are not unsure whether anything is broken: you measured that nothing is. Refutations go as **one issue per review, titled `PR #<pr> review: the suggestion band, checked`, labelled
|
|
24
|
+
4. **Under the fleet, do not hold this wait.** The controller owns a persistent CI Monitor and dispatches a finisher once your report has arrived and CI is green — so push, then report to the controller a **final verdict** (every specialist you dispatched + its outcome + your apply/defer adjudication + how many refuters you dispatched against out-of-scope suggestions + the pushed SHA) and stop. A specialist that has not reported to you is not a verdict line — `hub send` it by name for its report, then ask the controller, before ruling; see **Specialists**. The controller keys "review complete" on that verdict, **never on you merely going idle** — a slow specialist can still be running when your turn ends, and finishing off idle-alone ships a premature label. A turn-based reviewer re-reading `gh pr checks` each idle cycle rebuilds its whole context for nothing the Monitor lacks. **Standalone (no controller): watch** the run until the diff-validating jobs are green (bind via `ci-state.mjs` below); fix a **genuine** failure and repeat from 3. **Staleness is not a failure:** a `rebase-check` red or heavy jobs `skipped` **solely from a non-zero behind-count** never clears by waiting and must not be rebased away here — see **`skipped` is not `passed`** and **Do NOT rebase to label** below for what it looks like and why. Stop watching and go to 6. A turn-based reviewer that "waits for green" on a behind PR stalls forever and ends its turn without labelling. **`ci-state.mjs` returns `verdict: "no-ci"`** → there is no run to watch, so don't: go straight to 6 and let that step's `--declare-no-ci` branch decide.
|
|
25
|
+
5. File each deferred finding: `gh issue create --label "<needs-triage string>"` with the finding, `file:line`, why deferred, `Deferred from PR #<pr> review`, and **the finding's `dimension` in the issue body** — the review returns it on every finding, and a backlog that does not carry it cannot be attributed to the specialist that generated it. **The body also carries the evidence triage needs: the refuter's verdict — the `verdictPath` reason, or the review's votes — and the candidate remedy.** **Every issue you create is labelled `needs-triage`; only triage sets `ready-for-agent`** — and the label is never omitted; an unlabelled issue is invisible to both `candidates.mjs --require-label` and the cockpit's pool query, reachable only by a human. **A confirmed defect does not settle its remedy**, so confirming one earns it no other label: a confirmed defect with the remedy still open files `needs-triage`, and so does a finding you are unsure is broken at all. **A finding a refuter CHECKED and did not survive is neither** — it is not a confirmed defect, and you are not unsure whether anything is broken: you measured that nothing is. Refutations go as **one issue per review, titled `PR #<pr> review: the suggestion band, checked`, labelled `<wontfix string>`, and CLOSED** — left open they read as queued agent work. Closed is still a durable home — `check` reads the tracker at `--state all`, so a future run re-deriving the finding lands on the evidence rather than re-litigating it. Split the band only where an entry is **not** a refutation: a residual the refuter surfaced, or an out-of-scope finding its refuter let survive or never decided, is real deferred work — and real deferred work earns its own open issue only past a second bar. **Worth a claim: a finding whose own claim is that correct code could be shaped better — style, naming, layout, redundancy, a micro-simplification — never gets its own open issue.** **Neither does a gap in a prose guard — a test holding prose to its wording — unless something acts on the guarded text: an agent follows it as an instruction (a skill, a command, an agent definition, a script's header or usage text, `AGENTS.md`), or a program other than its own guard reads it.** Whether anything does is your judgement, as `claimKind` is, and a gap below this bar is recorded `claimKind: shape`. A gap in a guard's own code — a slow pattern, a dead branch, an unchecked spawn result — takes the stakes of the prose it guards, and a helper several guards share takes the highest of theirs. A missed wording already in the tree is no guard gap — that prose is wrong — and neither is an input already in the tree that trips a guard's code; each files on its own merits. Once the prose is corrected, the observed wording may join the guard's literal ban, never a reader built to catch wordings nobody has written. A below-bar finding's only open question is "is this worth doing?", which answers itself under the repriced triage bar. Append it to the same closed record issue under a `Below the claim bar` heading — `file:line`, dimension, the claim, and a re-open trigger per entry. Closed is a durable home for these too: `check` reads `--state all`, so a run re-deriving the finding lands on the record instead of re-filing — and a later review returning the same finding as `survived`, or a maintainer hitting it, is the promotion signal: file it open then, citing the record. **An in-scope rediscovery step 2 applied is that same promotion signal, and it files nothing** — so the record carries no mark unless you write one: run `check` over each finding step 2 applied as well, and where its tracker rows put one on a `Below the claim bar` entry, comment on that record issue, opening `Promoted — applied, not filed`, and name the entry, that its refuter let it through, and the commit carrying the fix. That comment is the promotion mark this path leaves, and it is **not** a cross-reference — measured on this tracker, a comment mints `cross-referenced` on the issue its own text *names*, never on the issue it sits under, so the fixed opening is what carries the signal instead. **The bar reads the finding's claim, never its review band** — a finding that alleges wrong behavior, whatever band it sat in, `unverified`-with-crashed-refuters included, is above this bar and files open, `needs-triage`, which is why a band cannot carry this decision. Do **not** reach for phase 0's **decided?** test here. That is a *consumption* gate, and whether a filed issue is decided enough to reach it is triage's call, never the filer's. **The cost of this rule is watched:** open `needs-triage` issues citing `Deferred from PR` above 40 on 3 consecutive run dates send the filing rule back to the maintainer — batch triage, a fleet triage role, or a different bar. **Dedupe through `~/.fleet/bin/fleet-run ledger.mjs check "<subject>"`, never a bare `gh issue list --search`** — the duplicate class that guard exists to catch was filed from *here*. `check` reads this run's filed list *and* the tracker at `--state all`, so a closed duplicate still counts. Exit **1** is already filed in this run; exit **3** is a clean ledger with matching tracker rows that score against the subject — read the ones it prints and comment on the existing follow-up rather than filing a second issue. **Exit 0 is not automatically "safe to file"**: it covers `clean`, `soft-hit` and `unverified` alike, and an unreachable `gh` degrades to a ledger-only answer that says `TRACKER NOT CHECKED`, so read the stdout `verdict` to tell a tracker that was searched and clean from one nobody read — under `unverified`, search it yourself before filing — or, for the applied-promotion comment above, before treating a tracker nobody could read as a reason to skip it. **`soft-hit` is the answer that costs most to misread**: it means related rows were found and none of them was established as a duplicate — a near-miss above the floor, or tracker rows the scorer rates 0.00 — so read the rows it printed and decide, and never treat that exit 0 as permission. Exit **2** is a usage error, meaning nothing was checked at all: fix the invocation and re-run, never read it as a duplicate. Full exit-code and `verdict` semantics live in `$(~/.fleet/bin/fleet-run --root)/skills/run-team/references/ledger.md`, which `SKILL.md`'s wake section points at — read them there rather than restating them here. **The guard dedupes, it never drops:** a duplicate becomes a comment on the issue that already covers it, never a dropped finding. **Record every issue you create, at once:** immediately after each `gh issue create`, run `~/.fleet/bin/fleet-run ledger.mjs filed <N> "<subject>"` — `<N>` the number `gh issue create` printed, and **the same subject string you passed to `check`**, so the next `check` for that finding meets it in the filed list instead of scoring a rewording. Without it the guard's ledger half never holds a row, and its exit **1** can never fire. If `filed` fails, retry it once; if it fails again, leave the issue alone — it exists and is correct — and report it as `unrecorded: #N <subject>`, so the controller runs `filed` for it. Report `filed: #N <subject>` for every issue you created — under the fleet, in your report to the controller. **The one window the guard cannot see:** `check` → `gh issue create` → `filed` is three commands, and the ledger's lock covers each alone, so two filers can both read `clean` in the seconds before either records. That gap is accepted, never a reason to skip `filed`. Post the numbers as one PR comment.
|
|
20
26
|
**A duplicate that should hold an open deferral is a comment, never a relabel.** Where the guard lands a finding whose home is an open issue on an existing one that is open, cite the refuters' verdict — or the review's votes — in the comment you leave there, and change no label. Never relabel `ready-for-agent` down to `needs-triage`: a `ready-for-agent` issue already holds a `needs-triage` finding, because triage already promoted it, and a later run's crashed refuters are no reason to send it back. A closed one cannot hold it: file a new open issue citing it, as the promotion rule above does for the closed record.
|
|
21
27
|
**Name where each deferral went, in the disposition record.** Every entry you defer carries `issue`: the number of the issue you filed it to, commented it onto, or appended it to — the `PR #<pr> review: the suggestion band, checked` record included. A `suggestion`'s entry — an `unverified` finding with `refutersDispatched` of zero — also carries `verdictPath`, applied or deferred, in scope and, above the claim bar, out of scope: the absolute path of a file holding its refuter's verdict as JSON, `{"refuted": <boolean>, "reason": "<string>"}`, under your own `<scratch>/pr<N>/fix-XXXXXXXX/<finding>/` run root. An out-of-scope one whose refuter crashed before any verdict reached you still names the path its verdict would have taken there; out of scope, that file missing or holding no decision files the finding open `needs-triage`, while in scope it is a mismatch. `dispositions-check.mjs` reads each named issue back through `gh issue view --json labels,state,title` and each verdict file off disk; a mismatch names the row of its filing table the entry broke, so move or relabel that filing to the home the row names and run the check again. With `gh` unreachable, or an issue it cannot read, that filing goes unchecked: with nothing else broken the verdict is `unchecked` — never `ok`, and it exits 1 — so run the check again once `gh` answers.
|
|
22
|
-
6. Diff-check green (run-bound per `ci-state.mjs`; under staleness see **`skipped` is not `passed`** for what the label then rests on) **and** deferrals filed **and** the PR carrying exactly one release label (`patch`/`minor`/`major`, counting only those three; **required on every PR** — `release-label.yml` auto-adds `patch` only to a dependabot or renovate PR that has none, and hard-fails any PR with none or more than one, so this never needs to check whether the repo defines the gate at all, and `gh label list` settles nothing here any more) **and** `dispositions-check.mjs --member fix-pr-<pr> --scratch <scratch>` run over your own record exiting 0 (standalone that is yours to run, from the worktree, after step 2 writes `<scratch>/dispositions-fix-pr-<pr>.json`; `--review <path>` names the review file, which you write yourself from the findings step 1 collected, in the shape **The review result file** describes — `pr`, `head`, `snapshot`, `counts` and the `survived`, `refuted` and `unverified` buckets; standalone you pass `--no-ledger` with it, so it writes no token and the exit status is the verdict — a `.fleet/ledger.md` the repository already holds is a previous run's, and without the flag it exits 2 for a ledger with no row for you; under the fleet `ledger.mjs dispatch` has already refused a finisher without it) → `gh pr comment <pr> --body "ready-to-merge-head: <prHead>"`, `prHead` being the full SHA your green `ci-state.mjs` reading reported, which the merge bot reads as the head the label was applied to,
|
|
28
|
+
6. Diff-check green (run-bound per `ci-state.mjs`; under staleness see **`skipped` is not `passed`** for what the label then rests on) **and** deferrals filed **and** the PR carrying exactly one release label (`patch`/`minor`/`major`, counting only those three; **required on every PR** — `release-label.yml` auto-adds `patch` only to a dependabot or renovate PR that has none, and hard-fails any PR with none or more than one, so this never needs to check whether the repo defines the gate at all, and `gh label list` settles nothing here any more) **and** `dispositions-check.mjs --member fix-pr-<pr> --scratch <scratch>` run over your own record exiting 0 (standalone that is yours to run, from the worktree, after step 2 writes `<scratch>/dispositions-fix-pr-<pr>.json`; `--review <path>` names the review file, which you write yourself from the findings step 1 collected, in the shape **The review result file** describes — `pr`, `head`, `snapshot`, `counts` and the `survived`, `refuted` and `unverified` buckets; standalone you pass `--no-ledger` with it, so it writes no token and the exit status is the verdict — a `.fleet/ledger.md` the repository already holds is a previous run's, and without the flag it exits 2 for a ledger with no row for you; under the fleet `ledger.mjs dispatch` has already refused a finisher without it) → `gh pr comment <pr> --body "ready-to-merge-head: <prHead>"`, `prHead` being the full SHA your green `ci-state.mjs` reading reported, which the merge bot reads as the head the label was applied to. The prefix `ready-to-merge-head:` is not a label: type it as written, whatever string the Label map gives `ready-to-merge`. Then `gh pr edit <pr> --add-label "<ready-to-merge string>"`. Do not merge. A non-zero dispositions exit halts you before the label, and you report the violations it printed. Zero or more than one release label halts you before the label, naming which you found — a timed-out `gh pr create` opens the PR with its `--label` unapplied and no exit status to react to, and nothing after this step re-derives the release label. **Under the fleet a finisher does this** — a fresh small agent the controller dispatches (after your final verdict, never on your bare idle). Gate it on the diff-validating **`check`** job, **not** on `ci-state --quiet` exit 0, which a behind PR — the normal case once any sibling merges — never reaches: a `rebase-check` red or heavy jobs `skipped` off the behind-count hold it short of full green, so an exit-0 gate strands every behind PR unlabelled. Label when `check` is present and green **and no heavy job (the diff-validating suites — *not* the `rebase-check` currency gate) is in `failure`** — a `skipped` heavy job is behind-count staleness and fine — **solely** off that count, which is a condition to establish rather than infer, see the five-condition note in `$(~/.fleet/bin/fleet-run --root)/skills/run-team/SKILL.md`'s fix-applier prompt block. A `failure` is the diff's own fault and blocks the label, else a genuinely broken PR gets labelled off a green `check` and burns a merge-bot rebase+CI cycle before the failure resurfaces. Read per-job state for this: run `ci-state.mjs` **without** `--quiet`, or read its `jobs` — the `--quiet` payload drops the per-job `jobs`/`missing` and the `dropped` list, keeping `reasons` (which still distinguishes `is failure` from `is skipped`). You reach step 6 yourself only when green is already in hand at push time.
|
|
23
29
|
|
|
24
30
|
**`verdict: "no-ci"` — this repo has no `check` job to gate on at all**, and that is a different state from red or unknown, not a third way to skip the wait. Label off step 3's own green `testCmd` run instead of a `check` job that will never exist — and only once `ci-state.mjs` reads `no-ci` **without** the flag, since a repo whose CI is merely misconfigured exits 2 there rather than reading no-ci. `--declare-no-ci` is your caller-side declaration that step 3's run **is** this repo's gate: it flips the exit code and echoes itself into `reasons`, so finding it in the payload confirms only that you passed it, never that anyone verified anything. **No green `testCmd` run on record → do not label.** Say in your verdict that the repo has no CI configured and no declaration, and stop — inferring a pass from silence here is exactly the misconfigured-CI case the declaration exists to rule out. See `ci-state.mjs --pr <n> --declare-no-ci` below.
|
|
25
31
|
|
|
@@ -65,7 +71,7 @@ jq '.refuted' "$R" # refuted: your
|
|
|
65
71
|
|
|
66
72
|
**Scan the findings against each other for MUTUAL EXCLUSION, and rule before the conflicting change reaches the tree.** Refuters are blind to their siblings, so two can approve changes that cannot both land — one preserving a comment block another's change deletes, one keeping a binding another collapses. Two runs produced it; in one, a refuter proved a variable collapse behavior-equivalent over 844 cases while its own blast-radius scan named the two comment blocks a *different* refuter had just established as guarding distinct pinned hazards. You hold every finding, so only you can see the pair — and the scan's two inputs arrive at different times, so run it twice. **Before you apply anything**, group the findings by `file:line` and by whether one's fix undoes another's; that is in the findings' own text. **Then as each refuter you dispatch reports**, read its blast radius against what you have already ruled on. **A conflicting pair goes to a SINGLE refuter, briefed with both claims** — that is what settled one such pair, one refuter ruling *"B wins: A's premise is false"* where two independent refuters would each have approved their own side. Defer only when no single refuter can settle it, with the equivalence evidence recorded in the filed issue so the work is not redone. Never let both reach the tree and hope the diff coheres.
|
|
67
73
|
|
|
68
|
-
**A finding whose suggested fix quotes text another applied finding deletes goes stale on arrival.**
|
|
74
|
+
**A finding whose suggested fix quotes text another applied finding deletes goes stale on arrival.** **Re-derive, never copy:** apply the finding that changes the text first, then derive the assertion from the post-fix tree. A `suggested_fix` is a hypothesis the review never ran; only the claim was refuted against.
|
|
69
75
|
|
|
70
76
|
**A `refuted=false` verdict is not an instruction to apply.** It says the finding survived refutation, not that the change is worth making — the two come apart exactly when the refuter confirms behavior-equivalence and falsifies the finding's *reason* in the same run. In the variable-collapse case the stated house-style premise was measurably false and the stated cost understated. Behavior-neutral plus a false rationale is a defer, however clean the verdict reads.
|
|
71
77
|
|
|
@@ -2,12 +2,23 @@
|
|
|
2
2
|
description: merge every ready-to-merge open PR in numeric order — rebase, wait green, merge, never jumping a related PR
|
|
3
3
|
---
|
|
4
4
|
|
|
5
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
6
|
+
|
|
5
7
|
Set the goal, then work it until no open PR is left:
|
|
6
8
|
|
|
7
9
|
`/goal Merge all of this repo's open PRs in numeric order if labeled ready-to-merge. Rebase -> Wait for checks green -> check for the ready-to-merge label -> merge if labeled. Never merge past a lower-numbered PR whose work is related — wait for its label instead.`
|
|
8
10
|
|
|
9
11
|
Only `ready-to-merge` PRs are in scope — it is the author's sign-off. Never add the label yourself. A PR-body line `main-gain-removal: <path> <key> - <why>` is a second sign-off, scoped to one file and one landing source: it lets through the removal of lines `main` gained after the PR began in that file from that source, and nothing else (step 3's `main-gain-removed`).
|
|
10
12
|
|
|
13
|
+
## The Label map
|
|
14
|
+
|
|
15
|
+
**At the start of your pass, before selection, read the Label map — once.** `~/.fleet/bin/fleet-run label-map.mjs show ready-to-merge` prints the string the tracker uses for `ready-to-merge`. Type that one string for the rest of your pass wherever this file polls or compares by label: `<ready-to-merge string>` below is what it printed, in both polls (the grace's and the Monitor's) and in the timeline comparison. You run no `ensure` and ask no one.
|
|
16
|
+
|
|
17
|
+
**A non-zero exit from `show` ends your pass before selection**, with nothing else done first and `ready-to-merge` never typed in place of the string:
|
|
18
|
+
|
|
19
|
+
- **A bot a controller dispatched** holds no grace. Read the queue your dispatch recorded, which needs no map — `~/.fleet/bin/fleet-run ledger.mjs read | jq -c '.queued["merge-bot-<n>"]'` — and write your one report giving every PR there `refused` with `reason` `label-map-refused`; an empty or absent queue gives every list empty. Validate it as **One verdict per queued PR** says, then send your final line followed by what `show` printed.
|
|
20
|
+
- **The top-level invocation** prints what `show` printed and stops. It writes no report.
|
|
21
|
+
|
|
11
22
|
## Order, and the hold rule
|
|
12
23
|
|
|
13
24
|
Lowest number first. But the label alone does not authorize a merge: **a labeled PR must not jump a lower-numbered open PR touching related work.** Numeric order is the author's intended order; jumping it silently rebases the lower PR onto changes it was never written against.
|
|
@@ -52,7 +63,7 @@ Obeying a fired signal blindly stalls the queue on a non-conflict; ignoring one
|
|
|
52
63
|
|
|
53
64
|
`ready-to-merge` is a finisher's verdict on one tree, and it does not expire when that tree does. **A GitHub label does not follow the branch** — one merged PR's timeline shows it, read with the timeline query below: `labeled ready-to-merge`, then commits and a `head_ref_force_pushed`, then `merged`, with no `unlabeled` anywhere between. The label stayed put while the head moved out from under it. Every other guard in this chain — the finisher's dispatch pin, the halt on a moved head, the worktree audit — runs *before* the label exists, so none of them is watching this window. You are the last gate, and **re-deriving the head is a requirement here, not bot discretion**: merge only a head that still carries the audit the label stands for.
|
|
54
65
|
|
|
55
|
-
**The labelled head is the head its labeller recorded.** Whoever adds `ready-to-merge` — a finisher, or `review-and-fix` run standalone — posts a PR comment whose whole body is `ready-to-merge-head: <sha>`, naming the head it audited, immediately before the label. Read the newest one before `gh pr update-branch` and before anything else that can move the head:
|
|
66
|
+
**The labelled head is the head its labeller recorded.** Whoever adds `ready-to-merge` — a finisher, or `review-and-fix` run standalone — posts a PR comment whose whole body is `ready-to-merge-head: <sha>`, naming the head it audited, immediately before the label. The prefix `ready-to-merge-head:` is not a label: type it as written, whatever string the Label map gives `ready-to-merge`. Read the newest one before `gh pr update-branch` and before anything else that can move the head:
|
|
56
67
|
|
|
57
68
|
```bash
|
|
58
69
|
gh pr view <pr> --json comments \
|
|
@@ -70,7 +81,7 @@ Nothing else names that head. A commit's dates are when it was made, not when it
|
|
|
70
81
|
|
|
71
82
|
```bash
|
|
72
83
|
gh api "repos/{owner}/{repo}/issues/<pr>/timeline?per_page=100" --paginate \
|
|
73
|
-
-q '.[] | select((.event == "labeled" and .label.name == "ready-to-merge")
|
|
84
|
+
-q '.[] | select((.event == "labeled" and .label.name == "<ready-to-merge string>")
|
|
74
85
|
or .event == "committed" or .event == "head_ref_force_pushed")
|
|
75
86
|
| .event + " " + (.sha // .label.name // "")'
|
|
76
87
|
```
|
|
@@ -318,7 +329,7 @@ Three dots, never two: a two-dot diff on a stale branch renders `main`'s gains a
|
|
|
318
329
|
**Only a bot a controller dispatched holds a grace** (`/skill:run-team`, or any caller that says it owns the watcher); the top-level invocation arms its Monitor instead (**Then stay armed**). You were dispatched on the first `ready-to-merge` label, never after anyone's report, and a label landing minutes after your last merge is the common case — so the pass does not end the moment the queue empties. It drains, then waits **15 minutes** for late labels, then reports once:
|
|
319
330
|
|
|
320
331
|
- Grace starts once no labelled PR is actionable — every one merged, skipped or held. Seed the labelled set then, the way **Then stay armed** seeds its Monitor, so a PR you already handled does not re-fire.
|
|
321
|
-
- Every 60s, poll `gh pr list --state open --label ready-to-merge --limit 200 --json number`. A number not in the seed → **re-run selection from the top**, hold rule included, drain what it makes actionable, and restart the grace after that drain. A failed poll is no reading: keep the seed and poll again. A poll that returns 200 numbers is not a whole reading either — gh stops at `--limit` with exit 0 and no warning, so a label past it is unseen: act on the numbers it did return, and name `poll-capped-at-200` in the report, so the controller knows the grace's silence covered only the first 200.
|
|
332
|
+
- Every 60s, poll `gh pr list --state open --label "<ready-to-merge string>" --limit 200 --json number`. A number not in the seed → **re-run selection from the top**, hold rule included, drain what it makes actionable, and restart the grace after that drain. A failed poll is no reading: keep the seed and poll again. A poll that returns 200 numbers is not a whole reading either — gh stops at `--limit` with exit 0 and no warning, so a label past it is unseen: act on the numbers it did return, and name `poll-capped-at-200` in the report, so the controller knows the grace's silence covered only the first 200.
|
|
322
333
|
- At grace start and on every 60s poll after it, also read `gh pr list --state open --limit 1 --json number`. An empty list (no PR open at all, any author, labelled or not) ends the grace: report and exit now. A failed read is no reading: keep waiting. It applies draining or not, and again after a late-label drain restarts the grace.
|
|
323
334
|
- 15 minutes with no new label → report and exit.
|
|
324
335
|
|
|
@@ -343,8 +354,9 @@ top-level invocation.
|
|
|
343
354
|
The pass ends, the queue does not. Once no labeled PR is actionable, arm a persistent Monitor so a later sign-off restarts the loop without re-running this command:
|
|
344
355
|
|
|
345
356
|
```bash
|
|
357
|
+
label="<ready-to-merge string>" # the string `show ready-to-merge` printed
|
|
346
358
|
cap=200 # the poll's --limit; gh stops there with exit 0 and no warning
|
|
347
|
-
poll() { gh pr list --state open --label
|
|
359
|
+
poll() { gh pr list --state open --label "$label" --limit "$cap" --json number --jq '.[].number' 2>/dev/null; }
|
|
348
360
|
capped=
|
|
349
361
|
capcheck() { # a full page may have been cut there: say so once, and once when it clears
|
|
350
362
|
if [ "$(printf '%s\n' "$1" | grep -c .)" -ge "$cap" ]; then
|
package/package.json
CHANGED
|
@@ -5,6 +5,8 @@ description: Use when user wants pick up new work — "what's next", "next ticke
|
|
|
5
5
|
|
|
6
6
|
# Next Ticket
|
|
7
7
|
|
|
8
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
9
|
+
|
|
8
10
|
Suggest ready tickets, maintainer picks, mark in-progress, implement at depth ticket needs, end with PR rebased on `origin/main`.
|
|
9
11
|
|
|
10
12
|
**Never grab ticket unilaterally.** Labels and git state record only some claims; others live in maintainer's head or another agent session.
|
|
@@ -13,6 +15,14 @@ Suggest ready tickets, maintainer picks, mark in-progress, implement at depth ti
|
|
|
13
15
|
|
|
14
16
|
## 1. Candidates
|
|
15
17
|
|
|
18
|
+
Before the query, run the Label map derivation step:
|
|
19
|
+
|
|
20
|
+
```bash
|
|
21
|
+
~/.fleet/bin/fleet-run label-map.mjs ensure
|
|
22
|
+
```
|
|
23
|
+
|
|
24
|
+
Exit 0 → the map is in place; go on. Exit 3 → it printed the question payload, a JSON object with `certain` and `uncertain`: render it to the maintainer as one question listing each uncertain role, its suggestion, why it is uncertain and the alternatives, ending with "reply `defaults` to accept every suggestion, or name `<role>=<label>` for any you want otherwise — a role with no suggestion must be named; labels that do not exist are created on your confirmation". **Wait for the answer**, then run `~/.fleet/bin/fleet-run label-map.mjs set --create` with it — `--accept-suggestions` for `defaults`, plus each `<role>=<label>` the maintainer named — and run `ensure` again, which now exits 0. Tell the maintainer how to make the answer permanent: add or edit the row for the role in the repository's triage-label table, the role in the first cell and the string in the second; never write that table yourself. Exit 1 or 2 → show what it printed and stop; neither is a question.
|
|
25
|
+
|
|
16
26
|
```bash
|
|
17
27
|
~/.fleet/bin/fleet-run candidates.mjs --require-label ready-for-agent --allow-fallback
|
|
18
28
|
```
|
|
@@ -74,15 +84,16 @@ Ask which. **Wait for answer.** Maintainer says taken → drop, re-suggest.
|
|
|
74
84
|
## 5. Claim it
|
|
75
85
|
|
|
76
86
|
```bash
|
|
77
|
-
gh label
|
|
78
|
-
gh issue edit <N> --add-label in-progress
|
|
87
|
+
gh issue edit <N> --add-label "<in-progress string>"
|
|
79
88
|
```
|
|
80
89
|
|
|
90
|
+
`<in-progress string>` is what `~/.fleet/bin/fleet-run label-map.mjs show in-progress` prints. The derivation step in step 1 already confirmed the label exists in the tracker, creating it on the maintainer's confirmation where it was missing.
|
|
91
|
+
|
|
81
92
|
Infer branch/worktree convention from `git worktree list` / `git branch -r` — commonly `feat|fix|refactor/<N>-slug` and `.worktrees/<N>-slug`. Branch off fresh `origin/main`, run the Install step, run the Check step, run the Test entrypoint as the baseline — the repo's **Recipe**, read from its Recipe cache: `~/.fleet/bin/fleet-run derive-testcmd.sh . install`, `… . check` and `… . test --at origin/main` print them. **No usable cache (any of the three exits 1) → run the Recipe derivation step first:** dispatch a `task` member, agent `fleet-recipe-deriver`, its prompt naming the main checkout's absolute path as `<repo>` and `<scratch>/derive-recipe/` as its scratch directory, `<scratch>` the output of `~/.fleet/bin/fleet-run scratch-root.mjs`; it reads the repo, proves all three commands in a throwaway worktree and writes the cache only on proof. `RECIPE NOT PROVEN` → stop and give the maintainer its reason; never pick a command yourself. Exit 3 is no verdict on the cache — the reader could not run a tool it needs — so fix that environment fault and re-run instead of deriving.
|
|
82
93
|
|
|
83
94
|
**Run the Install step with `CI` removed**, from the new worktree's root: `env -u CI sh -c "<install>"`, `<install>` the output of `derive-testcmd.sh . install`. A setup script that skips under `CI` installs no git hooks there, and you would then commit with the repository's commit-time checks silently absent. Only the Install step loses `CI`; the Check step and the Test entrypoint baseline run in your shell's own environment.
|
|
84
95
|
|
|
85
|
-
Abandoned before PR opens → remove
|
|
96
|
+
Abandoned before PR opens → remove the `<in-progress string>` label.
|
|
86
97
|
|
|
87
98
|
## 6. Size the ticket, then pick a path
|
|
88
99
|
|
package/skills/run-team/SKILL.md
CHANGED
|
@@ -5,6 +5,8 @@ argument-hint: "[in-flight] [cost|speed]"
|
|
|
5
5
|
disable-model-invocation: true
|
|
6
6
|
---
|
|
7
7
|
|
|
8
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
9
|
+
|
|
8
10
|
Run `next-ticket`, `review-and-fix`, `run-merge-bot` as one fleet. You are the
|
|
9
11
|
**controller**, in the main thread, never a member.
|
|
10
12
|
|
|
@@ -12,13 +14,11 @@ Run `next-ticket`, `review-and-fix`, `run-merge-bot` as one fleet. You are the
|
|
|
12
14
|
a positive integer, default 5, and the Objective, default `cost`.
|
|
13
15
|
Merge bot is at most one, not configurable.
|
|
14
16
|
|
|
15
|
-
|
|
16
|
-
it only when a member needs the *why*. A rule without that line carries its
|
|
17
|
-
reasoning inline — nothing is missing.
|
|
17
|
+
A rule ending `See references/<file>` keeps its war story there, read only for the *why*; a rule without that line carries its reasoning inline.
|
|
18
18
|
|
|
19
19
|
## Invariants
|
|
20
20
|
|
|
21
|
-
These hold in every phase: check
|
|
21
|
+
These hold in every phase: check each wake against them, and report evidence that one is broken.
|
|
22
22
|
|
|
23
23
|
- In-flight tickets at most the bound (default 5), at most one merge bot; the bound counts tickets, not live agents.
|
|
24
24
|
- A grandchild surfaces as its own task-notification; an unrecognized task-id is not a member reporting done.
|
|
@@ -28,7 +28,7 @@ These hold in every phase: check a wake against them before you act on it, and r
|
|
|
28
28
|
- Every member acts through the maintainer's `gh` credentials, so no write is attributable: when a label moves unexpectedly, ask members directly, rule out automation with `grep -rn '<label>' .github/workflows/`, and do not re-add it.
|
|
29
29
|
- Phase 1 is serial; everything else may run concurrently.
|
|
30
30
|
|
|
31
|
-
|
|
31
|
+
Reasoning: references/invariants.md.
|
|
32
32
|
|
|
33
33
|
## Phase 0 — shortlist
|
|
34
34
|
|
|
@@ -33,4 +33,6 @@ A member runs its test suite in the foreground and blocks on it. Exit 75 from th
|
|
|
33
33
|
Never run `pkill -f` on a pattern: members share one process table, so a pattern such as a test file's name matches every member's run, not only yours. Clearing your own leftover process needs its PID; report a stalled run to the controller instead.
|
|
34
34
|
## kind: repair
|
|
35
35
|
|
|
36
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
37
|
+
|
|
36
38
|
An earlier finisher on this PR reported `labelled`, but its read-back did not carry `ready-to-merge`: you are the repair finisher. Duty 3's script decides whether the label is on, as your agent definition says.
|
|
@@ -15,6 +15,7 @@ ticket ticket
|
|
|
15
15
|
literal your name
|
|
16
16
|
literal outcome
|
|
17
17
|
literal that path
|
|
18
|
+
literal what show printed
|
|
18
19
|
---
|
|
19
20
|
## kind: review, dispositions-retry
|
|
20
21
|
You are ALREADY in worktree `<abs-path>`, whose PR branch is `<branch>` — the
|
|
@@ -43,6 +44,19 @@ own issue with the label the finding's state calls for. Skip step 1 — the
|
|
|
43
44
|
review already ran — and steps 4 and 6: the controller owns the CI wait and
|
|
44
45
|
dispatches the finisher.
|
|
45
46
|
|
|
47
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
48
|
+
|
|
49
|
+
**Before your first edit or refuter dispatch, read the Label map — the two
|
|
50
|
+
roles you type or compare, once — and use those strings for the rest of your
|
|
51
|
+
run.** `~/.fleet/bin/fleet-run label-map.mjs show needs-triage` and
|
|
52
|
+
`~/.fleet/bin/fleet-run label-map.mjs show wontfix` each print the string the
|
|
53
|
+
tracker uses; every `gh` command and label comparison those steps of
|
|
54
|
+
`review-and-fix.md` type for those two roles takes it. You never run `ensure`
|
|
55
|
+
and never ask anyone. **A non-zero exit from `show` ends you with no report** —
|
|
56
|
+
the one ending in this brief that writes none, whatever the report paragraph
|
|
57
|
+
below says: do nothing else first, never type the role name in place of the
|
|
58
|
+
string, send `<your name>: failed (no report): <what show printed>` and exit.
|
|
59
|
+
|
|
46
60
|
**The review's result is `<scratch>/pr<pr>/<run>/review.json`** — the digest first
|
|
47
61
|
(`jq '{pr, head, resume, testEnvironment, suiteVerdict, dimensionsRun, dimensionsUnrun, cwdAudit, counts}'`),
|
|
48
62
|
then every finding (`jq '.survived'`, `jq '.unverified'`, `jq '.refuted'`).
|
|
@@ -12,7 +12,9 @@ Your report is a file, `<scratch>/reports/merge-bot-<n>.json`, in the shape
|
|
|
12
12
|
before your final message, and send nothing until
|
|
13
13
|
`~/.fleet/bin/fleet-run report-schema.mjs validate merge-bot <scratch>/reports/merge-bot-<n>.json`
|
|
14
14
|
answers `valid`. Your final message is then one line,
|
|
15
|
-
`merge-bot-<n>: done <scratch>/reports/merge-bot-<n>.json`.
|
|
15
|
+
`merge-bot-<n>: done <scratch>/reports/merge-bot-<n>.json`. A Label map
|
|
16
|
+
refusal, which `run-merge-bot.md` describes, follows that line with what
|
|
17
|
+
`show` printed.
|
|
16
18
|
|
|
17
19
|
The controller does not acknowledge reports. Send once and exit; never re-send unless the controller asks by name.
|
|
18
20
|
Confirmation state includes warnings received and acted on, even when the outcome is no change: say so when you report.
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# CI reading and staleness
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
Why green not verdict, why absence is its own verdict, why conclusion not
|
|
4
6
|
stable, why behind-count only honest signal, why the tick runs on every wake
|
|
5
7
|
and why the beat is shaped as it is. Assertions live in SKILL.md's wake table,
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# The finisher: why its gate and duties are shaped the way they are
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
Evidence for the finisher rules the finisher's agent body, `agents/fleet-finisher.agent.md`, and SKILL.md's **The finisher gate** state, keyed by the rule each justifies.
|
|
4
6
|
|
|
5
7
|
## The fix-applier pushes and exits; the finisher is dispatched fresh
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# Invariants: the full statements
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
The invariants SKILL.md states one line each, as they read before they were tightened.
|
|
4
6
|
|
|
5
7
|
- In-flight tickets at most the bound (default 5), ≤ 1 merge bot. The bound
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# The run ledger: the evidence behind its rules
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
Evidence for the rules SKILL.md's wake and dispatch sections state, keyed by the rule each justifies.
|
|
4
6
|
|
|
5
7
|
## Writer policy: every write is serialized by `<file>.lock`
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# Member lifecycle: naming, fresh context, recovery
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
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.
|
|
4
6
|
|
|
5
7
|
## Every member is named
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# Landing a change on main
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
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.
|
|
4
6
|
|
|
5
7
|
## When to fix the tooling mid-run, and its shape
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# Phase 0: what each step does and why
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
`phase0.mjs` runs the start sequence and writes the receipt `.fleet/phase0.json`; SKILL.md's phase 0 step 0 says how to drive it and what to do about each `NEED` line. This file is what each step means, in the order the script runs them, for the controller to read when a step refuses or a line asks for more than SKILL.md says. One heading per step.
|
|
4
6
|
|
|
5
7
|
**Run it from a Python eval cell, never the bash tool.** That kernel's
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# The Pull: what each step does and why
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
`pull.mjs` runs the Pull; SKILL.md's phase 1 says how to drive it, how to read the tick's `PULL` row and how to answer the questions it asks. This file is what each step means, and the measured reasons behind them, for the controller to read when a step refuses or an answer needs more than SKILL.md says.
|
|
4
6
|
|
|
5
7
|
## The steps
|
|
@@ -174,8 +176,8 @@ terminating in exactly one dispatch or an empty shortlist:
|
|
|
174
176
|
for. Give exactly one — the direction is not inferable from the string, and
|
|
175
177
|
the wrong one answers the opposite verdict with full confidence.
|
|
176
178
|
|
|
177
|
-
A needle that itself starts with `--` — `--label ready-for-agent`
|
|
178
|
-
|
|
179
|
+
A needle that itself starts with `--` — `--label ready-for-agent` is an
|
|
180
|
+
illustration of one, a role name and not a string to type — needs the end-of-options separator: `--gone
|
|
179
181
|
-- '<string>'`/`--present -- '<string>'`. Given bare, with no `--`
|
|
180
182
|
immediately before it, the value guard still refuses it — `staleness:
|
|
181
183
|
--gone needs a value` — at exit 2, a could-not-check to admit and annotate,
|
|
@@ -317,10 +319,10 @@ fleet has already judged unimplementable straight to the next member.
|
|
|
317
319
|
yours to judge: `pull.mjs` finds it at step 3 and posts its own comment naming
|
|
318
320
|
the stranded comment's heading line and URL, which is not one of the
|
|
319
321
|
`briefs/relabel.md` comments.
|
|
320
|
-
`gh issue edit <N> --remove-label ready-for-agent --add-label <label
|
|
322
|
+
`gh issue edit <N> --remove-label "<ready-for-agent string>" --add-label "<label string>"` (no
|
|
321
323
|
`in-progress` to drop — it was never claimed), preceded by exactly one comment,
|
|
322
324
|
the one `~/.fleet/bin/fleet-run dispatch-prompt.mjs render relabel --kind <kind> …`
|
|
323
|
-
prints. `--kind needs-triage` takes `--line`, the one-line missing decision;
|
|
325
|
+
prints. Each `<… string>` is what `~/.fleet/bin/fleet-run label-map.mjs show <role>` prints for that role — `<label string>` for the role the cause names — and you type that string, not the role name; where the rendered comment names `ready-for-agent`, file the string `~/.fleet/bin/fleet-run label-map.mjs show ready-for-agent` prints in its place. `--kind needs-triage` takes `--line`, the one-line missing decision;
|
|
324
326
|
`--kind fork` takes `--options`, the options verbatim from the brief, and is
|
|
325
327
|
the `ready-for-human` comment for a fork; `--kind hands` takes `--hands`,
|
|
326
328
|
one of external access, manual testing or judgment during the work, and
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# Reaping merged branches and worktrees
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
Why reap runs after each merge pass, why `commit-commands:clean_gone` disqualified, why hand-rolled reap shaped this way (implemented by `reap.sh`), and why a claim that never became a PR needs a different script (`release-ticket.sh`). Assertions these justify live in SKILL.md's **Merge-bot pass reports done** wake and its Failure handling row for a claim abandoned mid-run; evidence here.
|
|
4
6
|
|
|
5
7
|
## Reap after each merge pass, not once at the end
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
# The tick's rows: what each asks of the controller
|
|
2
2
|
|
|
3
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
4
|
+
|
|
3
5
|
The full text of each row `fleet-tick.mjs` prints and what it asks of the controller. SKILL.md's **The tick's rows** carries one line for each.
|
|
4
6
|
|
|
5
7
|
- `PULL #<N> …` — one Pull per named ticket, in the order printed: phase 1's
|
|
@@ -5,6 +5,8 @@ description: Use before implementing ticket — decides how much process work ne
|
|
|
5
5
|
|
|
6
6
|
# Sizing a Ticket
|
|
7
7
|
|
|
8
|
+
Label names in this file are roles; the Label map gives the string to type; a member never derives the map.
|
|
9
|
+
|
|
8
10
|
Judge ticket **as written**, not as hoped. Torn between rows → take heavier —
|
|
9
11
|
process depth, not admissibility.
|
|
10
12
|
|