@feigi/fleet-ctl 3.92.2 → 3.93.1

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();

package/scripts/tier-outcomes.mjs

@@ -9,9 +9,9 @@
 //          --note <text> [--sizing light|heavy] [--profile <p>] [--loc <n>] [--files <n>]
 //          [--scratch <dir>]
 //     Fills `run_date` (today's UTC date, the ruling date), `pr`, `ticket` (the
-//     PR's one `gh pr view --json closingIssuesReferences` issue; when the PR
-//     closes zero or several, the N of its one settled `impl-<N>=PR#<pr>` token
-//     in the run ledger), `tier` and, unless
+//     PR's one `gh pr view --json closingIssuesReferences,url` issue in its own
+//     repository; when the PR closes zero or several there, the N of its one
+//     settled `impl-<N>=PR#<pr>` token in the run ledger), `tier` and, unless
 //     `--sizing` names it, `sizing` (see below). Idempotent by
 //     PR: a row already present is named and nothing is written, exit 0.
 //   check [--live]
@@ -84,6 +84,7 @@ import { parseMember, parseToken, memberTokens, rowPr } from "./ledger-grammar.m
 import { rowText } from "./tier-check.mjs";
 import { latestImplReport, readReport, reportsDir, defaultScratch } from "./report-files.mjs";
 import { FleetDirUnresolvable } from "./fleet-dir.mjs";
+import { ownClosingIssues } from "./closing-refs.mjs";
 
 const NAME = "tier-outcomes";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
@@ -455,34 +456,35 @@ function readLedger(ledgerFile, requireFile) {
   }
 }
 
-// The unique issue numbers of a PR's closingIssuesReferences, in GitHub's
-// order, or an Error naming why they could not be read — a reference with no
-// integer issue number among the reasons. GH_REPO is blanked so an ambient one
-// naming another repository never decides which PR is read; the timeout keeps
-// a hung `gh` from stalling `append` or a close-out's `check --live`.
+// The unique issue numbers of a PR's closingIssuesReferences in its own
+// repository, by ownClosingIssues()'s rule, in GitHub's order — another
+// repository's reference is none of them — or an Error naming why they could
+// not be read, a reference that rule cannot read among the reasons. GH_REPO is
+// blanked so an ambient one naming another repository never decides which PR
+// is read; the timeout keeps a hung `gh` from stalling `append` or a
+// close-out's `check --live`.
 const GH_TIMEOUT_MS = 60_000;
 function closingIssueNumbers(pr) {
   let raw;
   try {
-    raw = execFileSync("gh", ["pr", "view", String(pr), "--json", "closingIssuesReferences"], {
+    raw = execFileSync("gh", ["pr", "view", String(pr), "--json", "closingIssuesReferences,url"], {
       encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, GH_REPO: "" }, timeout: GH_TIMEOUT_MS,
     });
   } catch (e) {
     throw new Error(`gh pr view ${pr} failed: ${e.stderr?.trim() || e.message}`);
   }
-  let refs;
+  let view;
   try {
-    refs = JSON.parse(raw).closingIssuesReferences;
+    view = JSON.parse(raw);
   } catch (e) {
     throw new Error(`gh pr view ${pr} returned unreadable JSON: ${e.message}`);
   }
-  if (!Array.isArray(refs)) throw new Error(`gh pr view ${pr} returned no closingIssuesReferences array`);
-  const numbers = [...new Set(refs.map((r) => r?.number))];
-  const unreadable = numbers.filter((n) => !Number.isInteger(n));
-  if (unreadable.length > 0) {
-    throw new Error(`gh pr view ${pr} returned a closing reference with no issue number (${unreadable.map((n) => JSON.stringify(n) ?? "undefined").join(", ")})`);
+  if (!Array.isArray(view?.closingIssuesReferences)) throw new Error(`gh pr view ${pr} returned no closingIssuesReferences array`);
+  try {
+    return ownClosingIssues(pr, view.url, view.closingIssuesReferences);
+  } catch (e) {
+    throw new Error(`gh pr view ${pr} answered ${e.message}`);
   }
-  return numbers;
 }
 
 function closingNumbers(pr) {