@feigi/fleet-ctl 3.21.12 → 3.22.0

package/package.json

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

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// The per-cell readout: how many within-session comparisons each implementer
+// cell has against the policy cell, and whether that is enough to read it.
+//
+//   cell-readout.mjs [--ticket-features <tsv>] [--member-outcomes <tsv>]
+//
+// Inputs default to docs/metrics/ under the working directory. A Pull is a
+// ticket-features.tsv row; what it ran is the member-outcomes.tsv row with the
+// same `session` + `agent`.
+//
+// ADMISSIBLE ROW. A Pull counts only when its member row exists, was
+// dispatched as the drawn cell's own definition (`subagent_type` =
+// `fleet-implementer-<chosen_cell>`), ran at the cell's level (`effort` = the
+// cell's `<level>`) and has a resolved `model` on record. So a generic `task`
+// dispatch, a clamped effort and every pre-cutover `fleet-implementer` /
+// `fleet-implementer-alt` row are never admissible. Whether the resolved model
+// was the role's target at dispatch is recorded in neither file; that half of
+// the tier check is the run ledger's, not this readout's.
+//
+// COMPARISON. For a cell X other than slow-high, a comparison is one session
+// holding at least one admissible X row and at least one admissible slow-high
+// row whose resolved (`model`, `effort`) differ from that X row's. A session
+// counts once however many rows it holds, and its date is its member-outcomes
+// `run_date`; a blank `run_date` means unknown, so that session is still a
+// comparison but adds no date to the distinct-date count.
+//
+// GATE. A cell is read only once it has at least GATE.comparisons comparisons
+// across at least GATE.runDates distinct run_dates. A gated cell prints one
+// line on stdout:
+//
+//   <cell> <comparisons> <run_dates> <resolved models>
+//
+// `<resolved models>` is the model of every admissible row at the cell — one
+// model by name, or `mixed (<model-a> n=…, <model-b> n=…)` when they span more
+// than one, because a role's target is operator config that can move under a
+// cell's history. A cell below the gate prints nothing on stdout and one
+// `below the gate` count on stderr. Nothing on either stream names a session,
+// ticket or member: the gate forbids reading a comparison early.
+//
+// Exit 0 whatever the counts; 2 on a usage error or an unreadable or
+// malformed input, with nothing on stdout.
+
+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 { parseTsv as parseMemberTsv } from "./member-outcomes.mjs";
+import { parseFeatures } from "./pr-cost.mjs";
+
+const NAME = "cell-readout";
+export const GATE = Object.freeze({ comparisons: 10, runDates: 5 });
+
+const key = (session, agent) => `${session}\0${agent}`;
+const levelOf = (cell) => CELL.exec(cell)?.[2] ?? null;
+
+/** 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;
+}
+
+/**
+ * `cells`: one entry per cell other than the policy cell that has a
+ * ticket-features row, `{ cell, comparisons, runDates, dates, models, gated }`,
+ * sorted by cell. `dates` is the comparisons' distinct run_dates, sorted;
+ * `models` maps each resolved model of the cell's admissible rows to its row
+ * count, largest first. `unjoined` counts Pulls with no member row.
+ */
+export function readout({ features, members }) {
+  const byKey = new Map(members.map((m) => [key(m.session, m.agent), m]));
+  // One Pull per session+agent: a re-dispatch lands on the same cell and the
+  // same member row.
+  const pulls = new Map(features.map((p) => [key(p.session, p.agent), p]));
+  const sessions = new Map();
+  const cells = new Map();
+  let unjoined = 0;
+  for (const p of pulls.values()) {
+    if (p.chosen_cell !== POLICY_CELL && !cells.has(p.chosen_cell)) cells.set(p.chosen_cell, new Map());
+    if (!byKey.has(key(p.session, p.agent))) unjoined++;
+    const m = admissibleMember(p, byKey);
+    if (!m) continue;
+    if (p.chosen_cell !== POLICY_CELL) cells.get(p.chosen_cell).set(m.model, (cells.get(p.chosen_cell).get(m.model) ?? 0) + 1);
+    if (!sessions.has(p.session)) sessions.set(p.session, { runDate: m.run_date, rows: [] });
+    sessions.get(p.session).rows.push({ cell: p.chosen_cell, model: m.model, effort: m.effort });
+  }
+
+  const out = [...cells].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([cell, modelCounts]) => {
+    let comparisons = 0;
+    const dates = new Set();
+    for (const { runDate, rows } of sessions.values()) {
+      const base = rows.filter((r) => r.cell === POLICY_CELL);
+      const compared = rows.some((x) => x.cell === cell && base.some((s) => s.model !== x.model || s.effort !== x.effort));
+      if (!compared) continue;
+      comparisons++;
+      if (runDate) dates.add(runDate);
+    }
+    const models = new Map([...modelCounts].sort(([a, n], [b, k]) => k - n || (a < b ? -1 : a > b ? 1 : 0)));
+    const runDates = dates.size;
+    return { cell, comparisons, runDates, dates: [...dates].sort(), models, gated: comparisons >= GATE.comparisons && runDates >= GATE.runDates };
+  });
+  return { cells: out, unjoined };
+}
+
+// Only a gated cell is formatted, and a comparison needs an admissible row at
+// the cell, so `models` is never empty here.
+function formatModels(models) {
+  if (models.size === 1) return [...models.keys()][0];
+  return `mixed (${[...models].map(([m, n]) => `${m} n=${n}`).join(", ")})`;
+}
+
+function main() {
+  const die = makeDie(NAME);
+  const { arg, sweep, stray } = defineFlags(die, {
+    flags: { "ticket-features": "value", "member-outcomes": "value" },
+  });
+  sweep();
+  stray();
+  const featuresPath = arg("ticket-features") ?? "docs/metrics/ticket-features.tsv";
+  const membersPath = arg("member-outcomes") ?? "docs/metrics/member-outcomes.tsv";
+  const load = (path, parse) => {
+    let text;
+    try { text = readFileSync(path, "utf8"); }
+    catch (e) { die(`cannot read ${path}: ${e.code ?? e.message}`); }
+    try { return parse(text); }
+    catch (e) { die(`${path}: ${e.message}`); }
+  };
+  const features = load(featuresPath, parseFeatures);
+  const members = load(membersPath, parseMemberTsv);
+
+  const { cells, unjoined } = readout({ features, members });
+  const lines = [];
+  const notes = [];
+  if (unjoined > 0) {
+    notes.push(`${unjoined} ticket-features row${unjoined === 1 ? " has" : "s have"} no member-outcomes row — never admissible`);
+  }
+  if (cells.length === 0) notes.push(`no cell other than ${POLICY_CELL} has a ticket-features row`);
+  for (const c of cells) {
+    if (c.gated) lines.push(`${c.cell} ${c.comparisons} ${c.runDates} ${formatModels(c.models)}`);
+    else notes.push(`${c.cell} below the gate: ${c.comparisons} comparisons across ${c.runDates} run_dates (needs ${GATE.comparisons} across ${GATE.runDates})`);
+  }
+  for (const n of notes) process.stderr.write(`${NAME}: ${n}\n`);
+  if (lines.length) process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+if (isCLI(import.meta.url)) main();

package/scripts/cell-readout.test.mjs

@@ -0,0 +1,341 @@
+// cell-readout.mjs: the per-cell gate over ticket-features.tsv joined to
+// member-outcomes.tsv, run as the CLI against synthetic fixture files.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tempDir } from "./temp-dir.mjs";
+import { paragraph, phrase, unemphasized } from "./prose-pin.mjs";
+import { formatTsv } from "./member-outcomes.mjs";
+import { FEATURE_COLUMNS } from "./pr-cost.mjs";
+import { readout, GATE } from "./cell-readout.mjs";
+
+const SCRIPT = fileURLToPath(new URL("./cell-readout.mjs", import.meta.url));
+
+const member = (o) => ({
+  run_date: "2026-10-01", role: "implementer", member: o.agent, model: "claude-opus-5", effort: "high",
+  ticket: "", pr: "", tokensCacheCreate: 0, tokensOut: 0, wallS: 0, turns: 1, harness: "omp",
+  tokensIn: 0, tokensCacheRead: 0, tokensCacheWrite1h: 0, cost: 0, ...o,
+});
+const pull = (o) => ({
+  run_date: "2026-10-01", policy_cell: "slow-high", exploration_draw: "", sizing_src: "rule", sizing_pre: "",
+  router_usd: "", brief_chars: "100", criteria: "1", comments: "0", age_days: "0", paths: "0",
+  test_paths: "0", xrefs: "0", kind: "enhancement", ...o,
+});
+
+function world() {
+  return { features: [], members: [], ticket: 100 };
+}
+// One implementer Pull at `cell` in `session`, and the member row it left.
+// `model`/`effort`/`subagentType` override what resolved and what was dispatched.
+function addRow(w, { session, date, cell, model, effort, subagentType, member: withMember = true }) {
+  const ticket = String(w.ticket++);
+  const agent = `impl-${ticket}`;
+  const level = cell.split("-").slice(1).join("-");
+  w.features.push(pull({ session, agent, ticket, chosen_cell: cell }));
+  if (withMember) {
+    w.members.push(member({
+      session, agent, run_date: date, ticket,
+      model: model ?? (cell.startsWith("slow-") ? "claude-opus-5" : "claude-sonnet-5"),
+      effort: effort ?? level, subagentType: subagentType ?? `fleet-implementer-${cell}`,
+    }));
+  }
+}
+// `n` sessions, each one comparison for `cell`: a `cell` row beside a slow-high
+// row, spread round-robin over `dates` distinct run_dates.
+let nextSession = 0;
+function addComparisons(w, cell, n, dates, rowOpts = {}) {
+  for (let i = 0; i < n; i++) {
+    const session = `2026-10-01T00-00-00-000Z_s${nextSession++}`;
+    const date = `2026-10-${String(1 + (i % dates)).padStart(2, "0")}`;
+    addRow(w, { session, date, cell, ...rowOpts });
+    addRow(w, { session, date, cell: "slow-high" });
+  }
+}
+
+function files(w) {
+  const dir = tempDir("cell-readout-");
+  const features = join(dir, "ticket-features.tsv");
+  const members = join(dir, "member-outcomes.tsv");
+  writeFileSync(features, [FEATURE_COLUMNS.join("\t"), ...w.features.map((r) => FEATURE_COLUMNS.map((c) => r[c] ?? "").join("\t"))].join("\n") + "\n");
+  writeFileSync(members, "# header\n" + formatTsv(w.members));
+  return { features, members, dir };
+}
+function cli(w, extra = []) {
+  const f = files(w);
+  return spawnSync(process.execPath, [SCRIPT, "--ticket-features", f.features, "--member-outcomes", f.members, ...extra], { encoding: "utf8", cwd: f.dir });
+}
+const lineFor = (stdout, cell) => stdout.split("\n").find((l) => l.split(" ")[0] === cell);
+
+test("the gate is ten comparisons across five run_dates: nine across five does not gate, ten across five does", () => {
+  const nine = world();
+  addComparisons(nine, "task-high", 9, 5);
+  const below = cli(nine);
+  assert.equal(below.status, 0, below.stderr);
+  assert.equal(lineFor(below.stdout, "task-high"), undefined, "a cell below the gate prints no line");
+  assert.match(below.stderr, /task-high below the gate: 9 comparisons across 5 run_dates/);
+
+  const ten = world();
+  addComparisons(ten, "task-high", 10, 5);
+  const at = cli(ten);
+  assert.equal(at.status, 0, at.stderr);
+  assert.equal(lineFor(at.stdout, "task-high"), "task-high 10 5 claude-sonnet-5");
+  assert.doesNotMatch(at.stderr, /task-high below the gate/);
+  assert.deepEqual(GATE, { comparisons: 10, runDates: 5 });
+});
+
+test("ten comparisons across four run_dates does not gate: both halves of the gate bind", () => {
+  const w = world();
+  addComparisons(w, "task-high", 12, 4);
+  const r = cli(w);
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(lineFor(r.stdout, "task-high"), undefined);
+  assert.match(r.stderr, /task-high below the gate: 12 comparisons across 4 run_dates/);
+});
+
+test("two resolved models in one cell's gate window print `mixed (...)` with each model's row count", () => {
+  const w = world();
+  addComparisons(w, "task-high", 7, 5);
+  addComparisons(w, "task-high", 3, 3, { model: "claude-opus-5" });
+  const r = cli(w);
+  assert.equal(r.status, 0, r.stderr);
+  // claude-opus-5 at task-high/high still differs from slow-high only if its
+  // effort does — it does not, so those three sessions are no comparison.
+  assert.match(r.stderr, /task-high below the gate: 7 comparisons across 5 run_dates/);
+
+  const gated = world();
+  addComparisons(gated, "task-high", 10, 5);
+  addComparisons(gated, "task-high", 2, 1, { model: "claude-haiku-4-5" });
+  const g = cli(gated);
+  assert.equal(g.status, 0, g.stderr);
+  assert.equal(lineFor(g.stdout, "task-high"), "task-high 12 5 mixed (claude-sonnet-5 n=10, claude-haiku-4-5 n=2)");
+});
+
+test("a comparison is one session, however many rows it holds, and a row on each side is required", () => {
+  const w = world();
+  // One session, three task-high rows and two slow-high rows: one comparison.
+  addRow(w, { session: "sA", date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: "sA", date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: "sA", date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: "sA", date: "2026-10-01", cell: "slow-high" });
+  addRow(w, { session: "sA", date: "2026-10-01", cell: "slow-high" });
+  // task-high with no slow-high beside it, and slow-high alone: no comparison.
+  addRow(w, { session: "sB", date: "2026-10-02", cell: "task-high" });
+  addRow(w, { session: "sC", date: "2026-10-03", cell: "slow-high" });
+  // A pair split across two sessions is no comparison either.
+  addRow(w, { session: "sD", date: "2026-10-04", cell: "smol-high" });
+  addRow(w, { session: "sE", date: "2026-10-04", cell: "slow-high" });
+  const [task, smol] = ["task-high", "smol-high"].map((c) => readout(parsed(w)).cells.find((x) => x.cell === c));
+  assert.deepEqual([task.comparisons, task.runDates], [1, 1]);
+  assert.deepEqual([smol.comparisons, smol.runDates], [0, 0]);
+});
+
+test("only admissible rows count: dispatched as the drawn cell's definition, at the cell's level, with a model on record", () => {
+  const w = world();
+  const s = (n) => `s-adm-${n}`;
+  // effort off the cell's level (a clamp): inadmissible
+  addRow(w, { session: s(1), date: "2026-10-01", cell: "task-high", effort: "medium" });
+  addRow(w, { session: s(1), date: "2026-10-01", cell: "slow-high" });
+  // dispatched as a generic task, not the cell's definition: inadmissible
+  addRow(w, { session: s(2), date: "2026-10-01", cell: "task-high", subagentType: "task" });
+  addRow(w, { session: s(2), date: "2026-10-01", cell: "slow-high" });
+  // the slow-high side dispatched as the pre-cutover definition: inadmissible
+  addRow(w, { session: s(3), date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: s(3), date: "2026-10-01", cell: "slow-high", subagentType: "fleet-implementer" });
+  // the slow-high side has no member row at all: no join, inadmissible
+  addRow(w, { session: s(4), date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: s(4), date: "2026-10-01", cell: "slow-high", member: false });
+  // blank model: the resolved model is unknown, so nothing can differ from it
+  addRow(w, { session: s(5), date: "2026-10-01", cell: "task-high", model: "" });
+  addRow(w, { session: s(5), date: "2026-10-01", cell: "slow-high" });
+  // the control: admissible on both sides
+  addRow(w, { session: s(6), date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: s(6), date: "2026-10-01", cell: "slow-high" });
+  const task = readout(parsed(w)).cells.find((x) => x.cell === "task-high");
+  assert.equal(task.comparisons, 1, "only the admissible session counts");
+  assert.deepEqual([...task.models], [["claude-sonnet-5", 3]], "the models column reads admissible rows only — sessions 3, 4 and 6");
+});
+
+test("a comparison needs a resolved (model, effort) that differs from slow-high's — the same model at a different level counts", () => {
+  const w = world();
+  // task-high resolved to slow-high's own model at the same level: empty comparison
+  addRow(w, { session: "sSame", date: "2026-10-01", cell: "task-high", model: "claude-opus-5" });
+  addRow(w, { session: "sSame", date: "2026-10-01", cell: "slow-high" });
+  // slow-medium: same model, a different effort — a real comparison
+  addRow(w, { session: "sEff", date: "2026-10-02", cell: "slow-medium" });
+  addRow(w, { session: "sEff", date: "2026-10-02", cell: "slow-high" });
+  const rows = readout(parsed(w)).cells;
+  assert.equal(rows.find((x) => x.cell === "task-high").comparisons, 0);
+  assert.equal(rows.find((x) => x.cell === "slow-medium").comparisons, 1);
+  assert.equal(rows.find((x) => x.cell === "slow-high"), undefined, "slow-high is the baseline, never a readout line");
+});
+
+test("a run_date is the comparison session's member-outcomes run_date, not the ticket-features one", () => {
+  const w = world();
+  addComparisons(w, "task-high", 10, 5);
+  for (const f of w.features) f.run_date = "2026-09-01";
+  const r = cli(w);
+  assert.equal(lineFor(r.stdout, "task-high"), "task-high 10 5 claude-sonnet-5");
+});
+
+test("a re-dispatched Pull is one Pull: two ticket-features rows for one session+agent count the member row once", () => {
+  const w = world();
+  addRow(w, { session: "sRe", date: "2026-10-01", cell: "task-high" });
+  addRow(w, { session: "sRe", date: "2026-10-01", cell: "slow-high" });
+  // The re-dispatch: the same Pull's features row again, on the same member row.
+  w.features.push({ ...w.features[0] });
+  // An unjoined Pull, likewise written twice.
+  addRow(w, { session: "sOrphan", date: "2026-10-01", cell: "smol-high", member: false });
+  w.features.push({ ...w.features[w.features.length - 1] });
+  const { cells, unjoined } = readout(parsed(w));
+  const task = cells.find((x) => x.cell === "task-high");
+  assert.equal(task.comparisons, 1);
+  assert.deepEqual([...task.models], [["claude-sonnet-5", 1]], "the member row behind a re-dispatched Pull is counted once");
+  assert.equal(unjoined, 1, "a re-dispatched Pull with no member row is one unjoined Pull");
+});
+
+test("a blank member-outcomes run_date is no date: its session is a comparison but adds nothing to the distinct-date count", () => {
+  const w = world();
+  addComparisons(w, "task-high", 4, 4);
+  for (let i = 0; i < 6; i++) {
+    const session = `sBlank${i}`;
+    addRow(w, { session, date: "", cell: "task-high" });
+    addRow(w, { session, date: "", cell: "slow-high" });
+  }
+  const task = readout(parsed(w)).cells.find((x) => x.cell === "task-high");
+  assert.equal(task.comparisons, 10);
+  assert.deepEqual([task.runDates, task.gated], [4, false], "ten comparisons over four real dates is below the five-date floor");
+  assert.ok(!task.dates.includes(""), "a blank run_date is listed as a date");
+});
+
+test("gated cells print sorted by cell name, not in ticket-features order", () => {
+  const w = world();
+  // Rows are added in reverse alphabetical order: task-high first, smol-high second.
+  addComparisons(w, "task-high", 10, 5);
+  addComparisons(w, "smol-high", 10, 5);
+  const r = cli(w);
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(
+    r.stdout.split("\n").filter(Boolean),
+    ["smol-high 10 5 claude-sonnet-5", "task-high 10 5 claude-sonnet-5"],
+  );
+});
+
+test("equal per-model counts in a mixed cell list models alphabetically", () => {
+  const w = world();
+  // Reverse-alphabetical insertion order: sonnet rows first, then haiku, five each.
+  addComparisons(w, "task-high", 5, 5, { model: "claude-sonnet-5" });
+  addComparisons(w, "task-high", 5, 5, { model: "claude-haiku-4-5" });
+  const r = cli(w);
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(lineFor(r.stdout, "task-high"), "task-high 10 5 mixed (claude-haiku-4-5 n=5, claude-sonnet-5 n=5)");
+});
+
+// run-team/SKILL.md sends the controller here for a cell's comparison count.
+// The prose is the only thing that does, and nothing else reads it: renaming
+// the script or pointing the floor back at another query leaves every test
+// above green. Each slice starts at an anchor that must occur exactly once and
+// ends at the paragraph's blank line, so a restatement elsewhere in the file
+// cannot satisfy a pin on the paragraph that carries the rule.
+const RUN_TEAM = readFileSync(join(import.meta.dirname, "..", "skills", "run-team", "SKILL.md"), "utf8");
+
+test("SKILL.md's floor names the script that prints a cell's count, and that script exists", () => {
+  const floor = unemphasized(paragraph(RUN_TEAM, "**Report the count the per-cell readout prints", "run-team's per-cell floor"));
+  const named = /`~\/\.fleet\/bin\/fleet-run (\S+\.mjs)`/.exec(floor)?.[1];
+  assert.ok(named, "the floor no longer tells the controller which script to run");
+  assert.equal(named, "cell-readout.mjs");
+  assert.ok(existsSync(join(dirname(SCRIPT), named)), `${named} is not a script beside cell-readout.mjs`);
+  assert.match(floor, phrase("prints `<cell> <comparisons> <run_dates> <resolved models>` for each cell past that floor"));
+  assert.match(floor, phrase("a cell below it only as a count on stderr"));
+});
+
+test("the line SKILL.md says the readout prints is the line it prints: four fields, a cell below the floor on stderr only", () => {
+  const gated = world();
+  addComparisons(gated, "task-high", 10, 5);
+  addComparisons(gated, "smol-high", 2, 2);
+  const r = cli(gated);
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(lineFor(r.stdout, "task-high"), "task-high 10 5 claude-sonnet-5");
+  assert.equal(lineFor(r.stdout, "smol-high"), undefined, "a cell below the floor must not print on stdout");
+  assert.match(r.stderr, /smol-high below the gate: 2 comparisons/);
+});
+
+test("SKILL.md says the readout counts a pair only when the two rows ran a different model or effort, as the readout does", () => {
+  const deliberate = unemphasized(paragraph(RUN_TEAM, "**The readout counts DELIBERATE comparisons.**", "run-team's DELIBERATE paragraph"));
+  assert.match(deliberate, phrase("the two rows must actually have RUN a different model or effort"));
+  // Run, not read: the same model at the same level is no comparison, the same
+  // model at a different level is one, a different model at the same level is one.
+  const w = world();
+  addRow(w, { session: "sNone", date: "2026-10-01", cell: "task-high", model: "claude-opus-5" });
+  addRow(w, { session: "sNone", date: "2026-10-01", cell: "slow-high" });
+  addRow(w, { session: "sModel", date: "2026-10-02", cell: "task-high" });
+  addRow(w, { session: "sModel", date: "2026-10-02", cell: "slow-high" });
+  addRow(w, { session: "sEffort", date: "2026-10-03", cell: "slow-medium" });
+  addRow(w, { session: "sEffort", date: "2026-10-03", cell: "slow-high" });
+  const { cells } = readout(parsed(w));
+  const countOf = (cell) => cells.find((c) => c.cell === cell).comparisons;
+  assert.deepEqual([countOf("task-high"), countOf("slow-medium")], [1, 1]);
+});
+
+test("the output identifies no comparison: no session, ticket or agent appears on either stream", () => {
+  const w = world();
+  addComparisons(w, "task-high", 10, 5);
+  addComparisons(w, "smol-high", 3, 2);
+  addRow(w, { session: "sOrphan", date: "2026-10-01", cell: "task-high", member: false });
+  const r = cli(w);
+  assert.equal(r.status, 0, r.stderr);
+  const out = r.stdout + r.stderr;
+  for (const f of w.features) {
+    assert.ok(!out.includes(f.session), `output names session ${f.session}`);
+    assert.ok(!out.includes(f.agent), `output names agent ${f.agent}`);
+  }
+  assert.match(r.stderr, /1 ticket-features row has no member-outcomes row/);
+});
+
+test("an empty ticket-features.tsv prints no line and says why, exit 0", () => {
+  const r = cli(world());
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(r.stdout, "");
+  assert.match(r.stderr, /no cell other than slow-high has a ticket-features row/);
+});
+
+test("usage and input errors exit 2 and print nothing on stdout", () => {
+  const w = world();
+  addComparisons(w, "task-high", 1, 1);
+  const f = files(w);
+  for (const args of [
+    ["--ticket-features", join(f.dir, "absent.tsv"), "--member-outcomes", f.members],
+    ["--ticket-features", f.features, "--member-outcomes", join(f.dir, "absent.tsv")],
+    ["--ticket-features", f.features, "--member-outcomes", f.members, "--bogus"],
+  ]) {
+    const r = spawnSync(process.execPath, [SCRIPT, ...args], { encoding: "utf8", cwd: f.dir });
+    assert.equal(r.status, 2, `${args.join(" ")}: ${r.stderr}`);
+    assert.equal(r.stdout, "");
+  }
+  writeFileSync(f.members, "# header\nshort\trow\n");
+  const bad = spawnSync(process.execPath, [SCRIPT, "--ticket-features", f.features, "--member-outcomes", f.members], { encoding: "utf8", cwd: f.dir });
+  assert.equal(bad.status, 2, bad.stderr);
+  assert.match(bad.stderr, /malformed row/);
+});
+
+test("with no flags it reads docs/metrics/ under the working directory", () => {
+  const w = world();
+  addComparisons(w, "task-high", 10, 5);
+  const f = files(w);
+  const metrics = join(f.dir, "docs", "metrics");
+  spawnSync("mkdir", ["-p", metrics]);
+  spawnSync("cp", [f.features, f.members, metrics]);
+  const r = spawnSync(process.execPath, [SCRIPT], { encoding: "utf8", cwd: f.dir });
+  assert.equal(r.status, 0, r.stderr);
+  assert.equal(lineFor(r.stdout, "task-high"), "task-high 10 5 claude-sonnet-5");
+});
+
+// The pure function's inputs, parsed the way the CLI parses them.
+function parsed(w) {
+  return {
+    features: w.features.map((r) => ({ ...r })),
+    members: w.members.map((r) => ({ ...r })),
+  };
+}

package/scripts/member-outcomes-header.test.mjs

@@ -1,10 +1,10 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, writeFileSync } from "node:fs";
-import { tempDir } from "./temp-dir.mjs";
+import { existsSync, readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { join } from "node:path";
 import { COLUMNS } from "./member-outcomes.mjs";
+import { GATE } from "./cell-readout.mjs";
 
 const REPO = join(import.meta.dirname, "..", "..");
 const TSV = readFileSync(join(REPO, "docs", "metrics", "member-outcomes.tsv"), "utf8");
@@ -55,94 +55,54 @@ test("the header states the blank, hand-edit, and superseded-generation rules",
   assert.match(HEADER, /workflows\/wf_/);
 });
 
