@feigi/fleet-ctl 3.93.6 → 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.93.6",
+  "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/cell-readout.mjs

@@ -14,7 +14,7 @@
 // ADMISSIBLE ROW. A Pull counts only when its member row exists, was
 // dispatched as the drawn cell's own definition (`subagent_type` =
 // `fleet-implementer-<chosen_cell>`), ran at the cell's level (`effort` = the
-// cell's `<level>`) and has a resolved `model` on record. So a generic `task`
+// cell's `<level>`) and has its `dispatch_model` on record. So a generic `task`
 // dispatch, a clamped effort and every pre-cutover `fleet-implementer` /
 // `fleet-implementer-alt` row are never admissible. Whether the resolved model
 // was the role's target at dispatch is recorded in neither file; that half of
@@ -22,7 +22,7 @@
 //
 // COMPARISON. For a cell X other than slow-high, a comparison is one session
 // holding at least one admissible X row and at least one admissible slow-high
-// row whose resolved (`model`, `effort`) differ from that X row's. A session
+// row whose (`dispatch_model`, `effort`) differ from that X row's. A session
 // counts once however many rows it holds, and its date is its member-outcomes
 // `run_date`; a blank `run_date` means unknown, so that session is still a
 // comparison but adds no date to the distinct-date count.
@@ -33,12 +33,13 @@
 //
 //   <cell> <comparisons> <run_dates> <resolved models>
 //
-// `<resolved models>` is the model of every admissible row at the cell — one
-// model by name, or `mixed (<model-a> n=…, <model-b> n=…)` when they span more
-// than one, because a role's target is operator config that can move under a
-// cell's history. A cell below the gate prints nothing on stdout and one
-// `below the gate` count on stderr. Neither the gate line nor that count names
-// a session, ticket or member: the gate forbids reading a comparison early.
+// `<resolved models>` is the `dispatch_model` of every admissible row at the
+// cell — one model by name, or `mixed (<model-a> n=…, <model-b> n=…)` when
+// they span more than one, because a role's target is operator config that
+// can move under a cell's history. A cell below the gate prints nothing on
+// stdout and one `below the gate` count on stderr. Neither the gate line nor
+// that count names a session, ticket or member: the gate forbids reading a
+// comparison early.
 // Only the refusal of conflicting ticket-features rows names a session and an
 // agent, and it prints nothing on stdout.
 //
@@ -49,7 +50,11 @@
 // the ticket's last Pull in file order, at any cell, slow-high included,
 // dated on or before the ruling. Dates only set that floor: a ruling counts
 // for a Pull only when dated on or after it, and neither pick is the
-// latest-dated row. A Pull at X is
+// latest-dated row. A Pull's GENERATION is pull-attribution.mjs's
+// (`pullGenerations`): the `dispatch_model` of its first Admissible
+// implementer row in dispatch order, over every implementer row booked to
+// the Pull, its retries included, so the guard and this rule never name two
+// generations for one Pull. A Pull is admissible here when it has one. A Pull at X is
 // COUNTABLE when X is a cell other than slow-high whose definition is live
 // and the Pull is admissible and dated on or after the day X's
 // `fleet-implementer-<cell>` definition was most recently added. The ruling
@@ -67,8 +72,12 @@
 // could move the verdict to another cell or uncount it. So is an admissible
 // Pull at X whose `run_date` is not `YYYY-MM-DD`: it cannot be placed against
 // the day X's definition was added, and dropping it would uncount its ruling.
-// X is to be withdrawn once it has at least STOP.verdicts verdicts and
-// floor failures ÷ verdicts is at least STOP.failRate.
+// X is to be withdrawn once its newest generation has at least STOP.verdicts
+// verdicts and floor failures ÷ verdicts is at least STOP.failRate. A ruling
+// counts for its carrier's generation; a cell's newest generation is that of
+// its latest admissible Pull, by session id, then file order. An older
+// generation's verdicts are returned beside the newest's and never withdraw
+// the cell.
 //
 // Exit 0 whatever the counts; 2 on a usage error or an unreadable or
 // malformed input, with nothing on stdout.
