@feigi/fleet-ctl 3.94.1 → 3.95.1

package/package.json

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

package/scripts/pr-cost.mjs

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

package/scripts/pull-attribution.mjs

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

package/scripts/router-table.json

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

package/scripts/ticket-router.mjs

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