@feigi/fleet-ctl 3.94.0 → 3.94.1

package/agents/fleet-implementer-slow-high.agent.md

@@ -240,6 +240,10 @@ including if the `Sizing:` line was written before the run and corrected after;
 `sizing.verdict` and `sizing.signal` are that line's verdict and signal.
 Nothing in the PR body separates a measured verdict from one typed in early;
 that field is the only thing that does, and an unreported ordering costs the
-covariate. A bail is `outcome` `bailed`, its cause in `bailCause`. Then send
+covariate. A bail is `outcome` `bailed`, its cause in `bailCause`: the
+pre-code outcome, before you touch code. A block or ambiguity you find after
+implementation began — the work cannot finish without a ruling or human hands
+you do not have — is `outcome` `blocked` instead, with `pr`, `head` and `bailCause` `null` and
+the reason in `bailDetail`; report it rather than ending with no report. Then send
 the one line your brief gives, `<your name>: <outcome> <path>`, and exit. Never
 apply `ready-to-merge`, never merge.

package/agents/fleet-implementer-slow-medium.agent.md

@@ -240,6 +240,10 @@ including if the `Sizing:` line was written before the run and corrected after;
 `sizing.verdict` and `sizing.signal` are that line's verdict and signal.
 Nothing in the PR body separates a measured verdict from one typed in early;
 that field is the only thing that does, and an unreported ordering costs the
-covariate. A bail is `outcome` `bailed`, its cause in `bailCause`. Then send
+covariate. A bail is `outcome` `bailed`, its cause in `bailCause`: the
+pre-code outcome, before you touch code. A block or ambiguity you find after
+implementation began — the work cannot finish without a ruling or human hands
+you do not have — is `outcome` `blocked` instead, with `pr`, `head` and `bailCause` `null` and
+the reason in `bailDetail`; report it rather than ending with no report. Then send
 the one line your brief gives, `<your name>: <outcome> <path>`, and exit. Never
 apply `ready-to-merge`, never merge.

package/agents/fleet-implementer-smol-high.agent.md

@@ -240,6 +240,10 @@ including if the `Sizing:` line was written before the run and corrected after;
 `sizing.verdict` and `sizing.signal` are that line's verdict and signal.
 Nothing in the PR body separates a measured verdict from one typed in early;
 that field is the only thing that does, and an unreported ordering costs the
-covariate. A bail is `outcome` `bailed`, its cause in `bailCause`. Then send
+covariate. A bail is `outcome` `bailed`, its cause in `bailCause`: the
+pre-code outcome, before you touch code. A block or ambiguity you find after
+implementation began — the work cannot finish without a ruling or human hands
+you do not have — is `outcome` `blocked` instead, with `pr`, `head` and `bailCause` `null` and
+the reason in `bailDetail`; report it rather than ending with no report. Then send
 the one line your brief gives, `<your name>: <outcome> <path>`, and exit. Never
 apply `ready-to-merge`, never merge.

package/agents/fleet-implementer-task-high.agent.md

@@ -240,6 +240,10 @@ including if the `Sizing:` line was written before the run and corrected after;
 `sizing.verdict` and `sizing.signal` are that line's verdict and signal.
 Nothing in the PR body separates a measured verdict from one typed in early;
 that field is the only thing that does, and an unreported ordering costs the
-covariate. A bail is `outcome` `bailed`, its cause in `bailCause`. Then send
+covariate. A bail is `outcome` `bailed`, its cause in `bailCause`: the
+pre-code outcome, before you touch code. A block or ambiguity you find after
+implementation began — the work cannot finish without a ruling or human hands
+you do not have — is `outcome` `blocked` instead, with `pr`, `head` and `bailCause` `null` and
+the reason in `bailDetail`; report it rather than ending with no report. Then send
 the one line your brief gives, `<your name>: <outcome> <path>`, and exit. Never
 apply `ready-to-merge`, never merge.

package/agents/fleet-implementer-task-max.agent.md

@@ -240,6 +240,10 @@ including if the `Sizing:` line was written before the run and corrected after;
 `sizing.verdict` and `sizing.signal` are that line's verdict and signal.
 Nothing in the PR body separates a measured verdict from one typed in early;
 that field is the only thing that does, and an unreported ordering costs the
