@feigi/fleet-ctl 3.92.2 → 3.93.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.92.2",
+  "version": "3.93.0",
   "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

@@ -76,9 +76,9 @@
 import { readFileSync } from "node:fs";
 import { makeDie, defineFlags } from "./arg.mjs";
 import { isCLI } from "./is-cli.mjs";
-import { CELL, POLICY_CELL } from "./ledger-grammar.mjs";
+import { POLICY_CELL } from "./ledger-grammar.mjs";
 import { formatTsv as formatMemberTsv, parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
-import { parseFeatures } from "./pr-cost.mjs";
+import { admissibleRow, parseFeatures } from "./pull-attribution.mjs";
 import { DATE, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
 
 const NAME = "cell-readout";
@@ -86,7 +86,6 @@ export const GATE = Object.freeze({ comparisons: 10, runDates: 5 });
 export const STOP = Object.freeze({ verdicts: 10, failRate: 0.8 });
 
 const key = (session, agent) => `${session}\0${agent}`;
-const levelOf = (cell) => CELL.exec(cell)?.[2] ?? null;
 
 /**
  * `features` keyed by session+agent. A repeat naming the same `chosen_cell`
@@ -106,10 +105,7 @@ function pullsOf(features) {
 /** The join's member row for a Pull when the Pull is admissible, else null. */
 function admissibleMember(pull, members) {
   const m = members.get(key(pull.session, pull.agent));
-  if (!m) return null;
-  const level = levelOf(pull.chosen_cell);
-  if (level === null || m.subagentType !== `fleet-implementer-${pull.chosen_cell}` || m.effort !== level || !m.model) return null;
-  return m;
+  return m && admissibleRow(m, pull.chosen_cell) ? m : null;
 }
 
 // One member row per session+agent. A key repeated with different fields is

package/scripts/member-outcomes.mjs

@@ -141,7 +141,7 @@ export function withReports(rows, scratch) {
 //   crash         the session never exited and wrote no yield sidecar;
 //   hollow        none of the above: the member stopped on its own.
 const IMPLEMENTER_LEAF = /^impl-\d+(?:-[a-z0-9]+)?$/;
-const isImplementer = (member) => IMPLEMENTER_LEAF.test(member.split("/").pop());
+export const isImplementer = (member) => IMPLEMENTER_LEAF.test(member.split("/").pop());
 
 export function endingOf({ member, pr, signals = null, earlierPrs = new Set(), verifyMain = verifyMainWithGit }) {
   if (!isImplementer(member)) return "";

package/scripts/metrics-refresh.mjs

@@ -42,7 +42,7 @@ import { makeDie, defineFlags } from "./arg.mjs";
 import { gitEnv } from "./git-env.mjs";
 import { FleetDirUnresolvable, fleetFile } from "./fleet-dir.mjs";
 import { isCLI } from "./is-cli.mjs";
-import { FEATURE_COLUMNS, parseFeatures } from "./pr-cost.mjs";
+import { FEATURE_COLUMNS, parseFeatures } from "./pull-attribution.mjs";
 
 const NAME = "metrics-refresh";
 const PR_COST = fileURLToPath(new URL("./pr-cost.mjs", import.meta.url));

package/scripts/pr-cost.mjs

@@ -25,55 +25,42 @@
 // fleet-tick's `router` row prints it today; a missing or unparseable file
 // means the default cell only, so deleting it cannot evade the guard.
 //
-// BOOKING. A Pull is a ticket-features.tsv row; its $ is the cost of the
-// member-outcomes.tsv row with the same `session` + `agent`, plus every member
-// that one dispatched (an `agent` path nested under it). A PR's $ is every
-// Pull of its ticket(s) up to the ruling — superseded re-dispatches included —
-// plus every member whose NAME carries the PR (`review-pr-<n>`, `fix-pr-<n>`,
-// the finisher spellings, the review fan-out labels; member-record.mjs's
-// parseMemberName decides), with their own nested members. `merge-bot-*`,
-// `memory` and `__advisor` are booked nowhere: their cost does not vary with
-// the implementer's cell. Only omp rows are read; a blank `cost` books 0 and
-// is counted as unpriced, and a Pull with no member row at all books 0 and is
-// listed as unbooked.
+// BOOKING is pull-attribution.mjs's, the one the router's fit reads too: each
+// Pull in the window is a unit booked as routed to its `chosen_cell`, with
+// every implementer under it, its PR's review, fix and finisher members and
+// their nested members, and its merge through its Ruling — merged when that
+// PR's state is MERGED. A Pull is counted, or excluded (no Admissible row),
+// pending (its PR still open, or not in the list), left out (never merged, no
+// `fixed` bail, and every ending the ticket's or neither's) or unpriced (a
+// booked row with a blank `cost`, or a Ruling whose PR none of its
+// implementers carries); only counted Pulls enter a cell's figures. A `cost`
+// that is neither blank nor a number is an input error (exit 2), as is a
+// ticket-features `run_date` that is neither blank nor YYYY-MM-DD, or a ruling
+// of a windowed Pull's ticket whose run_date is not YYYY-MM-DD or whose verdict
+// is not yes or no.
 //
-// A ticket's RULING is its last tier-outcomes.tsv row in file order dated on or
-// after its first Pull in the window, skipping rows with both verdict columns
-// blank, which were never ruled; that row names the PR and carries the quality
-// verdict. A PR ruling several tickets takes its verdict from the later of
-// their rulings in file order, whatever their dates. A ruling whose run_date is
-// not YYYY-MM-DD is an input error (exit 2), as is one whose verdict is not
-// yes or no. The PR's CELL is the `chosen_cell` of the last Pull booked to it
-// — tickets in the order of their first Pull, each ticket's Pulls in file
-// order, those dated on or before the ticket's ruling — cross-checked against
-// that Pull's member row: a `subagent_type` other than
-// `fleet-implementer-<cell>`, or an `effort` other than the cell's level,
-// lists the PR under `mismatch` and books it to no cell at all. A PR still
-// OPEN is pending and booked nowhere yet. A Pull with no ruling books to its
-// own `chosen_cell` as unmerged spend — unless its member opened a PR that is
-// still open, which is pending too.
-//
-// PER CELL: `n_pulls`; `n_merged`; `n_pass` (merged PRs passing the quality
-// floor — failure is `minted_false_claim=yes` or `closed_own_ticket=no`);
-// `fail_rate` = failed / merged; `mean_usd` = every $ booked to the cell —
-// merged, unmerged and superseded — / merged, so a cell that abandons work
-// carries that spend; `median_usd` over merged PRs alone, descriptive;
-// `router_usd`, the Pulls' own routing cost, summed. `usd_diff_ci95` is a
-// bootstrap 95% interval on `mean_usd` minus the baseline's — printed to be
-// read, never judged on.
+// 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.
 
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { makeDie, defineFlags, isDigits } from "./arg.mjs";
+import { makeDie, defineFlags } from "./arg.mjs";
 import { gitEnv } from "./git-env.mjs";
 import { fleetFile, FleetDirUnresolvable } from "./fleet-dir.mjs";
 import { isCLI } from "./is-cli.mjs";
-import { CELL } from "./ledger-grammar.mjs";
-import { parseMemberName } from "./member-record.mjs";
 import { parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
-import { RulingError, parseTierOutcomes, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
+import { AttributionError, attribute, parseFeatures, tally } from "./pull-attribution.mjs";
+import { RulingError, parseTierOutcomes } from "./tier-outcomes.mjs";
 
 const NAME = "pr-cost";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
@@ -91,38 +78,7 @@ export const TRIP_POINTS = 15;
 export const EXIT = { ok: 0, tripped: 3, none: 4 };
 export const GH_PR_LIMIT = 1000;
 
-export const FEATURE_COLUMNS = [
-  "run_date", "session", "agent", "ticket", "policy_cell", "chosen_cell", "exploration_draw",
-  "sizing_src", "sizing_pre", "router_usd", "brief_chars", "criteria", "comments", "age_days",
-  "paths", "test_paths", "xrefs", "kind",
-];
-
-// 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) {
-  const lines = String(text ?? "").split("\n").filter((l) => l.trim() && !l.startsWith("#"));
-  if (lines.length === 0) throw new Error("ticket-features.tsv has no header line");
-  const header = lines[0].split("\t");
-  const missing = FEATURE_COLUMNS.filter((c) => !header.includes(c));
-  if (missing.length) throw new Error(`ticket-features.tsv header lacks ${missing.join(", ")}`);
-  return lines.slice(1).map((l, i) => {
-    const cells = l.split("\t");
-    if (cells.length !== header.length) {
-      throw new Error(`ticket-features.tsv row ${i + 1}: ${cells.length} fields, expected ${header.length} — ${l.slice(0, 60)}`);
-    }
-    const row = Object.fromEntries(header.map((c, j) => [c, cells[j]]));
-    if (!isDigits(row.ticket)) throw new Error(`ticket-features.tsv row ${i + 1}: ticket ${JSON.stringify(row.ticket)} is not a number`);
-    if (!CELL.test(row.chosen_cell)) throw new Error(`ticket-features.tsv row ${i + 1}: chosen_cell ${JSON.stringify(row.chosen_cell)} is not a cell`);
-    return row;
-  });
-}
-
-export const EXCLUDED_MEMBER = /^(?:merge-?bot|memory$|__advisor$)/i;
-// omp nests a member's id as `<parent>/<parent>.<child>`: the child is the last segment after either separator.
-export const lastSegment = (agent) => String(agent).split(/[/.]/).at(-1);
-const usd = (r) => (r.cost === "" || r.cost === undefined ? 0 : Number(r.cost));
-const isMerged = (pr) => pr?.state === "MERGED";
-const failed = (tier) => tier.minted_false_claim === "yes" || tier.closed_own_ticket === "no";
+const routerUsd = (pull) => (pull.router_usd === "" ? 0 : Number(pull.router_usd));
 const round = (x, d = 4) => (x === null || !Number.isFinite(x) ? null : Number(x.toFixed(d)));
 
 function median(xs) {
@@ -167,7 +123,8 @@ export function bootstrapDiffCI(cellUnits, baseUnits, { iterations = 2000, seed
 }
 
 // The trip rule, in integer counts so a 3-of-20 difference is exactly 15
-// points rather than 14.999… in floating point.
+// points rather than 14.999… in floating point. `n` is a cell's claims and
+// `n_pass` the claims among them that held.
 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;
@@ -175,142 +132,46 @@ export function trips(cell, base) {
 }
 
 export function computeReport({ members, tiers, features, prs, routerTable = null, pricing = null, windowStart = WINDOW_START }) {
-  const omp = members.filter((r) => r.harness === "omp");
-  const memberKey = (session, agent) => `${session}\0${agent}`;
-  const prState = new Map(prs.map((p) => [String(p.number), p]));
-
-  // Direct bookings, keyed by the member row they name.
-  const pulls = features.filter((f) => f.run_date >= windowStart);
-  const pullByKey = new Map(pulls.map((p) => [memberKey(p.session, p.agent), p]));
-  const prMemberKeys = new Map();
-  for (const r of omp) {
-    if (EXCLUDED_MEMBER.test(lastSegment(r.member))) continue;
-    if (pullByKey.has(memberKey(r.session, r.agent))) continue;
-    const { pr } = parseMemberName(r.member);
-    if (pr) prMemberKeys.set(memberKey(r.session, r.agent), pr);
-  }
-  // Every omp row books to its nearest booked ancestor (itself included).
-  const pullUsd = new Map(), prMemberUsd = new Map();
-  const memberOfPull = new Map();
-  const booked = []; // [row, pull | null, pr | null]
-  for (const r of omp) {
-    if (EXCLUDED_MEMBER.test(lastSegment(r.member))) continue;
-    const segs = String(r.agent).split("/");
-    for (let i = segs.length; i > 0; i--) {
-      const k = memberKey(r.session, segs.slice(0, i).join("/"));
-      const pull = pullByKey.get(k);
-      const pr = prMemberKeys.get(k);
-      if (!pull && !pr) continue;
-      booked.push([r, pull ?? null, pull ? null : pr]);
-      if (pull) {
-        pullUsd.set(pull, (pullUsd.get(pull) ?? 0) + usd(r));
-        if (i === segs.length) memberOfPull.set(pull, r);
-      } else prMemberUsd.set(pr, (prMemberUsd.get(pr) ?? 0) + usd(r));
-      break;
-    }
-  }
-
-  // Rulings: per ticket, `rulingFor` of the ticket's first Pull — the last
-  // ruling row in file order dated on or after it, both-blank rows skipped.
-  const rulings = rulingsByTicket(tiers);
-  const fileOrder = new Map(tiers.map((t, i) => [t, i]));
-  const pullsByTicket = new Map();
-  for (const p of pulls) {
-    if (!pullsByTicket.has(p.ticket)) pullsByTicket.set(p.ticket, []);
-    pullsByTicket.get(p.ticket).push(p);
-  }
-  const groups = new Map(); // pr -> { pr, tier, pulls[] }
-  const unruled = [];
-  for (const [ticket, ps] of pullsByTicket) {
-    const ruling = rulingFor(rulings, ticket, ps[0].run_date);
-    if (!ruling) { unruled.push(...ps); continue; }
-    const g = groups.get(ruling.pr) ?? { pr: ruling.pr, tier: ruling, pulls: [] };
-    if (fileOrder.get(ruling) > fileOrder.get(g.tier)) g.tier = ruling;
-    for (const p of ps) (p.run_date <= ruling.run_date ? g.pulls : unruled).push(p);
-    groups.set(ruling.pr, g);
-  }
-
-  const cells = new Map();
-  const cellOf = (c) => {
-    if (!cells.has(c)) {
-      cells.set(c, { cell: c, n_pulls: 0, n_merged: 0, n_pass: 0, usd: 0, router_usd: 0, merged_usd: [], units: [] });
-    }
-    return cells.get(c);
-  };
-  const routerUsd = (p) => (p.router_usd === "" ? 0 : Number(p.router_usd));
-  const mismatch = [], pending = [];
-
-  for (const g of groups.values()) {
-    if (g.pulls.length === 0) continue;
-    const carrier = g.pulls.at(-1);
-    const cell = carrier.chosen_cell;
-    const m = memberOfPull.get(carrier);
-    const level = cell.split("-").slice(1).join("-");
-    if (m && (m.subagentType !== `fleet-implementer-${cell}` || m.effort !== level)) {
-      mismatch.push({ pr: g.pr, cell, subagent_type: m.subagentType, effort: m.effort });
-      continue;
-    }
-    const state = prState.get(g.pr);
-    if (!state || state.state === "OPEN") { pending.push(g.pr); continue; }
-    const total = g.pulls.reduce((s, p) => s + (pullUsd.get(p) ?? 0), 0) + (prMemberUsd.get(g.pr) ?? 0);
-    const c = cellOf(cell);
-    for (const p of g.pulls) { cellOf(p.chosen_cell).n_pulls++; c.router_usd += routerUsd(p); }
-    c.usd += total;
-    const merged = isMerged(state) ? 1 : 0;
-    c.units.push({ usd: total, merged });
-    if (merged) {
-      c.n_merged++;
-      c.merged_usd.push(total);
-      if (!failed(g.tier)) c.n_pass++;
-    }
-  }
-  for (const p of unruled) {
-    const opened = memberOfPull.get(p)?.pr;
-    if (opened && prState.get(opened)?.state === "OPEN") { pending.push(opened); continue; }
-    const c = cellOf(p.chosen_cell);
-    c.n_pulls++;
-    c.router_usd += routerUsd(p);
-    const spent = pullUsd.get(p) ?? 0;
-    c.usd += spent;
-    c.units.push({ usd: spent, merged: 0 });
-  }
-
-  const base = cells.get(BASELINE_CELL) ?? null;
-  const meanUsd = (c) => (c.n_merged ? c.usd / c.n_merged : null);
-  const figures = [...cells.values()].sort((a, b) => a.cell.localeCompare(b.cell)).map((c) => ({
-    cell: c.cell,
-    n_pulls: c.n_pulls,
-    n_merged: c.n_merged,
-    n_pass: c.n_pass,
-    fail_rate: c.n_merged ? round((c.n_merged - c.n_pass) / c.n_merged) : null,
-    mean_usd: round(meanUsd(c), 2),
-    median_usd: round(median(c.merged_usd), 2),
-    router_usd: round(c.router_usd, 4),
-    usd_diff_ci95: c.cell === BASELINE_CELL || !base ? null : bootstrapDiffCI(c.units, base.units),
+  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 meanUsd = (t) => (t.merged ? t.spend / t.merged : null);
+  const base = tallies.get(BASELINE_CELL) ?? null;
+  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)),
+    excluded: t.excluded,
+    left_out: t.left_out,
+    unpriced: t.unpriced,
   }));
 
   // The guard.
-  const byCell = new Map(figures.map((f) => [f.cell, f]));
-  const b = byCell.get(BASELINE_CELL) ?? { n_merged: 0, n_pass: 0, mean_usd: null, fail_rate: null };
+  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 $ 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 tripped = [];
   if (baseline.n >= MIN_N) {
-    for (const f of figures) {
-      if (f.cell === BASELINE_CELL || f.n_merged < MIN_N) continue;
-      // 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.
-      const c = cells.get(f.cell);
-      if (trips({ n: f.n_merged, n_pass: f.n_pass, mean_usd: meanUsd(c) }, { n: b.n_merged, n_pass: b.n_pass, mean_usd: meanUsd(base) })) tripped.push(f.cell);
+    for (const t of tallies.values()) {
+      if (t.cell !== BASELINE_CELL && t.merged >= MIN_N && trips(quality(t), quality(base))) tripped.push(t.cell);
     }
   }
   const verdict = baseline.n < MIN_N ? "none" : tripped.length ? "tripped" : "ok";
   // Retire: every non-default stage-1 cell tripped before any stratum adopted one.
   const adopted = Object.values(routerTable?.rows ?? {}).some((c) => c !== BASELINE_CELL);
   const retire = !adopted && STAGE_1.filter((c) => c !== BASELINE_CELL).every((c) => tripped.includes(c));
-  // The member rows this report books: every windowed Pull's, and those of
-  // PR-named members whose PR a windowed ticket was ruled on.
-  const inReport = booked.filter(([, pull, pr]) => pull || groups.has(pr)).map(([r]) => r);
 
   return {
     window_start: windowStart,
@@ -319,44 +180,40 @@ export function computeReport({ members, tiers, features, prs, routerTable = nul
     tripped,
     verdict,
     retire,
-    mismatch,
-    pending: [...new Set(pending)].sort((x, y) => Number(x) - Number(y)),
-    unpriced: inReport.filter((r) => r.cost === "").length,
-    // A Pull whose member row never reached member-outcomes.tsv books $0 into
-    // its cell's mean, which reads as a cheap run unless it is listed here.
-    unbooked_pulls: pulls.filter((p) => !pullUsd.has(p)).map((p) => p.agent),
-    ab: abReport(groups, pulls, prState, pullUsd, prMemberUsd),
-    cross_check: crossCheck(inReport, pricing),
+    pending: [...new Set(units.filter((u) => u.status === "pending").map((u) => u.pendingPr))].sort((x, y) => Number(x) - Number(y)),
+    ab: abReport(units),
+    cross_check: crossCheck(units.flatMap((u) => u.rows), pricing),
   };
 }
 
 // The reasoning test: arm A on an even ticket, B on an odd one. B has run only
-// if some odd-ticket Pull carries a `sizing_pre`.
-export function abReport(groups, pulls, prState, pullUsd, prMemberUsd) {
+// if some odd-ticket Pull carries a `sizing_pre`. An arm's $ is its counted
+// Pulls' spend plus their own `router_usd`, since the arms compare policies,
+// not cells.
+export function abReport(units) {
   const arm = (ticket) => (Number(ticket) % 2 === 0 ? "A" : "B");
-  const bPulls = pulls.filter((p) => arm(p.ticket) === "B");
+  const bPulls = units.map((u) => u.pull).filter((p) => arm(p.ticket) === "B");
   if (!bPulls.some((p) => p.sizing_pre !== "")) {
     return { status: "not-run", reason: "B not run — the table has no row a better classifier could change" };
   }
-  const arms = { A: { merged: 0, failed: 0, usd: 0 }, B: { merged: 0, failed: 0, usd: 0 } };
-  for (const g of groups.values()) {
-    if (!g.pulls.length || !isMerged(prState.get(g.pr))) continue;
-    const a = arms[arm(g.pulls.at(-1).ticket)];
-    a.merged++;
-    if (failed(g.tier)) a.failed++;
-    a.usd += g.pulls.reduce((s, p) => s + (pullUsd.get(p) ?? 0) + (p.router_usd === "" ? 0 : Number(p.router_usd)), 0)
-      + (prMemberUsd.get(g.pr) ?? 0);
+  const arms = { A: { merged: 0, claims: 0, failed: 0, usd: 0 }, B: { merged: 0, claims: 0, failed: 0, usd: 0 } };
+  for (const u of units) {
+    if (u.status !== "counted") continue;
+    const a = arms[arm(u.pull.ticket)];
+    if (u.merged) a.merged++;
+    a.claims += u.claims;
+    a.failed += u.falseClaims;
+    a.usd += u.spend + routerUsd(u.pull);
   }
   const disagree = bPulls.filter((p) => p.policy_cell !== p.chosen_cell).length;
-  const out = {
-    A: { n_merged: arms.A.merged, fail_rate: arms.A.merged ? round(arms.A.failed / arms.A.merged) : null, mean_usd: arms.A.merged ? round(arms.A.usd / arms.A.merged, 2) : null },
-    B: { n_merged: arms.B.merged, fail_rate: arms.B.merged ? round(arms.B.failed / arms.B.merged) : null, mean_usd: arms.B.merged ? round(arms.B.usd / arms.B.merged, 2) : null },
-    disagreement: bPulls.length ? round(disagree / bPulls.length) : null,
-  };
+  const side = (a) => ({
+    n_merged: a.merged, fail_rate: a.claims ? round(a.failed / a.claims) : null, mean_usd: a.merged ? round(a.usd / a.merged, 2) : null,
+  });
+  const out = { A: side(arms.A), B: side(arms.B), disagreement: bPulls.length ? round(disagree / bPulls.length) : null };
   // B can only show an effect through the Pulls where it chose differently.
   if (arms.A.merged < MIN_N || arms.B.merged < MIN_N) return { status: "insufficient", ...out };
   if (disagree < MIN_N) return { status: "underpowered", ...out };
-  const bWins = out.B.mean_usd < out.A.mean_usd && arms.B.failed * arms.A.merged <= arms.A.failed * arms.B.merged;
+  const bWins = out.B.mean_usd < out.A.mean_usd && arms.B.failed * arms.A.claims <= arms.A.failed * arms.B.claims;
   return { status: bWins ? "B-wins" : "B-off", ...out };
 }
 
@@ -381,7 +238,10 @@ export function crossCheck(rows, pricing) {
   return { rows: n, skipped, ratio: expected > 0 ? round(recorded / expected) : null };
 }
 
-const TSV_COLUMNS = ["cell", "n_pulls", "n_merged", "n_pass", "fail_rate", "mean_usd", "median_usd", "router_usd", "usd_diff_ci95", "guard"];
+const TSV_COLUMNS = [
+  "cell", "n_pulls", "n_merged", "n_claims", "n_failed", "fail_rate", "mean_usd", "median_usd", "router_usd", "usd_diff_ci95",
+  "excluded", "left_out", "unpriced", "guard",
+];
 
 export function formatReport(report) {
   const guardOf = (f) => {
@@ -394,13 +254,7 @@ export function formatReport(report) {
   for (const f of report.cells) lines.push(TSV_COLUMNS.map((c) => (c === "guard" ? guardOf(f) : cell(f[c]))).join("\t"));
   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"}; unpriced member rows: ${report.unpriced}`);
-  if (report.mismatch.length) {
-    lines.push(`# mismatch (excluded from every cell): ${report.mismatch.map((m) => `PR#${m.pr} ${m.cell} vs ${m.subagent_type || "(none)"}/${m.effort || "(none)"}`).join("; ")}`);
-  }
-  if (report.unbooked_pulls.length) {
-    lines.push(`# unbooked Pulls (no member row, so $0 in the mean): ${report.unbooked_pulls.join(" ")}`);
-  }
+  lines.push(`# window_start ${report.window_start}; pending PRs: ${report.pending.length ? report.pending.join(" ") : "none"}`);
   const ab = report.ab;
   lines.push(ab.status === "not-run"
     ? `# A/B: ${ab.reason}`
@@ -493,7 +347,11 @@ function main() {
 
   let report;
   try { report = computeReport({ members, tiers, features, prs, routerTable, pricing }); }
-  catch (e) { if (e instanceof RulingError) die(`${tiersPath}: ${e.message}`); throw e; }
+  catch (e) {
+    if (e instanceof RulingError) die(`${tiersPath}: ${e.message}`);
+    if (e instanceof AttributionError) die(e.message);
+    throw e;
+  }
   process.stdout.write(has("json") ? JSON.stringify(report, null, 2) + "\n" : formatReport(report));
   if (!has("guard")) return;
   const file = arg("out") ?? defaultGuardPath();

package/scripts/pull-attribution.mjs

@@ -0,0 +1,260 @@
+// 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.
+//
+// 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
+// is two units. Nothing splits across cells.
+//
+// JOINS. Only omp member rows are read, and a member whose name's last segment
+// starts with merge-bot (or mergebot), or is `memory` or `__advisor`, is booked
+// nowhere: its cost does not vary with the cell.
+//   - An implementer row (member-outcomes' implementer leaf) joins the Pull of
+//     its `ticket` in its own session. A session with no Pull of that ticket
+//     (a claim resumed in a later run) joins the ticket's latest earlier Pull.
+//   - A review, fix or finisher row — any row whose name carries a PR — joins
+//     the Pull whose implementer rows carry that PR in `pr`.
+//   - A nested member books with its nearest booked ancestor.
+//
+// RULING. A Pull's candidate Ruling is `rulingFor` of its ticket and date. One
+// PR's merge counts once: among the Pulls whose candidate names it, the Pull
+// whose implementer rows carry the PR takes it, with the verdict of the latest
+// such ruling row in file order. When none carries it, the last of them in
+// file order takes it and is unpriced, since its PR's review and fix spend
+// cannot be booked. The other candidates stay unruled.
+//
+// MERGED: the Pull holds a Ruling and, when PR states are given, its PR is
+// MERGED. With PR states, a ruled PR that is OPEN or not in the list, or an
+// unruled Pull whose implementer opened a PR still OPEN, is pending.
+//
+// STATUS, first that applies:
+//   excluded  no Admissible row among the Pull's implementer rows;
+//   pending   see above (only with PR states);
+//   left-out  holds no claim (never merged, no `fixed` bail), and every
+//             implementer ending is the ticket's or neither's;
+//   unpriced  a booked row's `cost` is blank, or the Pull took its Ruling
+//             without carrying its PR;
+//   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`.
+//
+// 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
+// `bail:fixed-refuted` ending is one claim, false when refuted. A cell's fail
+// rate is its counted Pulls' false claims over their claims.
+//
+// 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.
+
+import { isDigits } from "./arg.mjs";
+import { CELL } from "./ledger-grammar.mjs";
+import { parseMemberName } from "./member-record.mjs";
+import { isImplementer } from "./member-outcomes.mjs";
+import { DATE, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
+
+// The ticket-features row, one per Pull, in this order.
+export const FEATURE_COLUMNS = Object.freeze([
+  "run_date", "session", "agent", "ticket", "policy_cell", "chosen_cell", "exploration_draw",
+  "sizing_src", "sizing_pre", "router_usd", "brief_chars", "criteria", "comments", "age_days",
+  "paths", "test_paths", "xrefs", "kind",
+]);
+
+// 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) {
+  const lines = String(text ?? "").split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+  if (lines.length === 0) throw new Error("ticket-features.tsv has no header line");
+  const header = lines[0].split("\t");
+  const missing = FEATURE_COLUMNS.filter((c) => !header.includes(c));
+  if (missing.length) throw new Error(`ticket-features.tsv header lacks ${missing.join(", ")}`);
+  return lines.slice(1).map((l, i) => {
+    const cells = l.split("\t");
+    if (cells.length !== header.length) {
+      throw new Error(`ticket-features.tsv row ${i + 1}: ${cells.length} fields, expected ${header.length} — ${l.slice(0, 60)}`);
+    }
+    const row = Object.fromEntries(header.map((c, j) => [c, cells[j]]));
+    if (!isDigits(row.ticket)) throw new Error(`ticket-features.tsv row ${i + 1}: ticket ${JSON.stringify(row.ticket)} is not a number`);
+    if (!CELL.test(row.chosen_cell)) throw new Error(`ticket-features.tsv row ${i + 1}: chosen_cell ${JSON.stringify(row.chosen_cell)} is not a cell`);
+    return row;
+  });
+}
+
+export const EXCLUDED_MEMBER = /^(?:merge-?bot|memory$|__advisor$)/i;
+// omp nests a member's id as `<parent>/<parent>.<child>`: the child is the last segment after either separator.
+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.
+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;
+}
+
+// A bad input row, as opposed to a bug: a caller that reports bad input catches this class alone.
+export class AttributionError extends Error {}
+
+/**
+ * The features rows with a YYYY-MM-DD `run_date`, the rows that can be placed
+ * against the window and a ruling. A blank `run_date` (route writes one for a
+ * session id with no date) is no Pull and is left out. Any other date is a
+ * hand-edit that cannot be placed and is refused: dropping it would shrink
+ * every figure unseen.
+ */
+function datedRows(features) {
+  return features.filter((r) => {
+    if (DATE.test(r.run_date)) return true;
+    if (r.run_date !== "") throw new AttributionError(`ticket #${r.ticket}: a ticket-features row's run_date is '${r.run_date}', expected YYYY-MM-DD or blank`);
+    return false;
+  });
+}
+
+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 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);
+
+function costOf(row) {
+  const c = String(row.cost ?? "");
+  if (c === "") return null;
+  const n = Number(c);
+  if (c.trim() === "" || !Number.isFinite(n)) throw new AttributionError(`member-outcomes row session ${row.session} agent ${row.agent}: cost '${c}' is not a number`);
+  return n;
+}
+
+/**
+ * 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
+ * `{ 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)));
+  // 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, []]));
+  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);
+    }
+  }
+  // Each PR to the last Pull, in file order, whose implementer rows carry it.
+  const carrier = new Map();
+  for (const p of pulls) for (const r of impls.get(p)) if (r.pr) carrier.set(r.pr, p);
+
+  // Every row books to its nearest booked ancestor, itself included.
+  const rows = new Map(pulls.map((p) => [p, []]));
+  for (const r of omp) {
+    const segs = String(r.agent).split("/");
+    for (let i = segs.length; i > 0; i--) {
+      const k = key(r.session, segs.slice(0, i).join("/"));
+      const pull = implPull.get(k) ?? carrier.get(prOfKey.get(k));
+      if (pull) rows.get(pull).push(r);
+      if (pull || prOfKey.has(k)) break;
+    }
+  }
+
+  // Rulings: each PR's merge to one Pull.
+  const inWindow = pulls.filter((p) => windowStart === null || p.run_date >= windowStart);
+  const rulings = rulingsByTicket(tiers);
+  const fileOrder = new Map(tiers.map((t, i) => [t, i]));
+  const candidates = new Map(); // pr -> [{ pull, ruling }]
+  for (const p of inWindow) {
+    const ruling = rulingFor(rulings, p.ticket, p.run_date);
+    if (ruling) (candidates.get(ruling.pr) ?? candidates.set(ruling.pr, []).get(ruling.pr)).push({ pull: p, ruling });
+  }
+  const ruled = new Map(); // pull -> { pr, ruling, carried }
+  for (const [pr, cands] of candidates) {
+    const ruling = cands.reduce((a, c) => (fileOrder.get(c.ruling) > fileOrder.get(a) ? c.ruling : a), cands[0].ruling);
+    const held = cands.find((c) => c.pull === carrier.get(pr));
+    ruled.set(held?.pull ?? cands.at(-1).pull, { pr, ruling, carried: !!held });
+  }
+
+  const state = prs && new Map(prs.map((p) => [String(p.number), p.state]));
+  return inWindow.map((pull) => {
+    const own = impls.get(pull);
+    const booked = rows.get(pull);
+    const r = ruled.get(pull) ?? null;
+    let merged = r !== null;
+    let pendingPr = null;
+    if (state) {
+      if (r) {
+        const s = state.get(r.pr);
+        if (s === undefined || s === "OPEN") pendingPr = r.pr;
+        merged = s === "MERGED";
+      } else pendingPr = own.find((m) => m.pr && state.get(m.pr) === "OPEN")?.pr ?? null;
+    }
+    let claims = 0, falseClaims = 0;
+    if (merged) {
+      claims++;
+      if (failsFloor(r.ruling)) falseClaims++;
+    }
+    for (const m of own) {
+      if (m.ending === "bail:fixed" || m.ending === "bail:fixed-refuted") claims++;
+      if (m.ending === "bail:fixed-refuted") falseClaims++;
+    }
+    let spend = 0, blank = false;
+    for (const m of booked) {
+      const c = costOf(m);
+      if (c === null) blank = true;
+      else spend += c;
+    }
+    let status = "counted";
+    if (!own.some((m) => admissibleRow(m, pull.chosen_cell))) 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,
+      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.
+ */
+export function tally(units) {
+  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);
+    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("-", "_")]++;
+  }
+  return [...cells.values()].sort((a, b) => (a.cell < b.cell ? -1 : a.cell > b.cell ? 1 : 0));
+}

package/scripts/ticket-router.mjs

@@ -47,19 +47,13 @@ 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 { DATE, lastPullByTicket, parseTierOutcomes, rulingFor, rulingsByTicket } from "./tier-outcomes.mjs";
+import { AttributionError, FEATURE_COLUMNS, attribute, parseFeatures, tally } from "./pull-attribution.mjs";
+import { RulingError, parseTierOutcomes } from "./tier-outcomes.mjs";
 
 const NAME = "ticket-router";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 export const DEFAULT_TABLE = join(SCRIPT_DIR, "router-table.json");
 
-// The ticket-features row, one per Pull, in this order.
-export const COLUMNS = Object.freeze([
-  "run_date", "session", "agent", "ticket", "policy_cell", "chosen_cell",
-  "exploration_draw", "sizing_src", "sizing_pre", "router_usd", "brief_chars",
-  "criteria", "comments", "age_days", "paths", "test_paths", "xrefs", "kind",
-]);
-
 export const STRATA = Object.freeze(["light", "heavy", "unknown"]);
 // The free classifier's thresholds: heavy past the median brief length of
 // the tickets whose sizing verdict is known, or past five criteria.
@@ -323,140 +317,52 @@ export function route({ session, ticket, arm, implRow, chainHead = false, issue,
 }
 
 export function formatFeatureRow(row) {
-  return COLUMNS.map((c) => String(row[c] ?? "").replace(/[\t\r\n]/g, " ")).join("\t");
-}
-
-/** Data rows of a ticket-features TSV as objects; throws on a missing header or a short row. */
-export function parseFeatures(text) {
-  const lines = String(text ?? "").split("\n").filter((l) => l.trim() && !l.startsWith("#"));
-  if (lines.length === 0) throw new Error("no header line");
-  if (lines[0] !== COLUMNS.join("\t")) throw new Error(`header is not the ${COLUMNS.length} ticket-features columns`);
-  return lines.slice(1).map((l) => {
-    const cells = l.split("\t");
-    if (cells.length !== COLUMNS.length) throw new Error(`malformed row: ${cells.length} fields, expected ${COLUMNS.length} — ${l.slice(0, 60)}`);
-    return Object.fromEntries(COLUMNS.map((c, i) => [c, cells[i]]));
-  });
+  return FEATURE_COLUMNS.map((c) => String(row[c] ?? "").replace(/[\t\r\n]/g, " ")).join("\t");
 }
 
 // ---------------------------------------------------------------------------
 // fit
 // ---------------------------------------------------------------------------
 
-// Members whose cost does not vary with the implementer cell.
-const UNBOOKED = (name) => name.startsWith("merge-bot-") || name === "memory" || name === "__advisor";
 const round4 = (x) => Math.round(x * 1e4) / 1e4;
 
 /**
- * The verdict on a ticket's Pull dated `pullDate`, `{ pr, fail }`, or null: the
- * ruling `rulingFor` picks. A verdict is a ruled PR; the floor fails on a
- * minted false claim or an unclosed ticket.
- */
-function verdictOf(rulings, ticket, pullDate) {
-  const r = rulingFor(rulings, ticket, pullDate);
-  return r && { pr: String(r.pr ?? ""), fail: r.minted_false_claim === "yes" || r.closed_own_ticket === "no" };
-}
-
-/**
- * The features rows with a YYYY-MM-DD `run_date`, the rows that can be placed
- * against the window, the cut and a ruling. A blank `run_date` (route writes one
- * for a session id with no date) is no input row and is left out. Any other
- * date is a hand-edit that cannot be placed and is refused, as `rulingFor`
- * refuses a ruling's: dropping it would shrink the fit unseen.
+ * The fit's Pulls: pull-attribution.mjs's units over the window — booked as
+ * routed, each to its own row's cell and stratum — restricted to rows the free
+ * classifier routed plus exploration rows: a row a live B classifier routed is
+ * 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.
  */
-function datedRows(features) {
-  return features.filter((r) => {
-    if (DATE.test(r.run_date)) return true;
-    if (r.run_date !== "") throw new Error(`ticket #${r.ticket}: a ticket-features row's run_date is '${r.run_date}', expected YYYY-MM-DD or blank`);
-    return false;
-  });
+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");
 }
 
-/**
- * Per-ticket input rows: the ticket's features rows inside the window,
- * attributed to its LAST row's (in file order) cell and stratum, restricted to rows the
- * free classifier routed plus exploration rows — a row a live B classifier
- * routed is the A/B's test set, not the fit's. Its verdict rules its last
- * input row. A row with a blank `run_date` (route writes one for a session id
- * with no date) is no input row: it cannot be placed against the window or
- * its ruling, and a window bound drops it anyway. A `run_date` that is
- * neither blank nor YYYY-MM-DD is refused (see `datedRows`).
- * 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.
- */
-function fitTickets({ features, members, verdicts, window }) {
-  const inRange = datedRows(features).filter((r) => !window || r.run_date >= window);
-  const byTicket = new Map();
-  for (const r of inRange) {
-    if (!byTicket.has(r.ticket)) byTicket.set(r.ticket, []);
-    byTicket.get(r.ticket).push(r);
-  }
-  // `rulingFor` refuses a ruling whose date is not YYYY-MM-DD when its ticket
-  // is an input ticket. An input ticket is one the fit reads — its last
-  // in-window row is an exploration row or has `sizing_src` `rule`, which the
-  // skip below keeps — not every ticket with an in-window features row.
-  // `fit --due` also refuses for a ticket the skip drops: `mergedSince` calls
-  // `verdictOf` on every ticket with an in-window row the fitted commit does
-  // not hold, with no such skip.
-  const rulings = rulingsByTicket(verdicts);
-  const lastPulls = lastPullByTicket(inRange);
-  const out = [];
-  for (const [ticket, rows] of byTicket) {
-    const last = lastPulls.get(ticket);
-    if (last.exploration_draw === "" && last.sizing_src !== "rule") continue;
-    const verdict = verdictOf(rulings, ticket, last.run_date);
-    const keys = new Set(rows.map((r) => `${r.session}\0${r.agent}`));
-    let cost = 0;
-    let costKnown = true;
-    let booked = 0;
-    let fixRounds = 0;
-    for (const mr of members) {
-      const name = String(mr.member ?? mr.agent ?? "");
-      if (UNBOOKED(name)) continue;
-      if (!(keys.has(`${mr.session}\0${mr.agent}`) || mr.ticket === ticket || (verdict && verdict.pr && mr.pr === verdict.pr))) continue;
-      booked++;
-      // `cost` is a priced member-outcomes column; a row without it makes
-      // the ticket's $ unknown, so the fit adopts nothing off a TSV that lacks the column.
-      if (mr.cost === undefined || mr.cost === "" || !Number.isFinite(Number(mr.cost))) costKnown = false;
-      else cost += Number(mr.cost);
-      if (parseMember(name)?.family === "fix-pr") fixRounds++;
-    }
-    // A ticket with no member row on record has an unknown cost, not a free one.
-    if (booked === 0) costKnown = false;
-    for (const r of rows) if (r.router_usd !== "") cost += Number(r.router_usd) || 0;
-    out.push({ ticket, cell: last.chosen_cell, stratum: ruleStratum(last), verdict, cost, costKnown, fixRounds });
-  }
-  return out;
-}
-
-function estimate(tickets) {
-  const est = {};
-  for (const t of tickets) {
-    for (const s of [t.stratum, "*"]) {
-      est[s] ??= {};
-      const e = (est[s][t.cell] ??= { n: 0, merged: 0, fails: 0, cost: 0, costKnown: true, fix: 0 });
-      e.n++;
-      e.cost += t.cost;
-      e.costKnown &&= t.costKnown;
-      if (t.verdict) {
-        e.merged++;
-        if (t.verdict.fail) e.fails++;
-        e.fix += t.fixRounds;
-      }
-    }
-  }
+// 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) {
   const out = {};
-  for (const s of Object.keys(est).sort()) {
+  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 c of Object.keys(est[s]).sort()) {
-      const e = est[s][c];
-      out[s][c] = {
-        n: e.n,
-        merged: e.merged,
-        usd_per_merged: e.merged && e.costKnown ? round4(e.cost / e.merged) : null,
-        fail_rate: e.merged ? round4(e.fails / e.merged) : null,
-        fix_rounds: e.merged ? round4(e.fix / e.merged) : null,
+    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);
+      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,
+        excluded: t.excluded,
+        left_out: t.left_out,
+        unpriced: t.unpriced,
       };
     }
   }
@@ -487,8 +393,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 tickets = fitTickets({ features, members, verdicts, window });
-  const estimates = estimate(tickets);
+  const units = fitPulls({ features, members, verdicts, window });
+  const estimates = estimate(units);
   const tripped = new Set(guard.tripped);
 
   let { stage, cells } = prior;
@@ -508,7 +414,7 @@ export function fitTable({ prior, features, members, verdicts, guard, commit = n
   return {
     window_start: window,
     fitted_commit: commit,
-    n_rows: tickets.length,
+    n_rows: units.length,
     stage,
     cells,
     burn_in: !cells.every(atN),
@@ -520,16 +426,22 @@ export function fitTable({ prior, features, members, verdicts, guard, commit = n
 }
 
 /**
- * Merged PRs (tickets with a verdict on their last such row in file order)
- * among the YYYY-MM-DD-dated features rows on or after `window_start` that the
- * fitted commit's features file (`fitted`, parsed rows; empty before any fit)
- * does not hold, matched by `session` and `agent`.
+ * Merged PRs since the fit: pull-attribution.mjs's counted, merged Pulls on or
+ * after `window_start` whose features row the fitted commit's features file
+ * (`fitted`, parsed rows; empty before any fit) does not hold, matched by
+ * `session` and `agent`.
  */
-export function mergedSince({ table, features, verdicts, fitted }) {
-  const rulings = rulingsByTicket(verdicts);
+export function mergedSince({ table, features, members, verdicts, fitted }) {
   const read = new Set(fitted.map((r) => `${r.session}\0${r.agent}`));
-  const after = datedRows(features).filter((r) => (!table.window_start || r.run_date >= table.window_start) && !read.has(`${r.session}\0${r.agent}`));
-  return [...lastPullByTicket(after)].filter(([ticket, p]) => verdictOf(rulings, ticket, p.run_date)).length;
+  return attribute({ features, members, tiers: verdicts, windowStart: table.window_start || null })
+    .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.
+function cellCounts(estimates) {
+  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}`)
+    .join(", ") || "none";
 }
 
 // ---------------------------------------------------------------------------
@@ -630,7 +542,7 @@ function main() {
     // the rule, and neither this append nor the drain checks it.
     try {
       mkdirSync(dirname(pending), { recursive: true });
-      const header = statSync(pending, { throwIfNoEntry: false })?.size > 0 ? "" : `${COLUMNS.join("\t")}\n`;
+      const header = statSync(pending, { throwIfNoEntry: false })?.size > 0 ? "" : `${FEATURE_COLUMNS.join("\t")}\n`;
       appendFileSync(pending, `${header}${formatFeatureRow(row)}\n`);
     } catch (e) {
       process.stderr.write(`${NAME}: WARNING could not append to ${pending}: ${e.message} — this Pull's ticket-features row is not recorded\n`);
@@ -664,13 +576,15 @@ function main() {
     }
     return sha;
   };
-  // The join throws on a features row it cannot place and on a ruling of an input ticket it cannot place.
-  // For `fit` and `--check` an input ticket is one `fitTickets` reads (its last in-window row is an
-  // exploration row or has `sizing_src` `rule`), not every ticket with an in-window features row. `fit --due` also
-  // covers a ticket `fitTickets` skips, because `mergedSince` calls `verdictOf` on every ticket with an in-window
-  // row the fitted commit does not hold, with no such skip.
+  // The join throws on a features row it cannot date, a booked member row whose `cost` is not a number, and a
+  // ruling of a windowed Pull's ticket it cannot place — for `fit` and `--check` too on a Pull the fit then skips
+  // as a live B classifier's, since every windowed Pull is booked before that skip. Anything else it throws is a
+  // bug, never bad input, so it surfaces with its stack.
   const joined = (fit) => {
-    try { return fit(); } catch (e) { die(`cannot join --features ${need("features")} with --verdicts ${need("verdicts")}: ${e.message}`); }
+    try { return fit(); } catch (e) {
+      if (!(e instanceof RulingError || e instanceof AttributionError)) throw e;
+      die(`cannot join --features ${need("features")}, --members ${need("members")} and --verdicts ${need("verdicts")}: ${e.message}`);
+    }
   };
 
   if (mode === "check") {
@@ -685,7 +599,7 @@ function main() {
       process.exitCode = 1;
       return;
     }
-    process.stdout.write(`${NAME}: ${tablePath} matches a re-fit of ${refit.n_rows} tickets at ${short(fitted)}\n`);
+    process.stdout.write(`${NAME}: ${tablePath} matches a re-fit of ${refit.n_rows} Pulls at ${short(fitted)}\n`);
     return;
   }
 
@@ -699,14 +613,14 @@ function main() {
   if (F.has("due")) {
     const fitted = fittedCommit();
     const read = fitted === null ? [] : fileAt(fitted, "features", parseFeatures);
-    const n = joined(() => mergedSince({ table, features, verdicts, fitted: read }));
+    const n = joined(() => mergedSince({ table, features, members, verdicts, fitted: read }));
     process.stdout.write(`DUE=${n >= FIT_EVERY_MERGED ? "yes" : "no"} MERGED=${n}/${FIT_EVERY_MERGED}\n`);
     return;
   }
   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} tickets at ${short(sha)}; rows ${JSON.stringify(next.rows)}; burn_in ${next.burn_in}; stage ${next.stage}\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`);
 }
 
 if (isCLI(import.meta.url)) main();