@feigi/fleet-ctl 3.21.13 → 3.22.1

package/scripts/fleet-tick.test.mjs

@@ -452,7 +452,7 @@ const pr = (number, labels = [], closes = [number + 1000], headRefOid = HEAD_B)
   closingIssuesReferences: closes.map((n) => ({ number: n })),
   headRefOid,
 });
-const run = (ledger, prs = [], closed) => deriveRun({ rows: [], dispatched: [], drain: null, ...ledger }, prs, closed);
+const run = (ledger, prs = [], closed, finished) => deriveRun({ rows: [], dispatched: [], drain: null, ...ledger }, prs, closed, finished);
 
 test("deriveRun: live implementers are the unsettled impl- tokens — the #1692 shape, read rather than recited", () => {
   // #1692 was two sources disagreeing about the same fleet. There is one
@@ -506,6 +506,44 @@ test("deriveRun: live names every unsettled member and each in-flight review by
   assert.deepEqual(r.live, ["fix-pr-21", "impl-15", "review:PR#20"], "run2 returned and run3 is dead, so neither is live");
 });
 
+// A review whose own `reviewed=` write never landed stays in flight in the
+// ledger forever. The ledger cannot say the PR has since merged; the caller's
+// probe can, and hands the merged or closed PR numbers to the fold.
+const ZOMBIE_ROWS = [20, 21, 22].map((n) => `#${n - 10} impl-${n - 10}=PR#${n} → PR#${n} · review=member:review-pr-${n}`);
+
+test("deriveRun: an in-flight review whose PR has left the open list is named for a probe, and still counts until the probe answers", () => {
+  const r = run({ rows: ZOMBIE_ROWS }, [pr(21)]);
+  assert.deepEqual(r.reviewsOffList, [20, 22], "only the in-flight reviews of PRs not on the open list");
+  assert.equal(r.reviewsLive, 3, "no probe answer: fail closed, every one still reads as live");
+  assert.deepEqual(r.live, ["review:PR#20", "review:PR#21", "review:PR#22"]);
+});
+
+test("deriveRun: reviewsOffList is ascending whatever order the ledger rows arrive in", () => {
+  const r = run({ rows: [...ZOMBIE_ROWS].reverse() }, [pr(21)]);
+  assert.deepEqual(r.reviewsOffList, [20, 22], "rows arrive 22, 21, 20: the sort, not ledger order, makes it ascending");
+});
+
+test("deriveRun: a review in flight on a PR the caller found merged or closed is not live", () => {
+  const r = run({ rows: ZOMBIE_ROWS }, [pr(21)], undefined, new Set([20, 22]));
+  assert.equal(r.reviewsLive, 1, "only PR 21's review, on the open list, is live");
+  assert.deepEqual(r.live, ["review:PR#21"]);
+});
+
+test("deriveRun: a review in flight on an OPEN PR is live whatever the finished set says", () => {
+  // A probe answer that contradicts the open list is not trusted to retire a
+  // review: the open list is the fold's own read of which PRs are open.
+  const r = run({ rows: ZOMBIE_ROWS }, [pr(20), pr(21), pr(22)], undefined, new Set([20, 21, 22]));
+  assert.equal(r.reviewsLive, 3);
+  assert.deepEqual(r.reviewsOffList, []);
+});
+
+test("deriveRun: a finished PR's returned review and settled members read as before", () => {
+  const rows = [...ZOMBIE_ROWS, "#40 impl-40=PR#50 → PR#50 · review=member:review-pr-50 reviewed=abc1234:0/0/0"];
+  const r = run({ rows }, [], undefined, new Set([20, 21, 22, 50]));
+  assert.deepEqual([r.reviewsLive, r.reviewsOffList, r.live], [0, [20, 21, 22], []]);
+  assert.deepEqual(r.reviewed.map((x) => x.pr), [50], "the returned review is still on record");
+});
+
 test("deriveRun: fix-pr is due on a returned review with survivors and no fix-applier since", () => {
   const r = run({
     rows: [
@@ -1267,7 +1305,9 @@ test("CLI: every synchronous spawn in this file goes through spawnBounded (#2320
 });
 
 // `pr list` for the open PRs, `issue view` for a behind-issue premise's state,
-// `issue list --label in-progress` for the stall report's claimed count.
+// `pr view` for the state of a PR an in-flight review names that is no longer
+// on the open list, `issue list --label in-progress` for the stall report's
+// claimed count.
 const GH_STUB = `#!/bin/sh
 case "$1 $2" in
   "pr list") [ -n "$PR_FAIL" ] && { echo "boom" >&2; exit 1; }; cat "$FIXTURE_PRS" ;;
@@ -1280,6 +1320,15 @@ case "$1 $2" in
     # scrub them lifts an exclusion the case's own repository still holds.
     [ -n "$GIT_DIR$GIT_WORK_TREE$GH_REPO" ] && { echo '{"state":"CLOSED"}'; exit 0; }
     exec jq -c --arg n "$3" '{state: (.[$n] // error("no such issue"))}' "$FIXTURE_ISSUE_STATES" ;;
+  "pr view")
+    echo "$3" >> "$PR_VIEW_LOG"
+    [ -n "$PR_VIEW_FAIL" ] && { echo "gh: pr view failed" >&2; exit 1; }
+    [ -n "$PR_VIEW_BODY" ] && { printf '%s\n' "$PR_VIEW_BODY"; exit 0; }
+    # Real gh answers for the repository an inherited GIT_DIR or GH_REPO names;
+    # this one answers MERGED for every PR there, so a probe that forgot to
+    # scrub them retires a review the case's own repository still holds.
+    [ -n "$GIT_DIR$GIT_WORK_TREE$GH_REPO" ] && { echo '{"state":"MERGED"}'; exit 0; }
+    exec jq -c --arg n "$3" '{state: (.[$n] // error("no such pull request"))}' "$FIXTURE_PR_STATES" ;;
   "issue list")
     [ -n "$CLAIMED_FAIL" ] && { echo "boom" >&2; exit 1; }
     expr=""
@@ -1320,7 +1369,7 @@ const shortlistText = (ns, scanned = ns.length) => JSON.stringify({ scanned, sho
 // through info/exclude so no tracked file says so.
 function runCli(args = [], {
   prs = [], ledger, shortlist, refresh = shortlistText([]), refreshFail = false,
-  issueStates = {}, claimed = [], env: extraEnv = {}, defaultState = false, keep = false, beforeRun = () => {},
+  issueStates = {}, prStates = {}, claimed = [], env: extraEnv = {}, defaultState = false, keep = false, beforeRun = () => {},
   baseline = true, afterBaseline = () => {},
 } = {}) {
   // On macOS tmpdir() is /var -> /private/var; resolving it up front makes
@@ -1355,6 +1404,7 @@ function runCli(args = [], {
     afterBaseline(repo);
     const refreshLog = fx("refresh.log", "");
     const issueViewLog = fx("issue-view.log", "");
+    const prViewLog = fx("pr-view.log", "");
     // Every case gets its own state file unless it names one: the default path
     // resolves against the git common dir, and a shared streak and digest would
     // make the fold cases order-dependent. `defaultState` opts out for the case
@@ -1367,14 +1417,16 @@ function runCli(args = [], {
         FIXTURE_PRS: fx("prs.json", JSON.stringify(prs)),
         FIXTURE_CLAIMED: fx("claimed.json", JSON.stringify(claimed)),
         FIXTURE_ISSUE_STATES: fx("issue-states.json", JSON.stringify(issueStates)),
+        FIXTURE_PR_STATES: fx("pr-states.json", JSON.stringify(prStates)),
         FIXTURE_REFRESH: fx("refresh.json", refresh),
-        REFRESH_LOG: refreshLog, ISSUE_VIEW_LOG: issueViewLog,
+        REFRESH_LOG: refreshLog, ISSUE_VIEW_LOG: issueViewLog, PR_VIEW_LOG: prViewLog,
         ...(refreshFail ? { REFRESH_FAIL: "1" } : {}),
         ...extraEnv,
       },
     });
     r.refreshed = readFileSync(refreshLog, "utf8").split("\n").filter(Boolean).length;
     r.issueViews = readFileSync(issueViewLog, "utf8").split("\n").filter(Boolean);
+    r.prViews = readFileSync(prViewLog, "utf8").split("\n").filter(Boolean);
     r.repo = repo;
     r.dir = dir;
     returned = true;
@@ -1843,6 +1895,82 @@ test("CLI: an inherited GIT_DIR cannot retarget the behind-issue premise probe",
   assert.equal(r.refreshed, 0, "#9 is OPEN in the case's own repository — the exclusion stands");
 });
 
+// A review whose `reviewed=` write never landed stays in flight in the ledger
+// after its PR merges. Each such row holds one reviewer slot unless the tick
+// asks gh about the PR and finds it finished.
+const zombieRows = (numbers) => numbers.map((n) => `#${n - 90} impl-${n - 90}=PR#${n} → PR#${n} · review=member:review-pr-${n}`);
+const ZOMBIES = Array.from({ length: 10 }, (_, i) => 101 + i);
+const REVIEW_DUE = pr(500, [], [1500], HEAD_B);
+const CAPS = ["--reviewer-cap", "10", "--max-reviews", "10"];
+
+test("CLI: dangling in-flight reviews of merged PRs do not starve review dispatch", () => {
+  const r = runCli(CAPS, {
+    shortlist: shortlistText([]), prs: [REVIEW_DUE], ledger: { rows: zombieRows(ZOMBIES) },
+    prStates: Object.fromEntries(ZOMBIES.map((n) => [n, "MERGED"])),
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.prViews.map(Number).sort((a, b) => a - b), ZOMBIES, "each off-list PR is asked about");
+  assert.match(r.stdout, /^reviewers +0\/10 → DISPATCH review PR#500/m);
+});
+
+test("CLI: a CLOSED PR's dangling review is released too", () => {
+  const r = runCli(["--reviewer-cap", "1", "--max-reviews", "1"], {
+    shortlist: shortlistText([]), prs: [REVIEW_DUE], ledger: { rows: zombieRows([101]) }, prStates: { 101: "CLOSED" },
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /^reviewers +0\/1 → DISPATCH review PR#500/m);
+});
+
+test("CLI: an in-flight review on an open PR keeps its slot and is never probed", () => {
+  const r = runCli(["--reviewer-cap", "1", "--max-reviews", "1"], {
+    shortlist: shortlistText([]), prs: [pr(101, [], [1101]), REVIEW_DUE], ledger: { rows: zombieRows([101]) },
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.prViews, [], "an open PR needs no probe");
+  assert.match(r.stdout, /^reviewers +1\/1 → AT CAP/m);
+  assert.doesNotMatch(r.stdout, /DISPATCH review/);
+});
+
+test("CLI: a PR off the open list that gh still calls OPEN keeps its review's slot", () => {
+  const r = runCli(["--reviewer-cap", "1", "--max-reviews", "1"], {
+    shortlist: shortlistText([]), prs: [REVIEW_DUE], ledger: { rows: zombieRows([101]) }, prStates: { 101: "OPEN" },
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.prViews, ["101"]);
+  assert.match(r.stdout, /^reviewers +1\/1 → AT CAP/m);
+  assert.doesNotMatch(r.stdout, /DISPATCH review/);
+});
+
+test("CLI: a PR gh cannot answer for is not read as merged - the slot is held and the failure disclosed", () => {
+  const cases = [
+    ["a nonzero exit", { PR_VIEW_FAIL: "1" }, /gh pr view 101 exited 1: gh: pr view failed/],
+    ["a reply with no state", { PR_VIEW_BODY: "<html>proxy error</html>" }, /gh pr view 101 printed no PR state/],
+    ["a state that is not MERGED or CLOSED", { PR_VIEW_BODY: JSON.stringify({ state: "merged" }) }, /gh pr view 101 printed no PR state/],
+  ];
+  for (const [what, env, shown] of cases) {
+    const r = runCli(["--reviewer-cap", "1", "--max-reviews", "1"], {
+      shortlist: shortlistText([]), prs: [REVIEW_DUE], ledger: { rows: zombieRows([101]) }, prStates: { 101: "MERGED" }, env,
+    });
+    assert.equal(r.status, 0, `${what}: ${r.stderr}`);
+    assert.match(r.stderr, shown, what);
+    assert.match(r.stdout, /^reviewers +1\/1 → AT CAP/m, what);
+    assert.doesNotMatch(r.stdout, /DISPATCH review/, what);
+  }
+});
+
+test("CLI: an inherited GIT_DIR cannot retarget the merged-PR review probe", (t) => {
+  const decoy = realpathSync(mkdtempSync(join(tmpdir(), "fleet-tick-decoy-pr-")));
+  t.after(() => rmSync(decoy, { recursive: true, force: true }));
+  spawnBounded("git", ["init", "-q", decoy]);
+  const r = runCli(["--reviewer-cap", "1", "--max-reviews", "1"], {
+    shortlist: shortlistText([]), prs: [REVIEW_DUE], ledger: { rows: zombieRows([101]) }, prStates: { 101: "OPEN" },
+    env: { GIT_DIR: join(decoy, ".git"), GH_REPO: "someone/else" },
+  });
+  assert.equal(r.status, 0, r.stderr);
+  assert.deepEqual(r.prViews, ["101"], "the probe must still run");
+  assert.match(r.stdout, /^reviewers +1\/1 → AT CAP/m, "101 is OPEN in the case's own repository - its review keeps the slot");
+});
+
 // #2210, end to end: a real repo, a real baseline, a real stray write.
 const LIVE = {
   ledger: { rows: ["#412 impl-412 · tier-ok=impl-412:fleet-implementer"], dispatched: ["impl-412"] },

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",
   );
 });