-covariate. A bail is `outcome` `bailed`, its cause in `bailCause`. Then send
+covariate. A bail is `outcome` `bailed`, its cause in `bailCause`: the
+pre-code outcome, before you touch code. A block or ambiguity you find after
+implementation began — the work cannot finish without a ruling or human hands
+you do not have — is `outcome` `blocked` instead, with `pr`, `head` and `bailCause` `null` and
+the reason in `bailDetail`; report it rather than ending with no report. Then send
 the one line your brief gives, `<your name>: <outcome> <path>`, and exit. Never
 apply `ready-to-merge`, never merge.

package/package.json

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

package/scripts/fleet-event.mjs

@@ -50,6 +50,7 @@
 //       opens with no sha, is a NEED and N is left untouched, claim and all.
 //       The PR a `covered` detail names is never written to.
 //       A `PR#M` outcome also sets the claim branch's upstream when it has none: `reap.sh` keeps a branch with no upstream, and only an upstream's `[gone]` state makes it reapable. It writes `branch.<b>.remote` and `branch.<b>.merge` only while the merge key is unset, and prints `NEED upstream <b> — <why>` when a write fails.
+//       A `blocked` outcome takes no action beyond the settle: no label, comment, release or upstream, so the ticket keeps `in-progress`.
 //   fix-report <fix-pr-M[-x]>
 //       `settle --from-report`, which records the filings and rulings the
 //       report carries. Settled `applied:`/`no-op`, on a PR whose rows carry

package/scripts/ledger.mjs