@@ -78,7 +87,7 @@ import { makeDie, defineFlags } from "./arg.mjs";
 import { isCLI } from "./is-cli.mjs";
 import { POLICY_CELL } from "./ledger-grammar.mjs";
 import { formatTsv as formatMemberTsv, parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
-import { admissibleRow, parseFeatures } from "./pull-attribution.mjs";
+import { admissibleRow, generations, parseFeatures, pullGenerations } from "./pull-attribution.mjs";
 import { DATE, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
 
 const NAME = "cell-readout";
@@ -128,7 +137,7 @@ function indexMembers(members) {
  * `cells`: one entry per cell other than the policy cell that has a
  * ticket-features row, `{ cell, comparisons, runDates, dates, models, gated }`,
  * sorted by cell. `dates` is the comparisons' distinct run_dates, sorted;
- * `models` maps each resolved model of the cell's admissible rows to its row
+ * `models` maps each `dispatch_model` of the cell's admissible rows to its row
  * count, largest first. `unjoined` counts Pulls with no member row. Throws on
  * two ticket-features rows of one session+agent naming different cells, and on
  * a member-outcomes session+agent repeated with different fields.
@@ -144,9 +153,9 @@ export function readout({ features, members }) {
     if (!byKey.has(key(p.session, p.agent))) unjoined++;
     const m = admissibleMember(p, byKey);
     if (!m) continue;
-    if (p.chosen_cell !== POLICY_CELL) cells.get(p.chosen_cell).set(m.model, (cells.get(p.chosen_cell).get(m.model) ?? 0) + 1);
+    if (p.chosen_cell !== POLICY_CELL) cells.get(p.chosen_cell).set(m.dispatchModel, (cells.get(p.chosen_cell).get(m.dispatchModel) ?? 0) + 1);
     if (!sessions.has(p.session)) sessions.set(p.session, { runDate: m.run_date, rows: [] });
-    sessions.get(p.session).rows.push({ cell: p.chosen_cell, model: m.model, effort: m.effort });
+    sessions.get(p.session).rows.push({ cell: p.chosen_cell, model: m.dispatchModel, effort: m.effort });
   }
 
   const out = [...cells].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([cell, modelCounts]) => {
@@ -169,15 +178,22 @@ export function readout({ features, members }) {
 /**
  * One entry per cell named in `added` (cell → the `YYYY-MM-DD` its definition
  * was most recently added) other than the policy cell, sorted by cell:
- * `{ cell, since, verdicts, failures, stop }`. `verdicts` is
+ * `{ cell, since, generation, verdicts, failures, stop, older }`. `verdicts` is
  * `[{ ticket, pr, run_date, closed_own_ticket, minted_false_claim, failed }]`
  * sorted by ticket, `run_date` the ruling's; `stop` is whether the stopping
  * rule withdraws the cell. `verdicts` are parsed tier-outcomes.tsv rows.
  * A ticket's ruling is its last ruling row in file order, charged to the cell
  * of its carrier, the ticket's last Pull in file order at any cell dated on or
  * before the ruling, and only when that Pull is
- * countable: admissible, at a cell named in `added` other than the policy
+ * countable: admissible (it has a generation, pull-attribution.mjs's
+ * `pullGenerations`), at a cell named in `added` other than the policy
  * cell, and dated on or after the day that cell's definition was added.
+ * A ruling is charged to its carrier's generation too, and `generation`,
+ * `verdicts`, `failures` and `stop` are the cell's newest generation's alone
+ * (pull-attribution.mjs's `generations`, over the cell's admissible Pulls;
+ * null when it has none). `older` holds `{ generation, verdicts, failures }`
+ * for each other generation with at least one verdict, newest first, and
+ * never a stop.
  * Throws on a non-blank ruling row of a ticket with a countable Pull whose
  * `closed_own_ticket` or `minted_false_claim` is not `yes` or `no` or whose
  * `run_date` is not `YYYY-MM-DD`,
@@ -187,19 +203,25 @@ export function readout({ features, members }) {
  * repeated with different fields.
  */
 export function stoppingRule({ features, members, verdicts, added }) {
-  const byKey = indexMembers(members);
+  indexMembers(members); // refuses a session+agent repeated with different fields
   const rulings = rulingsByTicket(verdicts);
-  const charged = new Map(Object.keys(added).filter((c) => c !== POLICY_CELL).map((c) => [c, []]));
+  const charged = new Map(Object.keys(added).filter((c) => c !== POLICY_CELL).map((c) => [c, new Map()]));
   const dated = (p) => {
     if (!DATE.test(p.run_date)) throw new Error(`ticket #${p.ticket} (Pull ${p.agent} at ${p.chosen_cell}): run_date is '${p.run_date}', expected YYYY-MM-DD`);
     return p.run_date;
   };
-  const countable = new Set();
+  // A Pull's generation is pull-attribution's, read over all of its implementer
+  // rows; a Pull with none is not admitted.
+  const generationOf = pullGenerations(features, members);
+  const countable = new Map(); // Pull -> its generation
+  const admitted = []; // every Pull with a generation at a judged cell, as generations() reads one
   const pullsByTicket = new Map();
   for (const p of features) {
     (pullsByTicket.get(p.ticket) ?? pullsByTicket.set(p.ticket, []).get(p.ticket)).push(p);
-    if (!charged.has(p.chosen_cell) || !admissibleMember(p, byKey)) continue;
-    if (dated(p) >= added[p.chosen_cell]) countable.add(p);
+    const g = charged.has(p.chosen_cell) ? generationOf.get(p) : null;
+    if (!g) continue;
+    admitted.push({ cell: p.chosen_cell, generation: g, pull: p });
+    if (dated(p) >= added[p.chosen_cell]) countable.set(p, g);
   }
   for (const [ticket, pulls] of pullsByTicket) {
     if (!pulls.some((p) => countable.has(p))) continue;
@@ -210,17 +232,25 @@ export function stoppingRule({ features, members, verdicts, added }) {
     let carrier = null;
     for (const p of pulls) if (dated(p) <= v.run_date) carrier = p;
     if (!carrier || !countable.has(carrier)) continue;
-    charged.get(carrier.chosen_cell).push({
+    const byGeneration = charged.get(carrier.chosen_cell);
+    const g = countable.get(carrier);
+    (byGeneration.get(g) ?? byGeneration.set(g, []).get(g)).push({
       ticket: carrier.ticket, pr: v.pr, run_date: v.run_date,
       closed_own_ticket: v.closed_own_ticket, minted_false_claim: v.minted_false_claim,
       failed: v.minted_false_claim === "yes" || v.closed_own_ticket === "no",
     });
   }
-  return [...charged].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([cell, list]) => {
+  const order = generations(admitted);
+  const tallied = (list = []) => {
     list.sort((a, b) => Number(a.ticket) - Number(b.ticket));
-    const failures = list.filter((v) => v.failed).length;
+    return { verdicts: list, failures: list.filter((v) => v.failed).length };
+  };
+  return [...charged].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([cell, byGeneration]) => {
+    const [generation = null, ...rest] = order.get(cell) ?? [];
+    const { verdicts: list, failures } = tallied(byGeneration.get(generation));
     const stop = list.length >= STOP.verdicts && failures / list.length >= STOP.failRate;
-    return { cell, since: added[cell], verdicts: list, failures, stop };
+    const older = rest.filter((g) => byGeneration.has(g)).map((g) => ({ generation: g, ...tallied(byGeneration.get(g)) }));
+    return { cell, since: added[cell], generation, verdicts: list, failures, stop, older };
   });
 }
 

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

@@ -13,6 +13,7 @@ import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, basename } from "node:path";
 
 import { readOmpSession, normalizeModel, parseMemberName, isOmpSessionDirName } from "./member-record.mjs";
+import { stripLevel } from "./tier-roles.mjs";
 import { reportFamily, reportStatus, defaultScratch } from "./report-files.mjs";
 import { FleetDirUnresolvable } from "./fleet-dir.mjs";
 import { spawnSync } from "node:child_process";
@@ -91,9 +92,20 @@ export function rowsForSession(sessionDir, stats = {}, { verifyMain = verifyMain
     tokensIn: r.tokens_in, tokensCacheRead: r.tokens_cache_read,
     tokensCacheWrite1h: r.tokens_cache_write_1h ?? "", cost: r.cost == null ? "" : Number(r.cost.toFixed(6)),
     ending: endings[i],
+    dispatchModel: dispatchModel(r.resolvedModelIdentity),
   }));
 }
 
+// The `dispatch_model` column: the model fixed at dispatch, `session_init`'s
+// own model (the record's `resolvedModelIdentity`), with its provider prefix
+// and `:<level>` suffix stripped. `model` is the member's last turn, which a
+// provider fallback moves; this one does not move. Blank when the transcript
+// carries no `session_init` model: blank means unknown. Operator config is
+// never read for it.
+export function dispatchModel(identity) {
+  return stripLevel(String(identity ?? "").trim()).split("/").at(-1);
+}
+
 // A column is APPENDED, never inserted, as a rule: a read-out that indexes by
 // position (`$5`, in the file's header) silently repoints when one is added
 // ahead of it. `report` is placed after `subagent_type` regardless, which
@@ -108,7 +120,7 @@ export const COLUMNS = [
   "session", "run_date", "role", "member", "model", "effort", "ticket", "pr",
   "tokens_cache_create", "tokens_out", "wall_s", "turns", "agent", "harness",
   "subagent_type", "report", "tokens_in", "tokens_cache_read", "tokens_cache_write_1h", "cost",
-  "ending",
+  "ending", "dispatch_model",
 ];
 
 // `report`: what reportStatus() says of the row's member under `scratch` — a
@@ -134,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;
@@ -150,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";
@@ -221,7 +235,7 @@ function verifyMainWithGit(sha) {
 const FIELD = {
   tokens_cache_create: "tokensCacheCreate", tokens_out: "tokensOut", wall_s: "wallS",
   subagent_type: "subagentType", tokens_in: "tokensIn", tokens_cache_read: "tokensCacheRead",
-  tokens_cache_write_1h: "tokensCacheWrite1h",
+  tokens_cache_write_1h: "tokensCacheWrite1h", dispatch_model: "dispatchModel",
 };
 const field = (c) => FIELD[c] ?? c;
 // Keyed on the transcript's path-relative stem, not the member name: `member`

package/scripts/pr-cost.mjs

@@ -39,16 +39,22 @@
 // of a windowed Pull's ticket whose run_date is not YYYY-MM-DD or whose verdict
 // is not yes or no.
 //
-// PER CELL, over its counted Pulls: `n_pulls`; `n_merged`; `n_claims` (merged
-// PRs plus every `bail:fixed` or `bail:fixed-refuted` ending); `n_failed`
-// (merged PRs ruled `minted_false_claim=yes` or `closed_own_ticket=no`, plus
-// every `bail:fixed-refuted`); `fail_rate` = failed / claims; `mean_usd` = the
-// Pulls' spend — merged or not — / merged, so a cell that abandons work carries
-// that spend; `median_usd` over the merged Pulls alone, descriptive;
-// `router_usd`, the Pulls' own routing cost, summed and never in their spend.
-// `usd_diff_ci95` is a bootstrap 95% interval on `mean_usd` minus the
-// baseline's — printed to be read, never judged on. Then the cell's
-// `excluded`, `left_out` and `unpriced` Pull counts.
+// PER CELL GENERATION (pull-attribution.mjs's GENERATION), over its counted
+// Pulls: `generation`, the dispatch model; `n_pulls`; `n_merged`; `n_claims`
+// (merged PRs plus every `bail:fixed` or `bail:fixed-refuted` ending);
+// `n_failed` (merged PRs ruled `minted_false_claim=yes` or
+// `closed_own_ticket=no`, plus every `bail:fixed-refuted`); `fail_rate` =
+// failed / claims; `mean_usd` = the Pulls' spend — merged or not — / merged,
+// so a cell that abandons work carries that spend; `median_usd` over the
+// merged Pulls alone, descriptive; `router_usd`, the Pulls' own routing cost,
+// summed and never in their spend. `usd_diff_ci95` is a bootstrap 95% interval
+// on `mean_usd` minus the baseline's — printed to be read, never judged on.
+// Then the `left_out` and `unpriced` Pull counts, and the cell's `excluded`
+// count, which no generation owns. The baseline, the guard file's cells and
+// every trip are each cell's newest generation alone, so a cell whose model
+// changed is judged afresh once its new generation reaches MIN_N merged PRs.
+// Each older generation prints on its own line beside the newest, with no
+// verdict and no interval.
 
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -135,29 +141,39 @@ export function computeReport({ members, tiers, features, prs, routerTable = nul
   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) => counted.filter((u) => u.cell === cell);
-  const bootUnits = (cell) => countedIn(cell).map((u) => ({ usd: u.spend, merged: u.merged ? 1 : 0 }));
+  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 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 figures = [...tallies.values()].map((t) => ({
-    cell: t.cell,
-    n_pulls: t.n,
-    n_merged: t.merged,
-    n_claims: t.claims,
-    n_failed: t.failed,
-    fail_rate: t.claims ? round(t.failed / t.claims) : null,
-    mean_usd: round(meanUsd(t), 2),
-    median_usd: round(median(countedIn(t.cell).filter((u) => u.merged).map((u) => u.spend)), 2),
-    router_usd: round(countedIn(t.cell).reduce((s, u) => s + routerUsd(u.pull), 0), 4),
-    usd_diff_ci95: t.cell === BASELINE_CELL || !base ? null : bootstrapDiffCI(bootUnits(t.cell), bootUnits(BASELINE_CELL)),
+    ...figuresOf(t.cell, t, true),
     excluded: t.excluded,
-    left_out: t.left_out,
-    unpriced: t.unpriced,
+    older: t.older.map((o) => figuresOf(t.cell, o, false)),
   }));
 
-  // The guard.
-  const b = figures.find((f) => f.cell === BASELINE_CELL) ?? { n_merged: 0, mean_usd: null, fail_rate: null };
-  const baseline = { cell: BASELINE_CELL, n: b.n_merged, mean_usd: b.mean_usd, fail_rate: b.fail_rate };
+  // The guard, over each cell's newest generation alone.
+  const b = figures.find((f) => f.cell === BASELINE_CELL) ?? { generation: null, n_merged: 0, mean_usd: null, fail_rate: null };
+  const baseline = { cell: BASELINE_CELL, generation: b.generation, n: b.n_merged, mean_usd: b.mean_usd, fail_rate: b.fail_rate };
   // 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.
@@ -239,10 +255,12 @@ export function crossCheck(rows, pricing) {
 }
 
 const TSV_COLUMNS = [
-  "cell", "n_pulls", "n_merged", "n_claims", "n_failed", "fail_rate", "mean_usd", "median_usd", "router_usd", "usd_diff_ci95",
+  "cell", "generation", "n_pulls", "n_merged", "n_claims", "n_failed", "fail_rate", "mean_usd", "median_usd", "router_usd", "usd_diff_ci95",
   "excluded", "left_out", "unpriced", "guard",
 ];
 
+// One line per cell's newest generation, carrying the guard's verdict on it,
+// then one per older generation of that cell, which carries none.
 export function formatReport(report) {
   const guardOf = (f) => {
     if (f.cell === BASELINE_CELL) return "baseline";
@@ -250,8 +268,12 @@ export function formatReport(report) {
     return f.n_merged >= MIN_N && report.verdict !== "none" ? "ok" : `n<${MIN_N}`;
   };
   const cell = (v) => (v === null || v === undefined ? "" : Array.isArray(v) ? `[${v.join(", ")}]` : String(v));
+  const line = (f, guard) => TSV_COLUMNS.map((c) => (c === "guard" ? guard : cell(f[c]))).join("\t");
   const lines = [TSV_COLUMNS.join("\t")];
-  for (const f of report.cells) lines.push(TSV_COLUMNS.map((c) => (c === "guard" ? guardOf(f) : cell(f[c]))).join("\t"));
+  for (const f of report.cells) {
+    lines.push(line(f, guardOf(f)));
+    for (const o of f.older) lines.push(line(o, "older"));
+  }
   const b = report.baseline;
   lines.push(`# verdict: ${report.verdict} (baseline ${b.cell} n=${b.n}/${MIN_N}${report.tripped.length ? `; tripped ${report.tripped.join(" ")}` : ""})${report.retire ? " — retire: every non-default stage-1 cell tripped" : ""}`);
   lines.push(`# window_start ${report.window_start}; pending PRs: ${report.pending.length ? report.pending.join(" ") : "none"}`);
@@ -269,7 +291,7 @@ export function guardFile(report, computedAt) {
     computed_at: computedAt,
     window_start: report.window_start,
     baseline: report.baseline,
-    cells: report.cells.map((f) => ({ cell: f.cell, n: f.n_merged, mean_usd: f.mean_usd, fail_rate: f.fail_rate })),
+    cells: report.cells.map((f) => ({ cell: f.cell, generation: f.generation, n: f.n_merged, mean_usd: f.mean_usd, fail_rate: f.fail_rate })),
     tripped: report.tripped,
     verdict: report.verdict,
     retire: report.retire,

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
@@ -48,6 +48,17 @@
 //
 // SPEND is the recorded `cost` of every row booked to the Pull. A `cost` that
 // is neither blank nor a number is refused, naming the row.
+//
+// GENERATION. A cell's figures are per Cell generation: the cell on one
+// dispatch model, member-outcomes' `dispatch_model`. A Pull's generation is
+// the dispatch model of its first Admissible implementer row in dispatch
+// order: the session, then `impl-<N>` before its retries `-b`, `-c`, ….
+// A row at another cell (a rescue) is booked to the Pull and never changes
+// its generation; an excluded Pull has none. A cell's NEWEST generation is
+// that of its latest Pull that has one, by session id, then file order.
+// 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.
 
 import { isDigits } from "./arg.mjs";
 import { CELL } from "./ledger-grammar.mjs";
@@ -87,10 +98,11 @@ export const EXCLUDED_MEMBER = /^(?:merge-?bot|memory$|__advisor$)/i;
 export const lastSegment = (agent) => String(agent).split(/[/.]/).at(-1);
 
 // An Admissible row for `cell`: dispatched as the cell's own definition, run at
-// the cell's level, with a resolved model on record.
+// the cell's level, with its dispatch model on record. The last turn's `model`
+// is not read: a member that fell back to another provider is still admitted.
 export function admissibleRow(row, cell) {
   const level = CELL.exec(cell)?.[2] ?? null;
-  return level !== null && row.subagentType === `fleet-implementer-${cell}` && row.effort === level && !!row.model;
+  return level !== null && row.subagentType === `fleet-implementer-${cell}` && row.effort === level && !!row.dispatchModel;
 }
 
 // A bad input row, as opposed to a bug: a caller that reports bad input catches this class alone.
@@ -113,11 +125,66 @@ 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/;
 const startedBefore = (pull, row) => (STARTED.test(pull.session) && STARTED.test(row.session) ? pull.session < row.session : pull.run_date <= row.run_date);
+// An implementer leaf's retry suffix: "" for `impl-<N>`, "b" for `impl-<N>-b`.
+const retryOf = (row) => /^impl-\d+(?:-([a-z0-9]+))?$/.exec(String(row.member).split("/").pop())?.[1] ?? "";
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+// Implementer rows in dispatch order: by session, then the bare name before
+// its retries, a shorter suffix before a longer one (`-z` before `-aa`).
+const dispatchOrder = (rows) => [...rows].sort((a, b) => {
+  const [x, y] = [retryOf(a), retryOf(b)];
+  return cmp(a.session, b.session) || x.length - y.length || cmp(x, y);
+});
+const key = (session, agent) => `${session}\0${agent}`;
+// The omp rows a Pull can book: every member but the merge bot, memory and the advisor.
+const ompRows = (members) => members.filter((r) => r.harness === "omp" && !EXCLUDED_MEMBER.test(lastSegment(r.member)));
+
+/**
+ * Each implementer row of `omp` to its Pull among `pulls`: the same session's
+ * Pull of the row's ticket and agent, else that session's last Pull of the
+ * ticket, else the ticket's last Pull started before the row (a retry in a
+ * later session). `impls` maps every Pull to its rows, `implPull` each booked
+ * row's session+agent to its Pull. A row with no ticket, or no such Pull, is
+ * booked to none.
+ */
+function bookImplementers(pulls, omp) {
+  const bySessionTicket = new Map(), byTicket = new Map();
+  for (const p of pulls) {
+    const k = key(p.session, p.ticket);
+    (bySessionTicket.get(k) ?? bySessionTicket.set(k, []).get(k)).push(p);
+    (byTicket.get(p.ticket) ?? byTicket.set(p.ticket, []).get(p.ticket)).push(p);
+  }
+  const implPull = new Map();
+  const impls = new Map(pulls.map((p) => [p, []]));
+  for (const r of omp) {
+    if (!isImplementer(r.member) || !r.ticket) continue;
+    const own = bySessionTicket.get(key(r.session, r.ticket));
+    const pull = own ? (own.find((p) => p.agent === r.agent) ?? own.at(-1)) : byTicket.get(r.ticket)?.findLast((p) => startedBefore(p, r));
+    if (!pull) continue;
+    implPull.set(key(r.session, r.agent), pull);
+    impls.get(pull).push(r);
+  }
+  return { impls, implPull };
+}
+
+// A Pull's generation from its implementer rows: its first Admissible row's dispatch model, else null.
+const generationOf = (own, cell) => dispatchOrder(own).find((m) => admissibleRow(m, cell))?.dispatchModel ?? null;
+
+/**
+ * Each of `pulls` (ticket-features rows) to its generation, `attribute`'s
+ * rule over `members`: the dispatch model of the Pull's first Admissible
+ * implementer row in dispatch order, or null when it has none. Every caller
+ * that names a Pull's generation reads it here, so the guard, the fit and the
+ * stopping rule never derive two generations for one Pull.
+ */
+export function pullGenerations(pulls, members) {
+  const { impls } = bookImplementers(pulls, ompRows(members));
+  return new Map(pulls.map((p) => [p, generationOf(impls.get(p), p.chosen_cell)]));
+}
 
 function costOf(row) {
   const c = String(row.cost ?? "");
@@ -129,39 +196,24 @@ function costOf(row) {
 
 /**
  * One unit per ticket-features row dated on or after `windowStart` (every dated
- * row when null), in file order: `{ pull, cell, stratum, status, merged, pr,
- * ruling, pendingPr, claims, falseClaims, rows, spend }`. `prs` is `gh pr list`'s
+ * row when null), in file order: `{ pull, cell, stratum, generation, status,
+ * merged, pr, ruling, pendingPr, claims, falseClaims, rows, spend }`,
+ * `generation` null exactly when the Pull is excluded. `prs` is `gh pr list`'s
  * `{ number, state }` rows, or null when PR state is unknown (the fit). `stratum`
  * maps a features row to its stratum. Throws `AttributionError` on a features
  * row it cannot date or a booked `cost` it cannot read, and `RulingError` as
  * `rulingFor` does.
  */
 export function attribute({ features, members, tiers, prs = null, windowStart = null, stratum = () => null }) {
-  const key = (session, agent) => `${session}\0${agent}`;
   const pulls = datedRows(features);
-  const bySessionTicket = new Map(), byTicket = new Map();
-  for (const p of pulls) {
-    const k = key(p.session, p.ticket);
-    (bySessionTicket.get(k) ?? bySessionTicket.set(k, []).get(k)).push(p);
-    (byTicket.get(p.ticket) ?? byTicket.set(p.ticket, []).get(p.ticket)).push(p);
-  }
-
-  const omp = members.filter((r) => r.harness === "omp" && !EXCLUDED_MEMBER.test(lastSegment(r.member)));
+  const omp = ompRows(members);
   // Implementer rows to their Pull, and a PR-named member's key to its PR.
-  const implPull = new Map(), prOfKey = new Map();
-  const impls = new Map(pulls.map((p) => [p, []]));
+  const { impls, implPull } = bookImplementers(pulls, omp);
+  const prOfKey = new Map();
   for (const r of omp) {
-    if (isImplementer(r.member)) {
-      if (!r.ticket) continue;
-      const own = bySessionTicket.get(key(r.session, r.ticket));
-      const pull = own ? (own.find((p) => p.agent === r.agent) ?? own.at(-1)) : byTicket.get(r.ticket)?.findLast((p) => startedBefore(p, r));
-      if (!pull) continue;
-      implPull.set(key(r.session, r.agent), pull);
-      impls.get(pull).push(r);
-    } else {
-      const { pr } = parseMemberName(r.member);
-      if (pr) prOfKey.set(key(r.session, r.agent), pr);
-    }
+    if (isImplementer(r.member)) continue;
+    const { pr } = parseMemberName(r.member);
+    if (pr) prOfKey.set(key(r.session, r.agent), pr);
   }
   // Each PR to the last Pull, in file order, whose implementer rows carry it.
   const carrier = new Map();
@@ -224,37 +276,74 @@ export function attribute({ features, members, tiers, prs = null, windowStart =
       if (c === null) blank = true;
       else spend += c;
     }
+    const generation = generationOf(own, pull.chosen_cell);
     let status = "counted";
-    if (!own.some((m) => admissibleRow(m, pull.chosen_cell))) status = "excluded";
+    if (generation === null) status = "excluded";
     else if (pendingPr !== null) status = "pending";
     else if (claims === 0 && own.every((m) => ticketsEnding(m.ending) || NEITHER_ENDINGS.has(m.ending))) status = "left-out";
     else if (blank || (r && !r.carried)) status = "unpriced";
     return {
-      pull, cell: pull.chosen_cell, stratum: stratum(pull), status, merged, pr: r?.pr ?? null, ruling: r?.ruling ?? null,
+      pull, cell: pull.chosen_cell, stratum: stratum(pull), generation, status, merged, pr: r?.pr ?? null, ruling: r?.ruling ?? null,
       pendingPr, claims, falseClaims, rows: booked, spend: blank ? null : spend,
     };
   });
 }
 
 /**
- * Per cell, in cell-name order: `{ cell, n, merged, claims, failed, spend,
- * excluded, left_out, unpriced, pending }`. `n`, `merged`, `claims`, `failed`
- * and `spend` are over counted Pulls alone; the last four count the Pulls of
- * each other status.
+ * Each cell's generations, newest first: cell -> [model, …]. A generation's
+ * place is that of its latest Pull, by session id (an omp session id opens
+ * with its start time), then by file order, the order of `units`.
+ */
+export function generations(units) {
+  const latest = new Map(); // cell -> Map(generation -> { session, at })
+  units.forEach((u, at) => {
+    if (!u.generation) return;
+    const gens = latest.get(u.cell) ?? latest.set(u.cell, new Map()).get(u.cell);
+    const held = gens.get(u.generation);
+    if (!held || u.pull.session >= held.session) gens.set(u.generation, { session: u.pull.session, at });
+  });
+  return new Map([...latest].map(([cell, gens]) => [cell, [...gens]
+    .sort(([, a], [, b]) => cmp(b.session, a.session) || b.at - a.at)
+    .map(([g]) => g)]));
+}
+
+/**
+ * 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.
+ * `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()`
+ * of the units that place each cell's generations; by default these same
+ * units, but a caller tallying a subset passes the whole set's, so a subset
+ * never moves a cell's newest generation.
  */
-export function tally(units) {
+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 });
   const cells = new Map();
   for (const u of units) {
-    const c = cells.get(u.cell) ?? cells.set(u.cell, {
-      cell: u.cell, n: 0, merged: 0, claims: 0, failed: 0, spend: 0, excluded: 0, left_out: 0, unpriced: 0, pending: 0,
-    }).get(u.cell);
+    const c = cells.get(u.cell) ?? cells.set(u.cell, { excluded: 0, gens: new Map() }).get(u.cell);
+    if (u.status === "excluded") {
+      c.excluded++;
+      continue;
+    }
+    const g = u.generation ?? null;
+    const f = c.gens.get(g) ?? c.gens.set(g, figures(g)).get(g);
     if (u.status === "counted") {
-      c.n++;
-      if (u.merged) c.merged++;
-      c.claims += u.claims;
-      c.failed += u.falseClaims;
-      c.spend += u.spend;
-    } else c[u.status.replace("-", "_")]++;
+      f.n++;
+      if (u.merged) f.merged++;
+      f.claims += u.claims;
+      f.failed += u.falseClaims;
+      f.spend += u.spend;
+    } else f[u.status.replace("-", "_")]++;
   }
-  return [...cells.values()].sort((a, b) => (a.cell < b.cell ? -1 : a.cell > b.cell ? 1 : 0));
+  return [...cells].sort(([a], [b]) => cmp(a, b)).map(([cell, c]) => {
+    const ranked = order.get(cell) ?? [];
+    const newest = ranked[0] ?? null;
+    const rank = (g) => (ranked.includes(g) ? ranked.indexOf(g) : ranked.length);
+    const older = [...c.gens.values()].filter((f) => f.generation !== newest).sort((a, b) => rank(a.generation) - rank(b.generation));
+    return { cell, ...(c.gens.get(newest) ?? figures(newest)), excluded: c.excluded, older };
+  });
 }

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/ticket-router.mjs

@@ -47,7 +47,7 @@ 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, parseFeatures, tally } from "./pull-attribution.mjs";
+import { AttributionError, FEATURE_COLUMNS, attribute, generations, parseFeatures, tally } from "./pull-attribution.mjs";
 import { RulingError, parseTierOutcomes } from "./tier-outcomes.mjs";
 
 const NAME = "ticket-router";
@@ -333,36 +333,47 @@ const round4 = (x) => Math.round(x * 1e4) / 1e4;
  * the A/B's test set, not the fit's. The fit sees no PR state, so a Pull with
  * a Ruling is merged. A fit reads everything in the commit it is given: no row
  * is cut by date, because `--check` re-reads that same commit rather than
- * re-cutting the working tree's files.
+ * re-cutting the working tree's files. `order` ranks each cell's generations
+ * over every Pull in the window, the restriction aside, so the fit names the
+ * same newest generation the guard does.
  */
 function fitPulls({ features, members, verdicts, window }) {
-  return attribute({ features, members, tiers: verdicts, windowStart: window || null, stratum: ruleStratum })
-    .filter((u) => u.pull.exploration_draw !== "" || u.pull.sizing_src === "rule");
+  const all = attribute({ features, members, tiers: verdicts, windowStart: window || null, stratum: ruleStratum });
+  return { units: all.filter((u) => u.pull.exploration_draw !== "" || u.pull.sizing_src === "rule"), order: generations(all) };
 }
 
-// Per stratum and `*`, per cell: `n` counted Pulls, `merged`, $ per merged PR,
-// false claims over claims, fix rounds per merged PR, and the cell's excluded,
-// left-out and unpriced Pull counts.
-function estimate(units) {
+// Per stratum and `*`, per cell, its newest generation's figures: `n` counted
+// 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.
+function estimate(units, order) {
   const out = {};
   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] = {};
-    for (const t of tally(mine)) {
-      const fix = mine.filter((u) => u.cell === t.cell && u.status === "counted" && u.merged)
-        .reduce((n, u) => n + u.rows.filter((r) => parseMember(r.member)?.family === "fix-pr").length, 0);
+    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)
+          .reduce((n, u) => n + u.rows.filter((r) => parseMember(r.member)?.family === "fix-pr").length, 0);
+        return {
+          n: g.n,
+          merged: g.merged,
+          claims: g.claims,
+          failed: g.failed,
+          usd_per_merged: g.merged ? round4(g.spend / g.merged) : null,
+          fail_rate: g.claims ? round4(g.failed / g.claims) : null,
+          fix_rounds: g.merged ? round4(fix / g.merged) : null,
+          review_findings: null,
+          left_out: g.left_out,
+          unpriced: g.unpriced,
+        };
+      };
       out[s][t.cell] = {
-        n: t.n,
-        merged: t.merged,
-        claims: t.claims,
-        failed: t.failed,
-        usd_per_merged: t.merged ? round4(t.spend / t.merged) : null,
-        fail_rate: t.claims ? round4(t.failed / t.claims) : null,
-        fix_rounds: t.merged ? round4(fix / t.merged) : null,
-        review_findings: null,
+        generation: t.generation,
+        ...figures(t),
         excluded: t.excluded,
-        left_out: t.left_out,
-        unpriced: t.unpriced,
+        older: Object.fromEntries(t.older.map((o) => [o.generation, figures(o)])),
       };
     }
   }
@@ -371,8 +382,9 @@ function estimate(units) {
 
 // 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. 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
+// 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];
@@ -393,8 +405,8 @@ function adopt(est, cells, tripped) {
  */
 export function fitTable({ prior, features, members, verdicts, guard, commit = null }) {
   const window = guard.window_start ?? prior.window_start ?? null;
-  const units = fitPulls({ features, members, verdicts, window });
-  const estimates = estimate(units);
+  const { units, order } = fitPulls({ features, members, verdicts, window });
+  const estimates = estimate(units, order);
   const tripped = new Set(guard.tripped);
 
   let { stage, cells } = prior;
@@ -437,10 +449,16 @@ export function mergedSince({ table, features, members, verdicts, fitted }) {
     .filter((u) => u.status === "counted" && u.merged && !read.has(`${u.pull.session}\0${u.pull.agent}`)).length;
 }
 
-// Each cell's Pull counts over every stratum, as the fit prints them.
+// Each cell's Pull counts over every stratum, as the fit prints them: its
+// newest generation, then each older one.
 function cellCounts(estimates) {
+  const usd = (x) => (x === null ? "-" : x.toFixed(2));
+  const counts = (e) => `n=${e.n} merged=${e.merged} failed=${e.failed} usd_per_merged=${usd(e.usd_per_merged)}`;
   return Object.entries(estimates["*"] ?? {})
-    .map(([c, e]) => `${c} n=${e.n} merged=${e.merged} failed=${e.failed} excluded=${e.excluded} left_out=${e.left_out} unpriced=${e.unpriced}`)
+    .map(([c, e]) => [
+      `${c} ${e.generation ?? "-"} ${counts(e)} excluded=${e.excluded} left_out=${e.left_out} unpriced=${e.unpriced}`,
+      ...Object.entries(e.older).map(([g, o]) => `${c} ${g} (older) ${counts(o)}`),
+    ].join(", "))
     .join(", ") || "none";
 }
 

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