@feigi/fleet-ctl 3.94.0 → 3.95.0

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.95.0",
   "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/pr-cost.mjs

@@ -65,7 +65,7 @@ import { gitEnv } from "./git-env.mjs";
 import { fleetFile, FleetDirUnresolvable } from "./fleet-dir.mjs";
 import { isCLI } from "./is-cli.mjs";
 import { parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
-import { AttributionError, attribute, parseFeatures, tally } from "./pull-attribution.mjs";
+import { AttributionError, attribute, bootUnit, bootstrapDiffCI, parseFeatures, tally, underFloor } from "./pull-attribution.mjs";
 import { RulingError, parseTierOutcomes } from "./tier-outcomes.mjs";
 
 const NAME = "pr-cost";
@@ -78,9 +78,6 @@ export const BASELINE_CELL = "slow-high";
 // Stage 1 is the model axis at fixed `high`.
 export const STAGE_1 = ["slow-high", "task-high", "smol-high"];
 export const MIN_N = 20;
-// A cell trips when its fail rate is at least this many points above the
-// baseline's, or its mean $ is at least the baseline's.
-export const TRIP_POINTS = 15;
 export const EXIT = { ok: 0, tripped: 3, none: 4 };
 export const GH_PR_LIMIT = 1000;
 
@@ -94,77 +91,36 @@ function median(xs) {
   return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
 }
 
-// Deterministic, so a re-run prints the same interval.
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return () => {
-    a = (a + 0x6d2b79f5) >>> 0;
-    let t = a;
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-// Each unit is one booked group: `{ usd, merged }`. mean_usd is Σusd / Σmerged.
-export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed = 1 } = {}) {
-  if (!cellUnits.length || !baseUnits.length) return null;
-  const rand = mulberry32(seed);
-  const resample = (units) => {
-    let u = 0, m = 0;
-    for (let i = 0; i < units.length; i++) {
-      const x = units[Math.floor(rand() * units.length)];
-      u += x.usd; m += x.merged;
-    }
-    return m ? u / m : null;
-  };
-  const diffs = [];
-  for (let i = 0; i < iterations; i++) {
-    const a = resample(cellUnits), b = resample(baseUnits);
-    if (a !== null && b !== null) diffs.push(a - b);
-  }
-  if (diffs.length < iterations / 2) return null;
-  diffs.sort((x, y) => x - y);
-  return [round(diffs[Math.floor(0.025 * (diffs.length - 1))], 2), round(diffs[Math.ceil(0.975 * (diffs.length - 1))], 2)];
-}
-
-// The trip rule, in integer counts so a 3-of-20 difference is exactly 15
-// points rather than 14.999… in floating point. `n` is a cell's claims and
-// `n_pass` the claims among them that held.
+// The trip rule: the quality floor (pull-attribution.mjs's `underFloor`, in
+// integer counts), or a mean $ at least the baseline's. Each side is
+// `{ claims, failed, mean_usd }`.
 export function trips(cell, base) {
-  const failC = cell.n - cell.n_pass, failB = base.n - base.n_pass;
-  const failRise = (failC * base.n - failB * cell.n) * 100 >= TRIP_POINTS * cell.n * base.n;
-  return failRise || cell.mean_usd >= base.mean_usd;
+  return underFloor(cell, base) || cell.mean_usd >= base.mean_usd;
 }
 
 export function computeReport({ members, tiers, features, prs, routerTable = null, pricing = null, windowStart = WINDOW_START }) {
   const units = attribute({ features, members, tiers, prs, windowStart });
-  const counted = units.filter((u) => u.status === "counted");
   const tallies = new Map(tally(units).map((t) => [t.cell, t]));
-  const countedIn = (cell, generation) => counted.filter((u) => u.cell === cell && u.generation === generation);
-  const bootUnits = (us) => us.map((u) => ({ usd: u.spend, merged: u.merged ? 1 : 0 }));
+  const bootUnits = (g) => g.pulls.map(bootUnit);
   const meanUsd = (t) => (t.merged ? t.spend / t.merged : null);
   const base = tallies.get(BASELINE_CELL) ?? null;
   // One generation's figures. The interval is the newest generation's against
   // the baseline's newest; an older generation is printed, never compared.
-  const figuresOf = (cell, g, newest) => {
-    const mine = countedIn(cell, g.generation);
-    return {
-      cell,
-      generation: g.generation,
-      n_pulls: g.n,
-      n_merged: g.merged,
-      n_claims: g.claims,
-      n_failed: g.failed,
-      fail_rate: g.claims ? round(g.failed / g.claims) : null,
-      mean_usd: round(meanUsd(g), 2),
-      median_usd: round(median(mine.filter((u) => u.merged).map((u) => u.spend)), 2),
-      router_usd: round(mine.reduce((s, u) => s + routerUsd(u.pull), 0), 4),
-      usd_diff_ci95: !newest || cell === BASELINE_CELL || !base ? null : bootstrapDiffCI(bootUnits(mine), bootUnits(countedIn(BASELINE_CELL, base.generation))),
-      left_out: g.left_out,
-      unpriced: g.unpriced,
-    };
-  };
+  const figuresOf = (cell, g, newest) => ({
+    cell,
+    generation: g.generation,
+    n_pulls: g.n,
+    n_merged: g.merged,
+    n_claims: g.claims,
+    n_failed: g.failed,
+    fail_rate: g.claims ? round(g.failed / g.claims) : null,
+    mean_usd: round(meanUsd(g), 2),
+    median_usd: round(median(g.pulls.filter((u) => u.merged).map((u) => u.spend)), 2),
+    router_usd: round(g.pulls.reduce((s, u) => s + routerUsd(u.pull), 0), 4),
+    usd_diff_ci95: !newest || cell === BASELINE_CELL || !base ? null : bootstrapDiffCI(bootUnits(g), bootUnits(base)),
+    left_out: g.left_out,
+    unpriced: g.unpriced,
+  });
   const figures = [...tallies.values()].map((t) => ({
     ...figuresOf(t.cell, t, true),
     excluded: t.excluded,
@@ -177,7 +133,7 @@ export function computeReport({ members, tiers, features, prs, routerTable = nul
   // The $ leg takes the unrounded means: the cent-rounded figures are for
   // display, and a trip is sticky, so a cell cheaper by under half a cent
   // must not trip on rounding alone. The fail leg reads the claims.
-  const quality = (t) => ({ n: t.claims, n_pass: t.claims - t.failed, mean_usd: meanUsd(t) });
+  const quality = (t) => ({ claims: t.claims, failed: t.failed, mean_usd: meanUsd(t) });
   const tripped = [];
   if (baseline.n >= MIN_N) {
     for (const t of tallies.values()) {

package/scripts/pull-attribution.mjs

@@ -1,7 +1,8 @@
 // The one booking of member rows, merges and claims to Pulls, read by both the
 // cost guard (pr-cost.mjs) and the router's fit (ticket-router.mjs), so the two
 // print the same figures for a cell. Neither CLI imports the other; both import
-// this.
+// this, and with it the two judgements they share: the quality floor (the
+// guard's fail leg) and the bootstrap range of a $ per merged PR difference.
 //
 // THE UNIT is the Pull, a ticket-features.tsv row, booked AS ROUTED to its
 // `chosen_cell`: its merge, its Ruling and all its spend. A ticket Pulled twice
@@ -38,8 +39,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
@@ -59,6 +60,10 @@
 // Generations are told apart by model alone, so a cell that returns to an
 // earlier model rejoins that generation's Pulls. Only the newest generation's
 // figures are judged; older ones are reported beside them, never pooled.
+//
+// THE FLOOR. A cell is under the floor against a baseline when its fail rate
+// is TRIP_POINTS or more points above the baseline's, compared in integer
+// counts. The guard holds it pooled; the fit holds it per row.
 
 import { isDigits } from "./arg.mjs";
 import { CELL } from "./ledger-grammar.mjs";
@@ -73,6 +78,57 @@ export const FEATURE_COLUMNS = Object.freeze([
   "paths", "test_paths", "xrefs", "kind",
 ]);
 
+// The quality floor's margin, in points of fail rate.
+export const TRIP_POINTS = 15;
+
+// The floor, in integer counts so a 3-of-20 difference is exactly 15 points
+// rather than 14.999… in floating point. Each side is `{ claims, failed }`.
+export function underFloor(cell, base) {
+  return (cell.failed * base.claims - base.failed * cell.claims) * 100 >= TRIP_POINTS * cell.claims * base.claims;
+}
+
+const round2 = (x) => (Number.isFinite(x) ? Number(x.toFixed(2)) : null);
+
+// Deterministic, so a re-run reads the same range.
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// The bootstrap 95% range of (cell − base) $ per merged PR, its ends rounded
+// to cents. Each unit is one counted Pull: `{ usd, merged }`, merged 0 or 1.
+// $ per merged PR is Σusd / Σmerged. null when either side has no unit, or
+// when under half the resamples have a merged PR on both sides.
+export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed = 1 } = {}) {
+  if (!cellUnits.length || !baseUnits.length) return null;
+  const rand = mulberry32(seed);
+  const resample = (units) => {
+    let u = 0, m = 0;
+    for (let i = 0; i < units.length; i++) {
+      const x = units[Math.floor(rand() * units.length)];
+      u += x.usd; m += x.merged;
+    }
+    return m ? u / m : null;
+  };
+  const diffs = [];
+  for (let i = 0; i < iterations; i++) {
+    const a = resample(cellUnits), b = resample(baseUnits);
+    if (a !== null && b !== null) diffs.push(a - b);
+  }
+  if (diffs.length < iterations / 2) return null;
+  diffs.sort((x, y) => x - y);
+  return [round2(diffs[Math.floor(0.025 * (diffs.length - 1))]), round2(diffs[Math.ceil(0.975 * (diffs.length - 1))])];
+}
+
+// A counted Pull as a bootstrap unit.
+export const bootUnit = (u) => ({ usd: u.spend, merged: u.merged ? 1 : 0 });
+
 // ticket-features.tsv: one bare header line naming the columns, then rows.
 // Read by header name; a row whose width differs from the header's is refused.
 export function parseFeatures(text) {
@@ -125,7 +181,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/;
@@ -309,10 +365,11 @@ export function generations(units) {
 
 /**
  * Per cell, in cell-name order: `{ cell, generation, n, merged, claims, failed,
- * spend, excluded, left_out, unpriced, pending, older }`. `generation` is the
- * cell's newest (null when no Pull of it has one), and the figures beside it
- * are that generation's alone: `n`, `merged`, `claims`, `failed` and `spend`
- * over its counted Pulls, then its left-out, unpriced and pending Pull counts.
+ * spend, pulls, excluded, left_out, unpriced, pending, older }`. `generation`
+ * is the cell's newest (null when no Pull of it has one), and the figures
+ * beside it are that generation's alone: `n`, `merged`, `claims`, `failed` and
+ * `spend` over its counted Pulls, `pulls` those counted units themselves in
+ * the order of `units`, then its left-out, unpriced and pending Pull counts.
  * `excluded` counts the cell's excluded Pulls, which have no generation.
  * `older` is an array, newest first, of every other generation's figures in
  * the same shape, each carrying its `generation`. `order` is `generations()`
@@ -321,7 +378,10 @@ export function generations(units) {
  * never moves a cell's newest generation.
  */
 export function tally(units, order = generations(units)) {
-  const figures = (generation) => ({ generation, n: 0, merged: 0, claims: 0, failed: 0, spend: 0, left_out: 0, unpriced: 0, pending: 0 });
+  // `n` is read off `pulls`, so the count and the list cannot drift apart.
+  const figures = (generation) => ({
+    generation, get n() { return this.pulls.length; }, merged: 0, claims: 0, failed: 0, spend: 0, pulls: [], left_out: 0, unpriced: 0, pending: 0,
+  });
   const cells = new Map();
   for (const u of units) {
     const c = cells.get(u.cell) ?? cells.set(u.cell, { excluded: 0, gens: new Map() }).get(u.cell);
@@ -332,11 +392,11 @@ export function tally(units, order = generations(units)) {
     const g = u.generation ?? null;
     const f = c.gens.get(g) ?? c.gens.set(g, figures(g)).get(g);
     if (u.status === "counted") {
-      f.n++;
       if (u.merged) f.merged++;
       f.claims += u.claims;
       f.failed += u.falseClaims;
       f.spend += u.spend;
+      f.pulls.push(u);
     } else f[u.status.replace("-", "_")]++;
   }
   return [...cells].sort(([a], [b]) => cmp(a, b)).map(([cell, c]) => {

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/scripts/router-table.json

@@ -17,6 +17,14 @@
     "tau": null
   },
   "estimates": {},
+  "reasons": {
+    "*": {
+      "cell": "slow-high",
+      "reason": "unjudged",
+      "cells": {},
+      "pairs": []
+    }
+  },
   "guard": {
     "tripped": [],
     "n": {}

package/scripts/ticket-router.mjs

@@ -20,8 +20,10 @@
 //       --guard <cost-guard.json> --commit <rev> [--due]
 //     Re-fits the table from the three TSVs as committed at `--commit` (read
 //     with `git show`, never from the working tree) and the guard, and
-//     rewrites `--table`, recording the commit's sha as `fitted_commit`. The
-//     TSV flags name paths inside the repository that holds them. With
+//     rewrites `--table`, recording the commit's sha as `fitted_commit`, then
+//     prints the fit and one line per row: its cell and the reason, then each
+//     candidate's verdict and range. The TSV flags name paths inside the
+//     repository that holds them. With
 //     `--due`, writes nothing and prints `DUE=yes|no MERGED=<n>/<N>`: whether
 //     N merged PRs have landed since `fitted_commit`, counting the features
 //     rows at `--commit` that the fitted commit's features file does not hold.
@@ -47,7 +49,9 @@ import { makeDie, defineFlags } from "./arg.mjs";
 import { CELL, POLICY_CELL, drawCell, parseMember } from "./ledger-grammar.mjs";
 import { sessionFromReceipt } from "./phase0-receipt.mjs";
 import { parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
-import { AttributionError, FEATURE_COLUMNS, attribute, generations, parseFeatures, tally } from "./pull-attribution.mjs";
+import {
+  AttributionError, FEATURE_COLUMNS, TRIP_POINTS, attribute, bootUnit, bootstrapDiffCI, generations, parseFeatures, tally, underFloor,
+} from "./pull-attribution.mjs";
 import { RulingError, parseTierOutcomes } from "./tier-outcomes.mjs";
 
 const NAME = "ticket-router";
@@ -61,7 +65,7 @@ const HEAVY_BRIEF_CHARS = 3483;
 const HEAVY_CRITERIA = 5;
 // Exploration cadence after burn-in: the Pull that creates `impl-` row 5k.
 const EXPLORE_EVERY = 5;
-// The fit's adoption floor (n per side), margin, and cadence.
+// The fit's adoption floor (merged PRs per side), margin, and cadence.
 const MIN_N = 20;
 const ADOPT_RATIO = 0.75;
 export const FIT_EVERY_MERGED = 50;
@@ -346,15 +350,19 @@ function fitPulls({ features, members, verdicts, window }) {
 // Pulls, `merged`, $ per merged PR, false claims over claims, fix rounds per
 // merged PR, and its left-out and unpriced Pull counts. Beside them the cell's
 // excluded Pull count, `generation` naming the newest generation's model, and
-// `older`, each older generation's model to its figures, newest first.
+// `older`, each older generation's model to its figures, newest first. Beside
+// `estimates`, `pulls`: per stratum and `*`, per cell, the newest generation's
+// counted Pulls those figures are over.
 function estimate(units, order) {
-  const out = {};
+  const estimates = {};
+  const pulls = {};
   for (const s of units.length ? [...new Set([...units.map((u) => u.stratum), "*"])].sort() : []) {
     const mine = s === "*" ? units : units.filter((u) => u.stratum === s);
-    out[s] = {};
+    estimates[s] = {};
+    pulls[s] = {};
     for (const t of tally(mine, order)) {
       const figures = (g) => {
-        const fix = mine.filter((u) => u.cell === t.cell && u.generation === g.generation && u.status === "counted" && u.merged)
+        const fix = g.pulls.filter((u) => u.merged)
           .reduce((n, u) => n + u.rows.filter((r) => parseMember(r.member)?.family === "fix-pr").length, 0);
         return {
           n: g.n,
@@ -369,52 +377,123 @@ function estimate(units, order) {
           unpriced: g.unpriced,
         };
       };
-      out[s][t.cell] = {
+      estimates[s][t.cell] = {
         generation: t.generation,
         ...figures(t),
         excluded: t.excluded,
         older: Object.fromEntries(t.older.map((o) => [o.generation, figures(o)])),
       };
+      pulls[s][t.cell] = t.pulls;
     }
   }
-  return out;
+  return { estimates, pulls };
 }
 
-// Among cells with n >= MIN_N in a stratum and not tripped, the one with the
-// lowest $ per merged PR — adopted only at or under ADOPT_RATIO of the
-// default cell's. Every figure read is the cell's newest generation's, the
-// default cell's included. The quality floor is the guard's to enforce, never
-// the fit's. null when the stratum cannot decide (no default cell at n, or no
-// candidate at n).
-function adopt(est, cells, tripped) {
-  const base = est?.[POLICY_CELL];
-  if (!base || base.n < MIN_N || base.usd_per_merged === null) return null;
-  const candidates = cells
-    .filter((c) => c !== POLICY_CELL && !tripped.has(c))
-    .map((c) => ({ c, e: est[c] }))
-    .filter(({ e }) => e && e.n >= MIN_N && e.usd_per_merged !== null)
-    .sort((a, b) => a.e.usd_per_merged - b.e.usd_per_merged || (a.c < b.c ? -1 : 1));
-  if (candidates.length === 0) return null;
-  return candidates[0].e.usd_per_merged <= ADOPT_RATIO * base.usd_per_merged ? candidates[0].c : POLICY_CELL;
+/**
+ * One row's cell — the `*` row's or a stratum's — and why. The quality floor
+ * is held twice: pooled by the guard, whose trip takes a cell out of every row
+ * and out of the exploration draw, and per row by the fit, which refuses a
+ * cell under the floor that row alone. Every figure read is the cell's newest
+ * generation's, the default cell's included. `est` and `pulls` are the row's
+ * `estimate()` figures and counted Pulls.
+ *
+ * A candidate is a cell of `cells` other than the default cell. Its `verdict`,
+ * the first that applies: `tripped` by the guard; `too-few`, under MIN_N
+ * merged PRs in the row; `under-floor` against the default cell there;
+ * `too-dear`, above ADOPT_RATIO of the default cell's $ per merged PR;
+ * `not-reliably-cheaper`, its `range` does not lie wholly below zero (its
+ * upper end, as `bootstrapDiffCI` returns it, is not below zero) or there is
+ * none; else it `qualifies`. A candidate past `too-few` records whether it is
+ * `under_floor`, the floor's `bar` (the default cell's fail rate plus
+ * TRIP_POINTS, rounded as a fail rate is, for reading only: the floor compares
+ * counts) and its `range`, the bootstrap 95% range of (candidate − default
+ * cell) $ per merged PR over those Pulls; the others record null for each.
+ *
+ * Several qualifiers: each pair records the range of (the cheaper by $ per
+ * merged PR, else by name − the other) in `pairs`, and a qualifier another
+ * is reliably cheaper than is dropped. Among the rest the lower fail rate,
+ * compared in counts, wins, then the lower $ per merged PR, then the name.
+ *
+ * `reason`, why the row holds `cell`: `unjudged` (the default cell, or every
+ * untripped candidate, is under MIN_N merged PRs; `cell` is null and a
+ * stratum follows `*`), `no-qualifier` (the default cell), or, for the
+ * winner, `sole-qualifier`, `reliably-cheaper` (every other qualifier was
+ * dropped), or what put it ahead of the next of the rest: `lower-fail-rate`,
+ * `lower-usd` or `name`.
+ */
+function judgeRow(est = {}, pulls, cells, tripped) {
+  const record = { cell: null, reason: "unjudged", cells: {}, pairs: [] };
+  const base = est[POLICY_CELL];
+  if (!base || base.merged < MIN_N) return record;
+  // JSON writes −0 as 0, so a recorded end is 0 either way; `--check` compares the two.
+  const range = (a, b) => bootstrapDiffCI(pulls[a].map(bootUnit), pulls[b].map(bootUnit))?.map((x) => x + 0) ?? null;
+  const reliablyBelow = (r) => r !== null && r[1] < 0;
+  const bar = round4(base.failed / base.claims + TRIP_POINTS / 100);
+  const qualifiers = [];
+  let judged = false;
+  for (const c of cells) {
+    if (c === POLICY_CELL) continue;
+    const e = est[c];
+    if (tripped.has(c) || !e || e.merged < MIN_N) {
+      record.cells[c] = { verdict: tripped.has(c) ? "tripped" : "too-few", under_floor: null, bar: null, range: null };
+      continue;
+    }
+    judged = true;
+    const under = underFloor(e, base);
+    const r = range(c, POLICY_CELL);
+    const verdict = under ? "under-floor"
+      : e.usd_per_merged > ADOPT_RATIO * base.usd_per_merged ? "too-dear"
+        : reliablyBelow(r) ? "qualifies" : "not-reliably-cheaper";
+    record.cells[c] = { verdict, under_floor: under, bar, range: r };
+    if (verdict === "qualifies") qualifiers.push(c);
+  }
+  if (!judged) return record;
+  if (qualifiers.length === 0) return { ...record, cell: POLICY_CELL, reason: "no-qualifier" };
+
+  const usd = (c) => est[c].usd_per_merged;
+  const byName = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+  const failCmp = (a, b) => est[a].failed * est[b].claims - est[b].failed * est[a].claims;
+  const named = [...qualifiers].sort(byName);
+  const dropped = new Set();
+  for (let i = 0; i < named.length; i++) {
+    for (let j = i + 1; j < named.length; j++) {
+      const [cheaper, other] = usd(named[j]) < usd(named[i]) ? [named[j], named[i]] : [named[i], named[j]];
+      const r = range(cheaper, other);
+      record.pairs.push({ cheaper, other, range: r });
+      if (reliablyBelow(r)) dropped.add(other);
+    }
+  }
+  // The cheapest qualifier, by $ then name, is never dropped, so the rest is never empty.
+  const [win, next] = named.filter((c) => !dropped.has(c)).sort((a, b) => failCmp(a, b) || usd(a) - usd(b) || byName(a, b));
+  const reason = qualifiers.length === 1 ? "sole-qualifier"
+    : next === undefined ? "reliably-cheaper"
+      : failCmp(win, next) !== 0 ? "lower-fail-rate"
+        : usd(win) !== usd(next) ? "lower-usd" : "name";
+  return { ...record, cell: win, reason };
 }
 
 /**
  * The re-fit table. `guard` is `{ tripped, n, window_start }` (readGuard's
  * shape); `commit` is the sha of the commit the inputs were read from, or null
- * for the empty corpus before any fit.
+ * for the empty corpus before any fit. `reasons` holds `judgeRow()`'s record
+ * for `*` and for each stratum with Pulls; a stratum whose record has no cell
+ * gets no row and follows `*`, and an unjudged `*` is the default cell.
  */
 export function fitTable({ prior, features, members, verdicts, guard, commit = null }) {
   const window = guard.window_start ?? prior.window_start ?? null;
   const { units, order } = fitPulls({ features, members, verdicts, window });
-  const estimates = estimate(units, order);
+  const { estimates, pulls } = estimate(units, order);
   const tripped = new Set(guard.tripped);
 
   let { stage, cells } = prior;
   cells = [...cells];
-  const rows = { "*": adopt(estimates["*"], cells, tripped) ?? POLICY_CELL };
+  const star = judgeRow(estimates["*"], pulls["*"], cells, tripped);
+  const rows = { "*": star.cell ?? POLICY_CELL };
+  const reasons = { "*": { ...star, cell: rows["*"] } };
   for (const s of STRATA) {
-    const a = adopt(estimates[s], cells, tripped);
-    if (a !== null) rows[s] = a;
+    if (!estimates[s]) continue;
+    reasons[s] = judgeRow(estimates[s], pulls[s], cells, tripped);
+    if (reasons[s].cell !== null) rows[s] = reasons[s].cell;
   }
   const atN = (c) => (guard.n[c] ?? 0) >= MIN_N;
   if (stage === 1 && cells.every(atN) && (rows["*"] !== POLICY_CELL || cells.some((c) => tripped.has(c)))) {
@@ -433,6 +512,7 @@ export function fitTable({ prior, features, members, verdicts, guard, commit = n
     rows,
     classifier: prior.classifier,
     estimates,
+    reasons,
     guard: { tripped: [...tripped].sort(), n: Object.fromEntries(Object.keys(guard.n).sort().map((c) => [c, guard.n[c]])) },
   };
 }
@@ -462,6 +542,16 @@ function cellCounts(estimates) {
     .join(", ") || "none";
 }
 
+// One line per row the fit judged or skipped: its cell (`-` for a stratum
+// that follows `*`) and its reason, then each candidate's verdict and range.
+function rowLines(reasons) {
+  const range = (r) => (r === null ? "" : ` [${r.map((x) => x.toFixed(2)).join(", ")}]`);
+  return Object.entries(reasons).map(([s, r]) => {
+    const cells = Object.entries(r.cells).map(([c, x]) => `${c} ${x.verdict}${range(x.range)}`).join(", ");
+    return `${NAME}: row ${s} ${r.cell ?? "-"} ${r.reason}${cells ? ` (${cells})` : ""}\n`;
+  }).join("");
+}
+
 // ---------------------------------------------------------------------------
 // the commit a fit reads
 // ---------------------------------------------------------------------------
@@ -638,7 +728,7 @@ function main() {
   const next = joined(() => fitTable({ prior: table, features, members, verdicts, guard, commit: sha }));
   writeFileSync(`${tablePath}.tmp`, `${JSON.stringify(next, null, 2)}\n`);
   renameSync(`${tablePath}.tmp`, tablePath);
-  process.stdout.write(`${NAME}: fitted ${next.n_rows} Pulls at ${short(sha)}; rows ${JSON.stringify(next.rows)}; burn_in ${next.burn_in}; stage ${next.stage}; cells ${cellCounts(next.estimates)}\n`);
+  process.stdout.write(`${NAME}: fitted ${next.n_rows} Pulls at ${short(sha)}; rows ${JSON.stringify(next.rows)}; burn_in ${next.burn_in}; stage ${next.stage}; cells ${cellCounts(next.estimates)}\n${rowLines(next.reasons)}`);
 }
 
 if (isCLI(import.meta.url)) main();

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 .`,