@@ -2508,6 +2508,9 @@ function recordFiled(id, subject) {
 //                             own repository name N;
 //                             the Check-step record (below) holds for <head>
 //   impl-N=bailed             bailCause is not null; the receipt names it
+//   impl-N=blocked            nothing to check: report-schema.mjs already
+//                             refuses a block that names a bailCause, a pr or
+//                             a head, or gives no reason in bailDetail
 //   fix-pr-M=applied:<head>   origin's refs/heads/<branch> is <head>, fetched
 //                             by verify-sha.sh; the Check-step record (below)
 //                             holds for <head>
@@ -2670,6 +2673,8 @@ async function runSettleFromReport() {
       const { view: pr, numbers } = prViewClosing(report.pr, "state,closingIssuesReferences,url");
       check(`PR #${report.pr} reads OPEN`, pr.state === "OPEN");
       check(`PR #${report.pr} closes #${live.number}`, numbers.includes(live.number));
+    } else if (report.outcome === "blocked") {
+      outcome = "blocked";
     } else {
       outcome = "bailed";
       check(`bailCause: ${report.bailCause}`, report.bailCause !== null);

package/scripts/member-outcomes.mjs

@@ -146,6 +146,7 @@ export function withReports(rows, scratch) {
 //                 opened one (more than one leaves the pr column blank), or
 //                 the last report claims a PR an earlier same-ticket
 //                 implementer opened in this session;
+//   blocked       the last report blocks mid-implementation;
 //   bail:<cause>  the last report bails (`fixed` is checked against main);
 //   provider      a model fell back, or the last turn errored;
 //   budget        a budget notice reached the member;
@@ -162,6 +163,7 @@ export function endingOf({ member, pr, signals = null, earlierPrs = new Set(), v
   if (signals.openedPrs.length > 0) return "pr";
   const last = lastReport(signals.reportWrites, member.split("/").pop());
   if (last?.outcome === "pr" && earlierPrs.has(String(last.pr))) return "pr";
+  if (last?.outcome === "blocked") return "blocked";
   // lastReport passed the impl schema, whose bailCause is a BAILS key or null.
   if (last?.bailCause) return bailEnding(last, verifyMain);
   if (signals.providerFallback || signals.lastStopReason === "error") return "provider";

package/scripts/pull-attribution.mjs

@@ -38,8 +38,8 @@
 //   counted   every other Pull: the only ones in a cell's figures.
 //
 // ENDINGS come from member-outcomes' `ending` column. The cell's: `hollow`,
-// `budget`, `bail:fixed-refuted`, `unknown`. The ticket's: every other
-// `bail:<cause>`. Neither's: `provider`, `crash`, `abort`.
+// `budget`, `bail:fixed-refuted`, `unknown`. The ticket's: `blocked` and every
+// other `bail:<cause>`. Neither's: `provider`, `crash`, `abort`.
 //
 // CLAIMS. A merged Pull is one claim, false when its Ruling fails the floor
 // (`minted_false_claim=yes` or `closed_own_ticket=no`). Each `bail:fixed` or
@@ -125,7 +125,7 @@ function datedRows(features) {
 
 const CELL_ENDINGS = new Set(["hollow", "budget", "bail:fixed-refuted", "unknown"]);
 const NEITHER_ENDINGS = new Set(["provider", "crash", "abort"]);
-const ticketsEnding = (e) => e.startsWith("bail:") && !CELL_ENDINGS.has(e);
+const ticketsEnding = (e) => e === "blocked" || (e.startsWith("bail:") && !CELL_ENDINGS.has(e));
 const failsFloor = (ruling) => ruling.minted_false_claim === "yes" || ruling.closed_own_ticket === "no";
 // An omp session id opens with its ISO start time, so two of them sort in time order.
 const STARTED = /^\d{4}-\d{2}-\d{2}T/;

package/scripts/report-files.mjs

@@ -6,7 +6,7 @@
 // (flat: no per-run directory), `<member>` being its ledger name (`impl-412`,
 // `impl-412-b`, `fix-pr-88`, `finisher-pr-88`, `merge-bot-3`). The file is
 // checked against the schema of the member's family, report-schema.mjs's
-// SCHEMAS, and the rule reportViolation() adds to it. The review runner and
+// SCHEMAS, and the rules reportViolation() adds to them. The review runner and
 // every member outside those four families have no schema, so no file to
 // look up.
 //

package/scripts/report-schema.mjs

@@ -18,9 +18,14 @@
 //   0  print: the schema is on stdout. validate: `valid` on stdout
 //   1  validate: `invalid: <violation>` on stdout, naming the FIRST violation;
 //      a file that is not JSON is invalid too, as `$: not JSON (...)`, and so
-//      is one that repeats a key, as `$.merged: duplicate key "merged"`, and
-//      a merge-bot report giving one PR two verdicts, as
-//      `$.refused[0].pr: PR #<pr> already has a verdict at $.merged[0].pr`
+//      is one that repeats a key, as `$.merged: duplicate key "merged"`, a
+//      merge-bot report giving one PR two verdicts, as
+//      `$.refused[0].pr: PR #<pr> already has a verdict at $.merged[0].pr`,
+//      and an impl report whose `blocked` outcome names a `bailCause`, as
+//      `$.bailCause: "<cause>" is not null, with outcome "blocked" — a block
+//      is no bail`, gives no reason in `bailDetail`, or names a `pr` or a
+//      `head`, as `$.pr: <pr> is not null, with outcome "blocked" — a block
+//      reports no PR`
 //   2  usage: no or unknown subcommand, a wrong argument count, an unknown
 //      family, any flag; or <file> could not be read; or print could not
 //      write the schema to stdout. Refused on stderr, nothing on stdout
@@ -112,7 +117,9 @@ const issues = listOf({ issue: id, subject: str });
 export const SCHEMAS = {
   impl: report({
     member: str,
-    outcome: { type: "string", enum: ["pr", "bailed"] },
+    // `bailed` is the pre-code outcome; `blocked` a block or ambiguity found
+    // after implementation began, its reason in `bailDetail`.
+    outcome: { type: "string", enum: ["pr", "bailed", "blocked"] },
     pr: { ...id, type: ["integer", "null"] },
     head: { type: ["string", "null"], pattern: HEX },
     branch: str,
@@ -174,14 +181,25 @@ export function mergeBotVerdicts(report) {
   ];
 }
 
-// The first violation of `family`'s schema by `value`, or null; for a
-// merge-bot report then the rule no schema keyword states: each PR gets one
-// verdict — merged, held, conflict-held or refused — the last it reached in
-// the pass, so a PR named twice, in one list or in two, is a violation at
-// its second entry.
+// The first violation of `family`'s schema by `value`, or null; then the rules
+// no schema keyword states. For an impl report: a `blocked` outcome names no
+// `bailCause`, since a block is no bail, gives its reason in `bailDetail`,
+// text that is not only whitespace, and names no `pr` or `head`, since a block
+// reports no PR — a PR it opened is outcome `pr`, which settle checks. For a
+// merge-bot report: each PR gets one verdict — merged, held, conflict-held or
+// refused — the last it reached in the pass, so a PR named twice, in one list
+// or in two, is a violation at its second entry.
 export function reportViolation(family, value) {
   const found = validate(SCHEMAS[family], value);
-  if (found !== null || family !== "merge-bot") return found;
+  if (found !== null) return found;
+  if (family === "impl" && value.outcome === "blocked") {
+    if (value.bailCause !== null) return `$.bailCause: ${show(value.bailCause)} is not null, with outcome "blocked" — a block is no bail`;
+    if (!/\S/.test(value.bailDetail ?? "")) return `$.bailDetail: ${show(value.bailDetail)} is not a reason, with outcome "blocked"`;
+    for (const field of ["pr", "head"]) {
+      if (value[field] !== null) return `$.${field}: ${show(value[field])} is not null, with outcome "blocked" — a block reports no PR`;
+    }
+  }
+  if (family !== "merge-bot") return null;
   const first = new Map();
   for (const { pr, path } of mergeBotVerdicts(value)) {
     if (first.has(pr)) return `${path}: PR #${pr} already has a verdict at ${first.get(pr)}`;

package/skills/run-team/SKILL.md

@@ -792,7 +792,7 @@ Match the failure to its row in the table below and run that response; where the
 |---|---|
 | SHA not on expected branch | Flag, do not enqueue, report |
 | Implementer bails before implementing | Act by the report's `bailCause` as the **Relabel causes** table says, then refill (**What a wake owes beyond its call**) |
-| Implementer blocked or ambiguous *mid-implementation* | Free the slot, `ledger.mjs settle impl-<N> blocked`, leave `in-progress`, report — the ticket is not In flight and waits for a human; the row above is the pre-code bail, not this one |
+| Implementer blocked or ambiguous *mid-implementation* | Free the slot. A `blocked` report settles on the **Implementer report** wake, no label moved; with no report, `ledger.mjs settle impl-<N> blocked`, its Ending still `hollow`. Leave `in-progress`, report — the ticket is not In flight and waits for a human; the row above is the pre-code bail |
 | `review-pr` workflow throws or returns no tree | Retry once under the next letter (`review-pr-<pr#>-b`); still failing, report and leave the PR at review-due. Never enqueue the PR as reviewed — the workflow is not a member, so no other row here covers it |
 | Reviewer, fix-applier or red-check fixer cannot reach green | Report, leave the PR unlabeled, free the slot — a fix-applier or red-check fixer settles `failed` |
 | Merge bot hits the hold rule | Report `held-behind-#<lower>`, PR stays queued |
@@ -841,9 +841,7 @@ enqueue, do not return the ticket to the shortlist until the maintainer rules.
 escalate if it repeats, and never read it as `not reachable` or record it as a
 stray commit. See references/failure-handling.md.
 
-**Never `--delete-branch` — the merge bot deletes the head branch itself.**
-`gh pr merge <n> --merge` alone: the flag's local cleanup errors on a `main`
-held by another worktree, or strands the feature worktree on `main`.
+**Never `--delete-branch` — the merge bot deletes the head branch itself.** See references/failure-handling.md.
 
 **Never force a rebase to start.** No `git clean`, `git checkout .`,
 `git reset --hard`, `git stash`. Non-empty `git status --porcelain -unormal` →

package/skills/run-team/references/failure-handling.md

@@ -66,6 +66,13 @@ escalate if it repeats. Never read exit 2 as `not reachable`, and never record i
 as a stray commit — the flag and the maintainer's ruling above are what exit 1
 earns, and spending them on a probe that never answered costs a member its
 ticket over a failure a re-run would have cleared.
+
+## Never `--delete-branch`
+
+**Never `--delete-branch` — the merge bot deletes the head branch itself.**
+`gh pr merge <n> --merge` alone: the flag's local cleanup errors on a `main`
+held by another worktree, or strands the feature worktree on `main`.
+
 ## Never force a rebase to start
 
 **Never force a rebase to start.** No `git clean`, `git checkout .`,