@feigi/fleet-ctl 3.21.13 → 3.22.1

package/package.json

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

package/scripts/ambient-git-vars-mjs-prose.test.mjs

@@ -201,8 +201,8 @@ const COVERED_MJS = {
   // children (`node candidates.mjs`, `node ledger.mjs`, `sh inflight.sh`)
   // name no git.
   "shortlist.mjs": 2,
-  // THREE. The first two are the pair shortlist.mjs carries (#1803), the
-  // third is below (#2485). `shortlistPath()`'s
+  // FOUR. The first two are the pair shortlist.mjs carries (#1803), the
+  // third is below (#2485), the fourth after it. `shortlistPath()`'s
   // `--git-common-dir` probe names the `.fleet/shortlist.json` the tick PULLs
   // from; an ambient GIT_DIR would read another repository's shortlist and
   // name its tickets. Measured in fleet-tick.test.mjs, "an ambient GIT_DIR
@@ -216,7 +216,11 @@ const COVERED_MJS = {
   // implementer's ticket is already closed, and resolves the repository the
   // same way; measured in fleet-tick.test.mjs, "an inherited GIT_DIR cannot
   // retarget the tier-mismatch closed-ticket probe".
-  "fleet-tick.mjs": 3,
+  // `finishedReviewPrs()`'s `gh pr view` asks whether a PR with a dangling
+  // in-flight review is already merged or closed, and resolves the repository
+  // the same way; measured in fleet-tick.test.mjs, "an inherited GIT_DIR
+  // cannot retarget the merged-PR review probe".
+  "fleet-tick.mjs": 4,
   // ONE spawn primitive, `git(args, cwd)`, behind both of the file's git calls
   // — `resolveMainRoot()`'s `rev-parse --git-common-dir` and `checkIgnored()`'s
   // `check-ignore` (#1411). An ambient GIT_DIR would answer the first for

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/fleet-tick.mjs

@@ -39,7 +39,10 @@
 //             merge queue, and which PRs are owed a review. Also, for each ticket
 //             holding the implementer row on a tier mismatch, whether its issue
 //             is CLOSED (`gh issue view`, #2485): a closed ticket's mismatch
-//             holds nothing.
+//             holds nothing. And, for each in-flight `review=` token whose PR
+//             the open list does not carry, whether that PR is MERGED or
+//             CLOSED (`gh pr view`): a review cannot be running against a
+//             finished PR, so its dangling token holds no reviewer slot.
 //   main      The main checkout against the run-start baseline
 //             `.fleet/main-checkout.sha`, through main-checkout.mjs (#2210).
 //             Anything but `clean` — dirty, unknown, no baseline — prints one
@@ -496,7 +499,7 @@ export function unlabelledFinishers(ledger, unqueued) {
     .map((u) => ({ pr: u.pr, labelled: u.attempts.filter((a) => a.outcome === "labelled").map((a) => a.name) }));
 }
 
-export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set()) {
+export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set(), finished = new Set()) {
   // One entry per member name across `## Dispatched` and every row. A member
   // settled ANYWHERE is settled: `settle` is the only writer of an outcome, and
   // a bare copy beside it is what a whole-line `row` rewrite leaves behind.
@@ -752,11 +755,23 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set())
   // head that review read, and there is nothing more to review.
   const pastPinDue = (st, head) => st !== undefined && st.pastPinHalt && !st.inFlight && st.reviewedHead !== null
     && !String(head).toLowerCase().startsWith(st.reviewedHead);
+  // A `review=` token with no `reviewed=` after it reads as in flight, and the
+  // ledger alone never says otherwise: a review whose own `reviewed=` write
+  // never landed stays in flight after its PR merges, holding a reviewer slot
+  // for good. `finished` is the PR numbers the caller has found MERGED or
+  // CLOSED, and a finished PR has no review running against it. A PR on the
+  // open list is open whatever `finished` says, and none is the default, so a
+  // PR nobody has asked about keeps its review live.
+  const reviewing = [...byPr.entries()].filter(([, st]) => st.inFlight);
+  const liveReviews = reviewing.filter(([n]) => open.has(n) || !finished.has(n));
   return {
     implLive: live("impl"),
     fixLive: live("fix-pr"),
     mergeBotLive: live("merge-bot"),
-    reviewsLive: [...byPr.values()].filter((st) => st.inFlight).length,
+    reviewsLive: liveReviews.length,
+    // The in-flight reviews of PRs the open list does not carry: the ones
+    // `finished` could retire, so the caller asks gh about these and no others.
+    reviewsOffList: reviewing.filter(([n]) => !open.has(n)).map(([n]) => n).sort(asc),
     // A returned review whose survivors no review fix-applier has answered,
     // a conflict hold no fix-applier has cleared, or a dispositions mismatch
     // no retry has answered — on a PR still open, with no fix-applier working
@@ -824,7 +839,7 @@ export function deriveRun({ rows, dispatched, drain }, prs, closed = new Set())
     // run carries no member token of its own.
     live: [
       ...all.filter((m) => m.outcome === null).map((m) => m.name),
-      ...[...byPr.entries()].filter(([, st]) => st.inFlight).map(([n]) => `review:PR#${n}`),
+      ...liveReviews.map(([n]) => `review:PR#${n}`),
     ],
   };
 }
@@ -1106,6 +1121,31 @@ function closedTickets(mismatched) {
   return closed;
 }
 
+// The PRs, of those whose review the ledger reads as in flight yet the open
+// list does not carry, that gh says are MERGED or CLOSED. A review cannot be
+// running against a finished PR, so the ledger's dangling `review=` token must
+// not hold a reviewer slot for good. A probe that cannot answer — a nonzero
+// exit, a reply carrying no state, a state that is none of the three — is
+// disclosed and the review keeps its slot: an unreadable state is never read
+// as finished. A PR gh calls OPEN keeps it quietly.
+function finishedReviewPrs(offList) {
+  const finished = new Set();
+  for (const number of offList) {
+    const r = spawnSync("gh", ["pr", "view", String(number), "--json", "state"], { encoding: "utf8", env: gitEnv({ GH_REPO: "" }) });
+    if (r.error || r.status !== 0) {
+      console.error(`${NAME}: ${failure(r, `gh pr view ${number}`)} — review on PR#${number} unconfirmed finished, its slot stands`);
+      continue;
+    }
+    let st = null;
+    try { st = JSON.parse(r.stdout).state; } catch { /* no state: disclosed below */ }
+    if (st === "MERGED" || st === "CLOSED") finished.add(number);
+    else if (st !== "OPEN") {
+      console.error(`${NAME}: gh pr view ${number} printed no PR state — review on PR#${number} unconfirmed finished, its slot stands`);
+    }
+  }
+  return finished;
+}
+
 // shortlist.mjs, run by the tick itself (§ 6 §3). Its per-ticket stderr is
 // captured and dropped rather than billed to the controller's context; only a
 // failure's last line rides along.
@@ -1166,7 +1206,8 @@ function main() {
     const ledger = readLedger();
     run = deriveRun(ledger, prs);
     const closed = closedTickets(run.tierMismatch);
-    if (closed.size) run = deriveRun(ledger, prs, closed);
+    const finished = finishedReviewPrs(run.reviewsOffList);
+    if (closed.size || finished.size) run = deriveRun(ledger, prs, closed, finished);
   } catch (e) {
     if (e instanceof LedgerError) die(e.message);
     throw e;