-test("the header's awk read-outs index the columns they name", () => {
-  // This test asserted COLUMNS[0]/[2]/[4] — a fact about the CODE, not about
-  // the queries it is named for. Mutation-proven: repointing the header's pair
-  // query from $1/$3/$5 to $2/$4/$6 left it GREEN, so the query the header
-  // calls "the only unconfounded comparison" could silently group on run_date
-  // and distinguish by effort with nothing to catch it.
-  //
-  // So read the `$n` references out of the header's own awk lines and resolve
-  // each against COLUMNS. Mutation this must survive: changing any `$n` in the
-  // header without changing COLUMNS.
-  const awkLines = headerLines.filter((l) => l.includes("awk -F"));
-  assert.ok(awkLines.length >= 2, "header lost its awk read-outs");
-
-  const pair = pairQuery();
-  // BOTH arms are identified by the dispatch record (#1066), never by the role
-  // classifier and never by "the models differ" — so both `$n ~ /…/` tests
-  // must land on subagent_type, and there must be two of them.
-  const arms = [...pair.matchAll(/\$(\d+) ~ \/\(\^\|:\)fleet-implementer(-alt)?\$\//g)];
-  assert.equal(arms.length, 2, "the pair query no longer tests BOTH implementer definitions");
-  assert.deepEqual(arms.map((m) => Boolean(m[2])), [true, false], "the -alt arm must be tested FIRST — /fleet-implementer$/ is checked in the else branch");
-  for (const [, n] of arms) assert.equal(COLUMNS[n - 1], "subagent_type", "deliberateness comes from the dispatch record");
-
-  const keys = [...pair.matchAll(/[at]\[\$(\d+) FS \$(\d+)\]/g)];
-  assert.equal(keys.length, 2, "the pair query no longer keys both arms");
-  for (const [, session, model] of keys) {
-    assert.equal(COLUMNS[session - 1], "session", "a pair is WITHIN one session");
-    assert.equal(COLUMNS[model - 1], "model", "the two arms must have run different MODELS");
-  }
-
-  const [, dateKey, dateValue] = /d\[\$(\d+)\]=\$(\d+)/.exec(pair);
-  assert.equal(COLUMNS[dateKey - 1], "session");
-  assert.equal(COLUMNS[dateValue - 1], "run_date", "the gate's second number is distinct run_dateS");
-
+test("the header's awk read-out indexes the column it names", () => {
+  // Read the `$n` reference out of the header's own awk line and resolve it
+  // against COLUMNS — a fact about the CODE alone (COLUMNS[4]) stays green when
+  // the header is repointed. Mutation this must survive: changing the `$n` in
+  // the header without changing COLUMNS.
   const byModel = headerLines.find((l) => /\{n\[\$\d+\]\+\+\}/.test(l));
   assert.ok(byModel, "header lost its rows-by-model read-out");
   assert.equal(COLUMNS[/\{n\[\$(\d+)\]\+\+\}/.exec(byModel)[1] - 1], "model");
 });
 
-// The pair query as a runnable awk program: the header block from `awk -F` to
-// the path it reads, `#` stripped, the shell quoting removed. Index pins alone
-// cannot see a query that indexes the right columns and still counts the wrong
-// thing — which is precisely the defect #1066 was filed for.
-function pairQuery() {
-  const start = headerLines.findIndex((l) => l.includes("awk -F") && l.includes("fleet-implementer-alt"));
-  assert.ok(start >= 0, "header lost its within-run pair query");
-  let end = start;
-  while (end < headerLines.length && !headerLines[end].endsWith("docs/metrics/member-outcomes.tsv")) end++;
-  assert.ok(end < headerLines.length, "the pair query never reaches the file it reads");
-  return headerLines.slice(start, end + 1).map((l) => l.replace(/^#\s{0,3}/, "")).join("\n");
-}
+// The comparison count is cell-readout.mjs's, and the header only points at it:
+// a second copy of the definition as a runnable query is two countings free to
+// drift apart, which is how the pre-cell pair query came to count pairs no cell
+// owns once the cell grid replaced the two definitions it keyed on.
+test("the header points at cell-readout.mjs for a cell's comparisons and carries no query of its own", () => {
+  const invocation = headerLines.find((l) => /^#\s+node \S*cell-readout\.mjs\s*$/.test(l));
+  assert.ok(invocation, "header lost its `node plugin/scripts/cell-readout.mjs` pointer");
+  const script = invocation.replace(/^#\s+node\s+/, "").trim();
+  assert.equal(script, "plugin/scripts/cell-readout.mjs");
+  assert.ok(existsSync(join(REPO, script)), `the header points at ${script}, which does not exist`);
+  // The pointer is runnable as written, from the repo root, against this
+  // repo's own metrics files.
+  const r = spawnSync(process.execPath, [script], { cwd: REPO, encoding: "utf8" });
+  assert.equal(r.status, 0, r.stderr);
 
-test("the header's pair query counts DELIBERATE pairs, run against a corpus where every near-miss is present", () => {
-  // #1066: the query this replaces counted any session+role carrying two
-  // models, reported 198 keys against 17 real pairs, and so reported run-team's
-  // ten-across-five gate MET while the controlled comparison did not exist.
-  //
-  // Mutations this must survive, all measured against this fixture and all of
-  // which leave the column indexes (and therefore the test above) intact:
-  // dropping the `x[2]!=y[2]` model test reads 4 2, dropping the `-alt` anchor
-  // so both arms match one definition reads 0 0, and going back to #1066's own
-  // query — arms identified by `$3=="implementer"` rather than by the dispatch
-  // — reads 4 2, counting the untyped session and missing the omp one.
-  const rows = [
-    // a real pair: alt at sonnet against the top definition at opus
-    ["sA", "2026-09-01", "implementer", "impl-1", "claude-sonnet-5", "high", "1", "", "0", "0", "0", "1", "agent-a1", "claude", "fleet-implementer-alt"],
-    ["sA", "2026-09-01", "implementer", "impl-2", "claude-opus-5", "high", "2", "", "0", "0", "0", "1", "agent-a2", "claude", "fleet-implementer"],
-    // deliberate dispatch, empty comparison: both arms resolved to one model
-    ["sB", "2026-09-01", "other", "impl-3", "claude-sonnet-5", "high", "3", "", "0", "0", "0", "1", "agent-a3", "omp", "fleet-implementer-alt"],
-    ["sB", "2026-09-01", "other", "impl-4", "claude-sonnet-5", "high", "4", "", "0", "0", "0", "1", "agent-a4", "omp", "fleet-implementer"],
-    // two models, no deliberate dispatch: the accidental pair #1066 counted
-    ["sC", "2026-09-01", "implementer", "impl-5", "claude-sonnet-5", "high", "5", "", "0", "0", "0", "1", "agent-a5", "claude", ""],
-    ["sC", "2026-09-01", "implementer", "impl-6", "claude-opus-5", "high", "6", "", "0", "0", "0", "1", "agent-a6", "claude", ""],
-    // a second pair on the SAME day — two pairs, one run_date
-    ["sD", "2026-09-01", "implementer", "impl-7", "claude-sonnet-5", "high", "7", "", "0", "0", "0", "1", "agent-a7", "claude", "fleet-implementer-alt"],
-    ["sD", "2026-09-01", "implementer", "impl-8", "claude-opus-5", "high", "8", "", "0", "0", "0", "1", "agent-a8", "claude", "fleet-implementer"],
-    // and one on another day, so the second number is not the first
-    ["sE", "2026-09-02", "implementer", "impl-9", "claude-sonnet-5", "high", "9", "", "0", "0", "0", "1", "agent-a9", "claude", "fleet-implementer-alt"],
-    ["sE", "2026-09-02", "implementer", "impl-10", "claude-opus-5", "high", "10", "", "0", "0", "0", "1", "agent-a10", "claude", "fleet-implementer"],
-    // a typed non-implementer at a third model inside a pair session: the
-    // review fan-out runs one on every session and must not inflate anything
-    ["sE", "2026-09-02", "specialist", "rev", "claude-haiku-4-5", "", "", "", "0", "0", "0", "1", "agent-a11", "claude", "fleet-review-tests"],
-  ];
-  const corpus = join(tempDir("mo-hdr-"), "member-outcomes.tsv");
-  writeFileSync(corpus, "# header line, skipped by the query\n" + rows.map((r) => r.join("\t")).join("\n") + "\n");
+  assert.doesNotMatch(HEADER, /fleet-implementer-alt\$\//, "the header still carries the pre-cell pair query");
+  const subagentType = new RegExp(`\\$${COLUMNS.indexOf("subagent_type") + 1}(?!\\d)`);
+  assert.ok(
+    !headerLines.some((l) => subagentType.test(l)),
+    "an awk read-out over `subagent_type` is a second counting of comparisons",
+  );
 
-  const program = /awk -F'\\t' '([\s\S]*)' docs\/metrics\/member-outcomes\.tsv$/.exec(pairQuery());
-  assert.ok(program, "the pair query is no longer a runnable `awk -F'\\t' '<program>' <file>` line");
-  const r = spawnSync("awk", ["-F", "\t", program[1], corpus], { encoding: "utf8" });
-  assert.equal(r.status, 0, r.stderr);
-  assert.equal(r.stdout.trim(), "3 2", "three deliberate pairs across two distinct run_dates");
+  // The definition the header states is the one the script applies.
+  const block = HEADER.replace(/^#\s?/gm, "").replace(/\s+/g, " ");
+  assert.match(block, /a comparison is one session holding an ADMISSIBLE row at X and an admissible slow-high row whose resolved \(`model`, `effort`\) differ from the X row's/);
+  assert.match(block, /admissible only when its `subagent_type` is `fleet-implementer-<chosen_cell>` and its `effort` is the cell's level/);
+  assert.match(block, /joined to its row here on `session`\+`agent`/);
+  const gate = /at least (\w+) comparisons across (\w+) or more distinct `run_date`s/.exec(block);
+  assert.ok(gate, "the header no longer states the gate");
+  const words = { five: 5, ten: 10 };
+  assert.deepEqual({ comparisons: words[gate[1]], runDates: words[gate[2]] }, { ...GATE }, "the header's gate is not cell-readout.mjs's GATE");
+  assert.match(block, /`<cell> <comparisons> <run_dates> <resolved models>`/);
+  assert.match(block, /`mixed \(<model-a> n=…, <model-b> n=…\)`/);
+});
+
+test("the header names a producer script that exists", () => {
+  const producer = /produced by (\S+\.mjs)/.exec(HEADER);
+  assert.ok(producer, "the header no longer names the script that produces its rows");
+  assert.ok(existsSync(join(REPO, producer[1])), `the header names ${producer[1]} as its producer, which does not exist`);
+  assert.equal(producer[1], "plugin/scripts/member-outcomes.mjs");
 });

package/scripts/member-outcomes.mjs

@@ -35,8 +35,8 @@ export { normalizeModel, parseMemberName };
 //
 // `subagentType` is the record's `subagent_type` unchanged — `""` stays
 // `""` here, because unlike `effort` it does NOT mean unknown: it means the
-// dispatch named no agent definition, which is the reading the pair query
-// in this file's header depends on.
+// dispatch named no agent definition, which is the reading cell-readout.mjs's
+// admissibility test depends on: a blank is never any cell's definition.
 //
 // A member is never torn in the sense this file historically tracked (no
 // fold-back to tear mid-turn); `false` says so plainly rather than leaving

package/scripts/member-outcomes.test.mjs

@@ -269,9 +269,9 @@ test("a nested member's fan-out is scraped too, keyed on its path-relative stem"
 });
 
 test("role comes from classifyRole and is not invented here", () => {
-  // `role` had no assertion anywhere: it is the GROUPING column of the header's
-  // pair query, so a classifyRole regression moved every bucket in the read-out
-  // while the suite stayed green.
+  // `role` had no assertion anywhere while it was the GROUPING column of the
+  // header's former pair query, so a classifyRole regression moved every
+  // bucket in that read-out while the suite stayed green.
   const dir = fixture([
     ["impl-580", [sessionEvt("/x"), thinkingEvt("xhigh"), assistantEvt("claude-opus-5")]],
     ["merge-bot-3", [sessionEvt("/x"), thinkingEvt("xhigh"), sessionInitEvt("merge pass 3", "fleet-merge-bot"), assistantEvt("claude-opus-5")]],

package/scripts/tier-outcomes-header.test.mjs

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { between, phrase, sentences, stripHashGutter, unemphasized } from "./prose-pin.mjs";
-import { COLUMNS as MEMBER_COLUMNS } from "./member-outcomes.mjs";
+import { GATE, readout } from "./cell-readout.mjs";
 import { COLUMNS } from "./tier-outcomes.mjs";
 
 // #472: this file's header has never been pinned, while SKILL.md's guard tells
@@ -381,26 +381,20 @@ test("the ruling step refuses to record a sizing verdict it cannot date", () =>
 });
 
 // `run_date` is DERIVED in `member-outcomes.tsv` (a transcript mtime) and
-// STAMPED AT RULING here, and phase 2's pairing floor counts distinct
-// `run_date`s — ten pairs across five dates — over the other file, never this
-// one. Read as a count over THIS file, it answers a different question, and
-// nothing in this header used to say so.
+// STAMPED AT RULING here, and phase 2's per-cell gate counts distinct
+// `run_date`s — ten comparisons across five dates — over the other file, never
+// this one. Read as a count over THIS file, it answers a different question,
+// and nothing in this header used to say so.
 //
 // The paragraph that now says it makes claims about files this one does not
 // contain, which is the shape that rots silently: it stays true only while
-// member-outcomes.tsv keeps carrying the pairing query, `member-outcomes.mjs`
-// keeps stamping dates off an mtime, and SKILL.md keeps the floor's numbers.
-// So the pins below DERIVE each claim from its real source — the same reason
-// the `profile` pin above derives the enum instead of restating it.
-const MEMBER_TSV = readFileSync(join(REPO, "docs", "metrics", "member-outcomes.tsv"), "utf8");
+// cell-readout.mjs keeps dating comparisons off member-outcomes.tsv,
+// `member-outcomes.mjs` keeps stamping dates off an mtime, and SKILL.md keeps
+// the floor's numbers. So the pins below DERIVE each claim from its real
+// source — the same reason the `profile` pin above derives the enum instead of
+// restating it.
 const MEMBER_SRC = readFileSync(join(REPO, "plugin", "scripts", "member-outcomes.mjs"), "utf8");
 
-const memberHeaderLines = [];
-for (const l of MEMBER_TSV.split("\n")) {
-  if (!l.startsWith("#") && l.trim()) break;
-  memberHeaderLines.push(l);
-}
-
 // Bounded at both ends, for `between`'s own stated reason: this header is 140
 // lines about exactly these words, so an unbounded match is satisfiable from
 // the provenance block above the paragraph or the column legend below it. The
@@ -418,9 +412,9 @@ test("the header says which file each distinct-`run_date` count is read from, an
   assert.match(
     block,
     phrase(
-      "at least ten within-run pairs across five or more distinct `run_date`s, the floor that forbids reading the pairs early — is NOT read here at all. It comes from the pairing query in `docs/metrics/member-outcomes.tsv`'s own header",
+      "at least ten comparisons across five or more distinct `run_date`s, the floor that forbids reading a cell early — is NOT read here at all. It comes from `plugin/scripts/cell-readout.mjs`, which dates each comparison by its session's `run_date` in `docs/metrics/member-outcomes.tsv`",
     ),
-    "the header no longer says the pairing floor's distinct-date count is read from member-outcomes.tsv, not here",
+    "the header no longer says the per-cell gate's distinct-date count is read from member-outcomes.tsv through cell-readout.mjs, not here",
   );
 
   // The definitional halves, each joined to what it makes the column MEAN. A
@@ -457,47 +451,27 @@ test("the header says which file each distinct-`run_date` count is read from, an
   );
 });
 
-test("the header's `run_date` source claims still hold against the query, the scraper and the guard", () => {
+test("the header's `run_date` source claims still hold against the readout, the scraper and the guard", () => {
   const block = runDateSources();
 
-  // The pairing half: the query lives in the OTHER file's header and keys its
-  // dates off the other file's own columns, so resolve it against that file's
-  // COLUMNS export. This is the claim that makes the paragraph load-bearing —
-  // if the query moves or is rekeyed, "read it from there" stops being true.
-  // Bounded to the query BLOCK, not the whole 140-line header —
-  // member-outcomes-header.test.mjs's own `pairQuery()` bounds it the same
-  // way, for the same reason: an unbounded match is satisfiable by a stale
-  // `d[$1]=$2` idiom anywhere in that header even after the real query moved
-  // or was rekeyed, which is exactly what would make "read it from there"
-  // stop being true without this pin noticing.
-  const pairQueryStart = memberHeaderLines.findIndex((l) => l.includes("awk -F") && l.includes("fleet-implementer-alt"));
-  assert.ok(pairQueryStart >= 0, "member-outcomes.tsv's header lost its within-run pair query");
-  let pairQueryEnd = pairQueryStart;
-  while (pairQueryEnd < memberHeaderLines.length && !memberHeaderLines[pairQueryEnd].endsWith("docs/metrics/member-outcomes.tsv")) pairQueryEnd++;
-  assert.ok(pairQueryEnd < memberHeaderLines.length, "the pairing query never reaches the file it reads");
-  const pairQueryBlock = memberHeaderLines.slice(pairQueryStart, pairQueryEnd + 1).join("\n");
-
-  const pairKey = /d\[\$(\d+)\]=\$(\d+)/.exec(pairQueryBlock);
-  assert.ok(pairKey, "member-outcomes.tsv's header no longer carries the pairing query this header points at");
-  assert.equal(
-    MEMBER_COLUMNS[pairKey[2] - 1],
-    "run_date",
-    "the pairing query's distinct-date count is not member-outcomes.tsv's `run_date`",
-  );
-  assert.ok(
-    block.includes(pairKey[0]),
-    `the header cites an idiom for the pairing query's date key that member-outcomes.tsv no longer uses (\`${pairKey[0]}\`)`,
-  );
-
-  // The header also cites the query's distinct-date ACCUMULATOR
-  // (`length(r)`) — resolve the variable name against the query's own
-  // `length(...)` call rather than trusting the header's word for it.
-  const pairAccumulator = /print n\+0, length\((\w+)\)/.exec(pairQueryBlock);
-  assert.ok(pairAccumulator, "member-outcomes.tsv's pair query no longer prints its distinct-date count via `length(...)`");
-  assert.ok(
-    block.includes(`length(${pairAccumulator[1]})`),
-    `the header cites the wrong accumulator for the pairing query's distinct-date count (expected \`length(${pairAccumulator[1]})\`)`,
-  );
+  // The gate half: the count lives in cell-readout.mjs and dates each
+  // comparison off the OTHER file's `run_date`. Run, not read: one comparison
+  // whose ticket-features date and member-outcomes date differ, and the date
+  // the readout counts must be the member-outcomes one. If the readout ever
+  // keys its dates elsewhere, "it comes from there" stops being true.
+  const session = "s-tier-hdr";
+  const pull = (agent, chosen_cell) => ({ run_date: "2026-01-01", session, agent, chosen_cell });
+  const member = (agent, cell, model) => ({
+    session, agent, run_date: "2026-02-02", model, effort: "high", subagentType: `fleet-implementer-${cell}`,
+  });
+  const { cells: [task] } = readout({
+    features: [pull("impl-1", "task-high"), pull("impl-2", "slow-high")],
+    members: [member("impl-1", "task-high", "m-task"), member("impl-2", "slow-high", "m-slow")],
+  });
+  assert.deepEqual([task.cell, task.comparisons, task.runDates], ["task-high", 1, 1]);
+  assert.deepEqual([...task.dates], ["2026-02-02"], "cell-readout.mjs no longer dates a comparison by member-outcomes.tsv's `run_date`");
+  assert.match(block, /`plugin\/scripts\/cell-readout\.mjs`/);
+  assert.match(block, /`docs\/metrics\/member-outcomes\.tsv`/);
 
   // The DERIVED half as code, not prose: the date comes off a transcript
   // mtime. A scraper switched to a clock read would make this header's
@@ -528,16 +502,17 @@ test("the header's `run_date` source claims still hold against the query, the sc
   // writes to the day it ran.
 
   // The floor's numbers, as the paragraph quotes them. It names figures it
-  // does not own; a threshold changed in SKILL.md alone leaves this header
-  // quietly citing the old one.
+  // does not own; a threshold changed in SKILL.md or in the readout alone
+  // leaves this header quietly citing the old one.
   assert.match(
     unemphasized(RUN_TEAM),
     phrase("there are at least ten of them across five or more distinct `run_date`s"),
-    "SKILL.md's pairing floor is no longer ten pairs across five dates — the header quotes those numbers",
+    "SKILL.md's per-cell floor is no longer ten comparisons across five dates — the header quotes those numbers",
   );
+  assert.deepEqual({ ...GATE }, { comparisons: 10, runDates: 5 }, "cell-readout.mjs's gate is no longer ten across five — the header quotes those numbers");
   assert.match(
     block,
-    phrase("at least ten within-run pairs across five or more"),
-    "the header no longer states the pairing floor it attributes to the other file",
+    phrase("at least ten comparisons across five or more"),
+    "the header no longer states the per-cell floor it attributes to the other file",
   );
 });

package/skills/run-team/SKILL.md

@@ -1125,31 +1125,29 @@ Pull is one member, so a rate counted per Pull is a rate counted per member —
 one implementer in five, however the Pulls fall across the run — and the
 ledger, not your memory, is what still holds the count after a compaction.
 
-**Do not label it anywhere — the dispatch record already carries it.** The
-pairing is a query over `docs/metrics/member-outcomes.tsv` (the exact awk sits
-in that file's header): a `session` that ran BOTH pre-cutover implementer
-definitions at DIFFERENT `model`s — one member whose `subagent_type` is
-`fleet-implementer-alt`, another whose is `fleet-implementer`. Neither
-definition is dispatched any more, so the query counts pre-cutover history
-only: a session whose implementers ran as `fleet-implementer-<cell>` is not in
-it until #2133 replaces it with the per-cell readout. That column is
-the record of what each member was dispatched AS, scraped like every other
-column, so it survives the file's regeneration and mislabels no historical row
-— a pre-rule session carries no such dispatch to find. A hand-set column would
-fail both of those tests, and one derived against today's declared tiers would
-mislabel every historical row.
-
-**The query counts DELIBERATE pairs, and that is the whole of #1066.** The
-rule this replaces asked only for a `session`+`role` carrying more than one
-distinct `model`, which any session that happened to stage a routine ticket
-beside a correction one satisfies. Measured 2026-09-12 on one corpus: 198
-keys as that query is literally written, 35 sessions across 21 `run_date`s
-once restricted to implementers, against 17 real pairs across 8 — so the gate
-below read itself past its floor on sessions where nothing had been
-controlled. Dispatch alone is not enough either: both arms must actually have
-RUN different models, because a deliberate alt dispatch whose two arms resolve
-to the same model (a `modelRoles` override, measured on omp 2026-09-12)
-controls nothing.
+**Do not label it anywhere — the dispatch record already carries it.** A
+cell's comparisons are a query, and `cell-readout.mjs` is that query: it joins
+`docs/metrics/ticket-features.tsv`, whose `chosen_cell` names the cell the
+router chose, to `docs/metrics/member-outcomes.tsv` on `session`+`agent`, and
+admits a row only when its `subagent_type` is that cell's
+`fleet-implementer-<cell>` definition and its `effort` is the cell's level.
+That column is the record of what each member was dispatched AS, scraped like
+every other column, so it survives the file's regeneration and mislabels no
+historical row — the pre-cutover `fleet-implementer` and
+`fleet-implementer-alt` rows are no cell's, and the readout never admits them.
+A hand-set column would fail both of those tests, and one derived against
+today's declared tiers would mislabel every historical row.
+
+**The readout counts DELIBERATE comparisons.** An earlier rule asked
+only for a `session`+`role` carrying more than one distinct `model`, which any
+session that happened to stage a routine ticket beside a correction one
+satisfies. Measured 2026-09-12 on one corpus: 198 keys as that query was
+literally written, 35 sessions across 21 `run_date`s once restricted to
+implementers, against 17 real pairs across 8 — so the gate below read itself
+past its floor on sessions where nothing had been controlled. Dispatch alone
+is not enough either: the two rows must actually have RUN a different model or
+effort, because a deliberate dispatch whose two sides resolve to the same model
+(a `modelRoles` override, measured on omp 2026-09-12) controls nothing.
 
 **Why one in five within the run, not a week of one tier then a week of the other:**
 tier would then be confounded with calendar date and therefore with prompt
@@ -1397,11 +1395,14 @@ pooled across cells, and stop until
 there are at least ten of them across five or more distinct `run_date`s; below
 that, a comparison count is a number, not evidence, and the last guard fired
 with n=1 on the control side. **Report the count the per-cell readout prints,
-never one from any other query:** until that readout exists there is no count
-to report, the pair query in `member-outcomes.tsv`'s header counts pre-cutover
-pairs only, which are no cell's comparisons, and the query before that one
-counted every session whose implementers merely differed, so it cleared this
-floor by an order of magnitude while the controlled comparison did not exist yet.
+never one from any other query:** `~/.fleet/bin/fleet-run cell-readout.mjs`
+prints `<cell> <comparisons> <run_dates> <resolved models>` for each cell past
+that floor and a cell below it only as a count on stderr; a `mixed (…)` models
+column means the cell's history spans more than one model behind its role.
+The pre-cell pair query counted pairs that are no cell's comparisons, and the
+query before that one counted every session whose implementers merely
+differed, so it cleared this floor by an order of magnitude while the
+controlled comparison did not exist yet.
 
 Why the agent body carries what it does — read this before editing any
 `fleet-implementer-<cell>` file, and keep every cell's body byte-identical. Each rule in the body's