@feigi/fleet-ctl 3.20.0 → 3.21.1

package/package.json

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

@@ -255,6 +255,18 @@ const COVERED_MJS = {
   // cache reader child gets the same env but unsets both itself, so no
   // fixture can tell its env apart.
   "recipe-prove.mjs": 1,
+  // TWO scrubbed children. `defaultGuardPath()`'s `rev-parse --git-common-dir`
+  // names the workspace the guard file is written into: an ambient GIT_DIR
+  // would answer for ANOTHER repository, and the verdict would land in its
+  // `.fleet/` at exit 0 while fleet-tick reads this one's. Measured in
+  // pr-cost.test.mjs, "an ambient GIT_DIR naming another repository cannot move
+  // the guard file out of the repository pr-cost runs in". The `gh pr list`
+  // child is the second: gh's remote resolution follows GIT_DIR too (measured
+  // for shortlist.mjs's `probeState()` above), so merged state could be read
+  // for another repository's PRs; the gh stub in pr-cost.test.mjs, "an ambient
+  // GIT_DIR does not reach the gh child that reads merged state", records
+  // that the child sees no GIT_DIR.
+  "pr-cost.mjs": 2,
 };
 
 // The two-name-only exemption list #1599's second design question answers

package/scripts/fleet-tick.mjs

@@ -45,6 +45,12 @@
 //             Anything but `clean` — dirty, unknown, no baseline — prints one
 //             MAIN-CHECKOUT-* line and holds every dispatching row until the
 //             maintainer clears it; it never refuses the tick.
+//   guard     `.fleet/cost-guard.json` beside the shortlist, pr-cost.mjs
+//             --guard's verdict on the implementer cells. Printed as the
+//             `router` row and never acted on here: a missing or unreadable
+//             file reads DEFAULT-ONLY, the way the router (not in the tree
+//             yet; ADR 0016) is to read it. pr-cost.mjs writes the main
+//             workspace's file by default, the one read here.
 //
 // The pure half below is `reconcile()` over the counts `deriveRun()` reads off
 // the ledger; main() does the I/O. Split so the guard table and the reading are
@@ -61,7 +67,7 @@ import { parseMember, parseToken } from "./ledger-grammar.mjs";
 // reads what they leave: the slots this tick's own dispatches fill.
 export function reconcile(s) {
   const rev = reviewers(s);
-  return [...mainCheckoutHold(s, [implementers(s, rev.left), ...rev.rows, mergeBot(s)]), ...shortlistRows(s)];
+  return [...mainCheckoutHold(s, [implementers(s, rev.left), ...rev.rows, mergeBot(s)]), ...shortlistRows(s), ...routerRows(s)];
 }
 
 // #2210: a main checkout changed since the run's baseline — or one the tick
@@ -254,6 +260,59 @@ function shortlistRows(s) {
   }];
 }
 
+// The cost guard's verdict, as pr-cost.mjs --guard wrote it: OK, DEFAULT-ONLY
+// (a cell tripped, or no readable guard file — the router then runs the
+// default cell alone), or NO VERDICT (the baseline is short of its n). The
+// controller has nothing to do about any of them inside a run, so the row
+// never acts; it is here so the verdict is printed by code, not recalled.
+// Every verdict carries the guard's own `computed_at`: a refresh that failed
+// leaves the old file on disk, and only its age says the OK is not current.
+// No `router` state at all (a caller that read no guard) prints no row.
+export function routerRows(s) {
+  const g = s.router;
+  if (g === undefined) return [];
+  const row = (action, detail) => [{ role: "router", action, acts: false, detail }];
+  const run = "run pr-cost.mjs --guard";
+  if (g.status === "missing") return row("DEFAULT-ONLY", `cost-guard.json missing — ${run}`);
+  if (g.status !== "ok") return row("DEFAULT-ONLY", `cost-guard.json unreadable (${g.why}) — ${run}`);
+  const { baseline: b, cells, tripped, verdict, min_n: minN, computed_at: computed } = g.guard;
+  const age = `guard computed ${computed}`;
+  if (verdict === "none") return row("NO VERDICT", `baseline n=${b.n}/${minN}; ${age}`);
+  const pct = (x) => (x === null ? "n/a" : `${Math.round(x * 100)}%`);
+  const usd = (x) => (x === null ? "n/a" : `$${x.toFixed(2)}`);
+  const vs = (c) => `${c.cell} ${usd(c.mean_usd)} vs ${usd(b.mean_usd)}, fail ${pct(c.fail_rate)} vs ${pct(b.fail_rate)}, n=${c.n}/${b.n}`;
+  if (verdict === "tripped") {
+    const retired = g.guard.retire ? "; every non-default stage-1 cell tripped — the router retires" : "";
+    return row("DEFAULT-ONLY", `cost guard: ${cells.filter((c) => tripped.includes(c.cell)).map(vs).join("; ")}${retired}; ${age}`);
+  }
+  const others = cells.filter((c) => c.cell !== b.cell);
+  return row("OK", `${others.length ? others.map(vs).join("; ") : `baseline ${b.cell} ${usd(b.mean_usd)}, n=${b.n}`}; ${age}`);
+}
+
+// pr-cost.mjs's guard file, read as the router is to read it: anything but a
+// well-formed, self-consistent verdict is not one.
+export function readCostGuard(path) {
+  if (path === null) return { status: "missing" };
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (e) {
+    return e.code === "ENOENT" ? { status: "missing" } : { status: "unreadable", why: e.code ?? e.message };
+  }
+  let guard;
+  try { guard = JSON.parse(text); } catch { return { status: "unreadable", why: "not JSON" }; }
+  const cellShaped = (c) => c && typeof c.cell === "string" && Number.isInteger(c.n)
+    && (c.mean_usd === null || typeof c.mean_usd === "number") && (c.fail_rate === null || typeof c.fail_rate === "number");
+  const ok = guard && ["ok", "tripped", "none"].includes(guard.verdict) && typeof guard.computed_at === "string"
+    && cellShaped(guard.baseline) && Array.isArray(guard.cells) && guard.cells.every(cellShaped) && Number.isInteger(guard.min_n)
+    && Array.isArray(guard.tripped) && guard.tripped.every((c) => typeof c === "string")
+    // The verdict is "tripped" exactly when a cell is named, and only a reported cell can be named.
+    && (guard.verdict === "tripped") === (guard.tripped.length > 0)
+    && guard.tripped.every((c) => guard.cells.some((x) => x.cell === c))
+    && (guard.retire === undefined || typeof guard.retire === "boolean");
+  return ok ? { status: "ok", guard } : { status: "unreadable", why: "not a guard verdict" };
+}
+
 export function formatLines(rows) {
   const w = Math.max(...rows.map((r) => r.role.length));
   return rows.map((r) => r.actual === undefined
@@ -1086,7 +1145,10 @@ function claimed() {
 
 function main() {
   const { fold, state: path, ...caps } = options();
-  const current = readShortlist(shortlistPath());
+  const listPath = shortlistPath();
+  const current = readShortlist(listPath);
+  // Beside the shortlist, off the same git probe rather than a second one.
+  const router = readCostGuard(listPath === null ? null : join(dirname(listPath), "cost-guard.json"));
 
   // The PRIOR run's liveness, before anything that can refuse — #1597. The gh
   // read and the ledger read below both exit 2 on failure, and a stall
@@ -1142,7 +1204,7 @@ function main() {
   const mainCheckout = checkMainCheckout();
 
   const rows = reconcile({
-    ...caps, ...run, heads, supply, shortlistStatus: current.status, refresh: fresh, mainCheckout,
+    ...caps, ...run, heads, supply, shortlistStatus: current.status, refresh: fresh, mainCheckout, router,
   });
   const said = describe(mainCheckout, run.live);
   const lines = [...(said === null ? [] : [said]), ...formatLines(rows)];

package/scripts/fleet-tick.test.mjs

@@ -278,6 +278,93 @@ test("no refresh, no shortlist row", () => {
   assert.deepEqual(reconcile(state()).map((r) => r.role), ["implementers", "reviewers", "merge-bot"]);
 });
 
+// ---------------------------------------------------------------------------
+// The router row: pr-cost.mjs --guard's verdict, read off a guard file the way
+// the tick reads it. One case per state, each against a fixture file.
+
+import { routerRows, readCostGuard } from "./fleet-tick.mjs";
+
+const BASE = { cell: "slow-high", n: 31, mean_usd: 31, fail_rate: 0.29 };
+const guardJson = (over = {}) => JSON.stringify({
+  computed_at: "2026-10-03T00:00:00.000Z", window_start: "2026-10-03", baseline: BASE,
+  cells: [{ cell: "slow-high", n: 31, mean_usd: 31, fail_rate: 0.29 }, { cell: "task-high", n: 24, mean_usd: 12.3, fail_rate: 0.25 }],
+  tripped: [], verdict: "ok", retire: false, min_n: 20, ...over,
+});
+function routerRowOf(text) {
+  const dir = mkdtempSync(join(tmpdir(), "fleet-tick-guard-"));
+  try {
+    const path = join(dir, "cost-guard.json");
+    if (text !== null) writeFileSync(path, text);
+    const rows = reconcile(state({ router: readCostGuard(path) }));
+    assert.equal(actionable(rows), false, "no router state is work for the controller");
+    const r = rows.filter((x) => x.role === "router");
+    assert.equal(r.length, 1);
+    assert.equal(rows.at(-1), r[0], "the router row prints last");
+    return { ...r[0], line: formatLines(rows).at(-1) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test("router: a guard with no cell tripped is OK, naming each cell against the baseline", () => {
+  const r = routerRowOf(guardJson());
+  assert.equal(r.action, "OK");
+  assert.equal(r.acts, false);
+  assert.equal(r.line, "router       → OK   (task-high $12.30 vs $31.00, fail 25% vs 29%, n=24/31; guard computed 2026-10-03T00:00:00.000Z)");
+});
+
+test("router: the row carries the guard's own computed_at, so a stale OK reads as old", () => {
+  const r = routerRowOf(guardJson({ computed_at: "2026-09-01T08:00:00.000Z" }));
+  assert.equal(r.action, "OK");
+  assert.match(r.detail, /; guard computed 2026-09-01T08:00:00\.000Z$/);
+});
+
+test("router: a tripped cell is DEFAULT-ONLY, naming the cost guard and the cell it tripped", () => {
+  const r = routerRowOf(guardJson({
+    verdict: "tripped", tripped: ["smol-high"],
+    cells: [{ ...BASE }, { cell: "smol-high", n: 21, mean_usd: 9.5, fail_rate: 0.45 }, { cell: "task-high", n: 24, mean_usd: 12.3, fail_rate: 0.25 }],
+  }));
+  assert.equal(r.action, "DEFAULT-ONLY");
+  assert.equal(r.detail, "cost guard: smol-high $9.50 vs $31.00, fail 45% vs 29%, n=21/31; guard computed 2026-10-03T00:00:00.000Z");
+  const retired = routerRowOf(guardJson({ verdict: "tripped", tripped: ["task-high"], retire: true }));
+  assert.match(retired.detail, /^cost guard: task-high .*; every non-default stage-1 cell tripped — the router retires; guard computed /);
+});
+
+test("router: a baseline short of its n is NO VERDICT, with the count and the n it needs", () => {
+  const r = routerRowOf(guardJson({ verdict: "none", baseline: { ...BASE, n: 7 } }));
+  assert.equal(r.action, "NO VERDICT");
+  assert.equal(r.line, "router       → NO VERDICT   (baseline n=7/20; guard computed 2026-10-03T00:00:00.000Z)");
+});
+
+test("router: no guard file is DEFAULT-ONLY, naming the command that writes one", () => {
+  const r = routerRowOf(null);
+  assert.equal(r.line, "router       → DEFAULT-ONLY   (cost-guard.json missing — run pr-cost.mjs --guard)");
+});
+
+test("router: a guard file that is not a verdict reads DEFAULT-ONLY too — deleting or breaking it cannot evade the guard", () => {
+  const cell = { cell: "task-high", n: 24, mean_usd: 1, fail_rate: 0 };
+  for (const [text, why] of [["{", "not JSON"], [guardJson({ verdict: "maybe" }), "not a guard verdict"],
+    [guardJson({ tripped: "smol-high" }), "not a guard verdict"], [guardJson({ min_n: undefined }), "not a guard verdict"],
+    [guardJson({ computed_at: undefined }), "not a guard verdict"],
+    [guardJson({ cells: [{ ...cell, n: "24" }] }), "not a guard verdict"],
+    [guardJson({ cells: [{ ...cell, mean_usd: "12" }] }), "not a guard verdict"],
+    [guardJson({ cells: [{ ...cell, fail_rate: "0.2" }] }), "not a guard verdict"],
+    [guardJson({ baseline: { ...BASE, mean_usd: "31" } }), "not a guard verdict"],
+    // Self-contradicting files: a verdict that disagrees with tripped[], a tripped cell the file never reports, a non-boolean retire.
+    [guardJson({ verdict: "ok", tripped: ["task-high"] }), "not a guard verdict"],
+    [guardJson({ verdict: "tripped", tripped: [] }), "not a guard verdict"],
+    [guardJson({ verdict: "tripped", tripped: ["ghost"] }), "not a guard verdict"],
+    [guardJson({ retire: "yes" }), "not a guard verdict"]]) {
+    const r = routerRowOf(text);
+    assert.equal(r.action, "DEFAULT-ONLY", text);
+    assert.equal(r.detail, `cost-guard.json unreadable (${why}) — run pr-cost.mjs --guard`, text);
+  }
+});
+
+test("router: with no guard state read at all, no router row", () => {
+  assert.deepEqual(routerRows(state()), []);
+});
+
 test("formatLines prints role, actual/target and the ACTION on one line each", () => {
   assert.deepEqual(
     formatLines(reconcile(state({
@@ -1320,6 +1407,18 @@ test("CLI: runCli with keep: true hands back a fixture dir that still exists", (
   assert.equal(existsSync(runCli([]).dir), false, "without keep the dir is gone on return");
 });
 
+test("CLI: the router row reads the run's .fleet/cost-guard.json, and prints DEFAULT-ONLY without one", () => {
+  const none = runCli([], { shortlist: shortlistText([]) });
+  assert.equal(none.status, 0, none.stderr);
+  assert.deepEqual(lineOf(none, "router"), ["router       → DEFAULT-ONLY   (cost-guard.json missing — run pr-cost.mjs --guard)"]);
+  const ok = runCli([], {
+    shortlist: shortlistText([]),
+    beforeRun: (repo) => writeFileSync(join(repo, ".fleet", "cost-guard.json"), guardJson({ verdict: "none", baseline: { ...BASE, n: 12 } })),
+  });
+  assert.equal(ok.status, 0, ok.stderr);
+  assert.deepEqual(lineOf(ok, "router"), ["router       → NO VERDICT   (baseline n=12/20; guard computed 2026-10-03T00:00:00.000Z)"]);
+});
+
 test("CLI: the #1692 shape, read off the ledger — two live implementers at cap 2 pull nothing", () => {
   const r = runCli([], {
     ledger: { rows: ["#412 impl-412 · tier-ok=impl-412:fleet-implementer", "#415 impl-415 · tier-ok=impl-415:fleet-implementer"], dispatched: ["impl-412", "impl-415"] },

package/scripts/member-outcomes.mjs

@@ -77,24 +77,30 @@ export function rowsForSession(sessionDir, stats = {}) {
     tokensCacheCreate: r.tokens_cache_create, tokensOut: r.tokens_out,
     wallS: r.wall_s, turns: r.turns, agent: r.agent, torn: false,
     subagentType: r.subagent_type,
+    tokensIn: r.tokens_in, tokensCacheRead: r.tokens_cache_read,
+    tokensCacheWrite1h: r.tokens_cache_write_1h ?? "", cost: r.cost == null ? "" : Number(r.cost.toFixed(6)),
   }));
 }
 
 // APPENDED TO, never inserted into: every read-out in the file's header and
-// in docs/specs indexes by position, so a column added anywhere but the end
-// silently repoints every `$n` a reader already wrote down. `subagent_type`
-// (#1066) is therefore last, after `harness`.
+// in the design specs indexes by position, so a column added anywhere but the
+// end silently repoints every `$n` a reader already wrote down.
+// `subagent_type` therefore follows `harness`, and the four priced columns
+// follow it. `cost` is the provider's own per-turn `usage.cost.total`, summed
+// to the micro-dollar — the $ of record; `tokens_cache_write_1h` and `cost`
+// are blank where the transcript recorded no figure, never 0.
 export const COLUMNS = [
   "session", "run_date", "role", "member", "model", "effort", "ticket", "pr",
   "tokens_cache_create", "tokens_out", "wall_s", "turns", "agent", "harness",
-  "subagent_type",
+  "subagent_type", "tokens_in", "tokens_cache_read", "tokens_cache_write_1h", "cost",
 ];
 
 // Row objects use camelCase; the file uses snake_case. One map, one direction
 // each, so a rename cannot silently drop a column.
 const FIELD = {
   tokens_cache_create: "tokensCacheCreate", tokens_out: "tokensOut", wall_s: "wallS",
-  subagent_type: "subagentType",
+  subagent_type: "subagentType", tokens_in: "tokensIn", tokens_cache_read: "tokensCacheRead",
+  tokens_cache_write_1h: "tokensCacheWrite1h",
 };
 const field = (c) => FIELD[c] ?? c;
 // Keyed on the transcript's path-relative stem, not the member name: `member`
@@ -118,13 +124,16 @@ export function formatTsv(rows) {
 }
 
 // REFUSES a row whose cell count is not exactly COLUMNS.length rather than
-// padding it. Padding looked harmless and was not: `agent` is the LAST column,
-// so a short row parsed to `agent: ""` — a key rowsForSession can never
-// produce, which means mergeRows can never REPLACE it. Three ways to reach that
-// were measured, all previously exit 0: a transcript torn mid-write became a
-// permanent phantom that re-scraping could not heal; git conflict markers became
-// three data rows; and adding one column ahead of `agent` collapsed the corpus
-// onto one key per session, 2,702 rows to 156.
+// padding it. Padding looked harmless and was not: when this was written
+// `agent` was the LAST column, so a short row parsed to `agent: ""` — a key
+// rowsForSession can never produce, which means mergeRows can never REPLACE
+// it. Three ways to reach that were measured, all previously exit 0: a
+// transcript torn mid-write became a permanent phantom that re-scraping could
+// not heal; git conflict markers became three data rows; and adding one column
+// ahead of `agent` collapsed the corpus onto one key per session, 2,702 rows
+// to 156. `agent` is no longer last — the priced columns follow it — and
+// there a padded "" would read as "no figure was recorded" for a member whose
+// transcript carried one, so a short row stays refused for that too.
 export function parseTsv(text) {
   return String(text ?? "").split("\n")
     .filter((l) => l.trim() && !l.startsWith("#"))

package/scripts/member-outcomes.test.mjs

@@ -137,6 +137,37 @@ test("a generated word pair that merely starts with a family word yields blanks
   assert.deepEqual(parseMemberName("Impl1341/Impl1341.CwdProbe"), { ticket: "", pr: "" });
 });
 
+test("a review fan-out label books its PR, in the label's own spelling and in the stem omp writes for it", () => {
+  // omp names the member by deleting every character outside [A-Za-z0-9_-]
+  // from the label and appending -<n> from a label's second dispatch on.
+  for (const [label, stem] of [
+    ["review:correctness:pr2132", "reviewcorrectnesspr2132"],
+    ["review:silent-failure:pr2132", "reviewsilent-failurepr2132"],
+    ["verify:comments:pr2132", "verifycommentspr2132"],
+    ["snapshot:pr2132", "snapshotpr2132"],
+    ["test-run:pr2132", "test-runpr2132"],
+  ]) {
+    assert.deepEqual(parseMemberName(label), { ticket: "", pr: "2132" }, label);
+    assert.deepEqual(parseMemberName(stem), { ticket: "", pr: "2132" }, stem);
+    assert.deepEqual(parseMemberName(`${stem}-7`), { ticket: "", pr: "2132" }, `${stem}-7`);
+    // Nested under the reviewer that dispatched it: the last segment is the member.
+    assert.deepEqual(parseMemberName(`review-pr-2132/${stem}`), { ticket: "", pr: "2132" }, `nested ${stem}`);
+  }
+  // A dimension key that itself spells `pr` still yields the trailing number.
+  assert.deepEqual(parseMemberName("reviewprpr12"), { ticket: "", pr: "12" });
+});
+
+test("a fan-out stem that carries no PR, or a name that only resembles one, books nothing", () => {
+  // Measured stems from before the label carried its PR.
+  for (const name of ["verifycorrectness-26", "reviewtests", "snapshot-8", "snapshot", "test-run",
+    // Generated or human names: PascalCase never matches, and a bare number is not `pr<n>`.
+    "ReviewCorrectness", "VerifyAndRepair", "Verify685", "ReviewTestsPr12", "review:correctness", "verify::pr", "reviewpr",
+    // Look-alikes of a fan-out stem: a prefix before the family word, a key-less `verify`, a hyphen before `pr`.
+    "xreviewfoopr12", "xsnapshotpr12", "verifypr12", "snapshot-pr12", "test-run-pr12", "verify-pr12", "reviewers-sprint-pr3"]) {
+    assert.deepEqual(parseMemberName(name), { ticket: "", pr: "" }, name);
+  }
+});
+
 // ---------------------------------------------------------------------------
 // omp fixtures — shaped like real ~/.omp/agent/sessions/**/*.jsonl lines
 // ---------------------------------------------------------------------------
@@ -271,25 +302,37 @@ test("`subagent_type` is what the DISPATCH named, and blank when it named nothin
 });
 
 test("a row whose cell count is wrong is REFUSED, never padded", () => {
-  // Padding put "" in the LAST column — `agent` when this was written,
-  // `subagent_type` now — a key rowsForSession can never produce, so mergeRows
+  // Padding put "" in the trailing columns — `agent` was the LAST one when
+  // this was written, a key rowsForSession can never produce, so mergeRows
   // could never replace it. Three measured routes there, all exit 0: a torn
   // last line became a permanent phantom that re-scraping could not heal, git
   // conflict markers became three data rows, and adding one column ahead of
-  // `agent` collapsed 2,702 rows to 156.
+  // `agent` collapsed 2,702 rows to 156. The columns that trail `agent` now
+  // are the priced ones, where a padded blank reads as "no figure recorded".
   //
-  // The 14-field spelling is the PREVIOUS schema, still on every branch cut
-  // before #1066: it must be refused rather than padded with a blank
-  // `subagent_type`, which would read as "this member was dispatched untyped"
-  // for rows that were nothing of the kind. Regenerating is the migration.
+  // The 15-field spelling is the PREVIOUS schema, from before the four priced
+  // columns: it must be refused rather than padded with blank prices, which
+  // would read as "no figure was recorded" for members whose transcript
+  // carried one. Re-scraping is the migration. The 14-field one before it is
+  // refused the same way.
   //
   // Mutation this must survive: restoring `cells[i] ?? ""`.
   const short = ["s1", "2026-08-25", "memory"].join("\t");
-  assert.throws(() => parseTsv(short), /malformed row: 3 fields, expected 15/);
+  assert.throws(() => parseTsv(short), /malformed row: 3 fields, expected 19/);
   assert.throws(() => parseTsv("<<<<<<< HEAD"), /malformed row/);
-  assert.throws(() => parseTsv(formatTsv([row()]).trim().split("\t").slice(0, 14).join("\t")), /14 fields, expected 15/);
+  const full = formatTsv([row()]).replace(/\n$/, "").split("\t");
+  assert.equal(full.length, 19);
+  assert.throws(() => parseTsv(full.slice(0, 15).join("\t")), /15 fields, expected 19/);
+  assert.throws(() => parseTsv(full.slice(0, 14).join("\t")), /14 fields, expected 19/);
   // A long row is refused too — that is the schema-drift direction.
-  assert.throws(() => parseTsv(formatTsv([row()]).trim() + "\textra"), /16 fields/);
+  assert.throws(() => parseTsv(full.join("\t") + "\textra"), /20 fields/);
+});
+
+test("the four priced columns follow subagent_type, and a scraped member fills them", () => {
+  assert.deepEqual(COLUMNS.slice(COLUMNS.indexOf("subagent_type")),
+    ["subagent_type", "tokens_in", "tokens_cache_read", "tokens_cache_write_1h", "cost"]);
+  const [parsed] = parseTsv(formatTsv([row({ tokensIn: 12, tokensCacheRead: 3400, tokensCacheWrite1h: 900, cost: 0.123457 })]));
+  assert.deepEqual([parsed.tokensIn, parsed.tokensCacheRead, parsed.tokensCacheWrite1h, parsed.cost], ["12", "3400", "900", "0.123457"]);
 });
 
 const row = (o = {}) => ({
@@ -300,7 +343,8 @@ const row = (o = {}) => ({
   // only `member` still get distinct transcript ids, and fixtures that share
   // the default member (untouched) still key as the SAME agent.
   agent: o.member ?? "impl-580", harness: "omp",
-  subagentType: "fleet-implementer", ...o,
+  subagentType: "fleet-implementer",
+  tokensIn: 0, tokensCacheRead: 0, tokensCacheWrite1h: 0, cost: 0.01, ...o,
 });
 
 test("re-scraping a session REPLACES its rows rather than appending duplicates", () => {
@@ -442,6 +486,19 @@ test("two separate sessions scraped in two runs merge into one TSV", () => {
   assert.equal(rows.find((r) => r.member === "Solo").subagentType, "fleet-implementer-alt");
 });
 
+test("a scrape writes the priced columns off the transcript's usage, the 1h share off its cttl", () => {
+  const dir = fixture([["impl-580", [sessionEvt("/x"), thinkingEvt("high"),
+    assistantEvt("claude-opus-5", { input: 7, cacheRead: 500, cacheWrite: 300, cttl: { ephemeral1h: 300 }, cost: { total: 0.25 } }),
+    assistantEvt("claude-opus-5", { input: 3, cacheRead: 800, cacheWrite: 40, cttl: { ephemeral5m: 40 }, cost: { total: 0.0500004 } }, "2026-08-25T10:05:00.000Z"),
+  ]]]);
+  const out = join(tempDir("mo-out-"), "member-outcomes.tsv");
+  const r = spawnSync(process.execPath, [CLI, dir, "--file", out], { encoding: "utf8" });
+  assert.equal(r.status, 0, r.stderr);
+  const [row] = parseTsv(readFileSync(out, "utf8"));
+  assert.deepEqual([row.tokensIn, row.tokensCacheRead, row.tokensCacheCreate, row.tokensCacheWrite1h, row.cost],
+    ["10", "1300", "340", "300", "0.3"]);
+});
+
 test("a run writes rows, and a second run over the same session changes nothing", () => {
   const dir = fixture([["impl-580", [sessionEvt("/x"), thinkingEvt("xhigh"), assistantEvt("claude-opus-5")]]]);
   const out = join(tempDir("mo-out-"), "member-outcomes.tsv");

package/scripts/member-record.mjs

@@ -7,11 +7,11 @@
 //
 // The record: harness, session, role, agent, model, thinking,
 // subagent_type, tokens_in, tokens_cache_create, tokens_cache_read,
-// tokens_out, cost, wall_s, turns, ticket, pr. `harness` is set by whichever
-// reader produced the row — structural, decided by which root the transcript
-// lives under, before any byte is parsed. `cost` is real (`usage.cost.total`
-// — no pricing table exists in this repo, and inventing one is not this
-// module's business.
+// tokens_cache_write_1h, tokens_out, cost, wall_s, turns, ticket, pr.
+// `harness` is set by whichever reader produced the row — structural,
+// decided by which root the transcript lives under, before any byte is
+// parsed. `cost` is real (`usage.cost.total`, the provider's own per-turn
+// figure) — this module prices nothing itself.
 //
 // `thinking` is the harness-written level, blank when a hole is visible.
 // `subagent_type` is what the member was DISPATCHED AS — the agent DEFINITION the dispatch named, never the
@@ -137,10 +137,11 @@ export function normalizeModel(raw) {
 // pr:""}`, losing its join key into tier-outcomes.tsv exactly the way an
 // unmatched finisher spelling once did.
 //
-// Every pattern below is written against the lower-kebab spelling, so the
-// name is first rewritten by `canonicalMemberName` (compute-spend.mjs), the
-// same rewrite classifyRole applies: `Impl327` and `FixPr774` book the
-// ticket and PR their kebab forms do instead of blanks.
+// Every pattern below but the review fan-out one (specialistPr, after the
+// function) is written against the lower-kebab spelling, so the name is first
+// rewritten by `canonicalMemberName` (compute-spend.mjs), the same rewrite
+// classifyRole applies: `Impl327` and `FixPr774` book the ticket and PR their
+// kebab forms do instead of blanks.
 export function parseMemberName(name) {
   const s = canonicalMemberName(name).replace(/-(?:[a-z]|v\d+)$/, "");
   let m = /^(?:fix|review|finish(?:er)?|resolve)-pr-(\d+)(?:-\d+)?$/.exec(s);
@@ -149,7 +150,28 @@ export function parseMemberName(name) {
   if (m) return { ticket: "", pr: m[1] };
   m = /^impl-(\d+)$/.exec(s);
   if (m) return { ticket: m[1], pr: "" };
-  return { ticket: "", pr: "" };
+  return { ticket: "", pr: specialistPr(name) };
+}
+
+// A review fan-out dispatch is labelled `review:<key>:pr<n>`,
+// `verify:<key>:pr<n>`, `snapshot:pr<n>` or `test-run:pr<n>` (review-core.mjs),
+// and books to PR <n>. The label is not what reaches this function off disk:
+// omp derives the member id from it by deleting every character outside
+// `[A-Za-z0-9_-]` and appending `-<n>` from the second dispatch of one label
+// on (measured: `verify:silent-failure` lands as `verifysilent-failure-6`), so
+// `review:correctness:pr12` is the stem `reviewcorrectnesspr12`, or
+// `reviewcorrectnesspr12-3`. Both spellings are matched by applying that same
+// deletion first. Only the LAST path segment is read — a member nested under
+// a reviewer keeps its own id there — and only lowercase, the case the label
+// templates write, so a generated PascalCase name never books a PR. A stem
+// from before the label carried its PR (`verifycorrectness-26`) has no
+// `pr<n>` and stays blank. The key never ends in a hyphen — a label's `<key>:`
+// loses its colon, never leaving one — so a typed `verify-pr12` or
+// `review-sprint-pr3` is not a fan-out stem and stays blank.
+const SPECIALIST_STEM_RE = /^(?:(?:review|verify)[a-z0-9_-]*?[a-z0-9_]|snapshot|test-run)pr(\d+)(?:-\d+)?$/;
+function specialistPr(name) {
+  const stem = String(name ?? "").split(/[/.]/).at(-1).replace(/[^A-Za-z0-9_-]+/g, "");
+  return SPECIALIST_STEM_RE.exec(stem)?.[1] ?? "";
 }
 
 // ---------------------------------------------------------------------------
@@ -328,8 +350,8 @@ function createdPrNumbers(text) {
 export function foldOmpTranscript(jsonlText, filePath) {
   let model = null, thinking = null, task = null, resolvedModelIdentity = null, agent = null;
   let firstTs = null, lastTs = null;
-  let input = 0, cacheWrite = 0, cacheRead = 0, output = 0, cost = 0, turns = 0;
-  let sawCost = false;
+  let input = 0, cacheWrite = 0, cacheWrite1h = 0, cacheRead = 0, output = 0, cost = 0, turns = 0;
+  let sawCost = false, unsplit = false;
   let malformedNonLastLines = 0;
   const entries = [];
   const createCallIds = new Set();
@@ -369,6 +391,8 @@ export function foldOmpTranscript(jsonlText, filePath) {
         cacheWrite += cw;
         cacheRead += Number(u.cacheRead ?? 0);
         output += Number(u.output ?? 0);
+        if (u.cttl && typeof u.cttl === "object") cacheWrite1h += Number(u.cttl.ephemeral1h ?? 0);
+        else if (cw > 0) unsplit = true;
         if (u.cost && typeof u.cost.total === "number") { cost += u.cost.total; sawCost = true; }
         turns++;
         entries.push({
@@ -391,6 +415,12 @@ export function foldOmpTranscript(jsonlText, filePath) {
   return {
     model, thinking, task, resolvedModelIdentity, agent,
     input, cacheWrite, cacheRead, output,
+    // The 1h-TTL share of `cacheWrite`, off each turn's `usage.cttl`
+    // (`{ephemeral1h}` or `{ephemeral5m}`, present only on a turn that wrote
+    // cache). A real 0 when nothing was written, and unknown — `null` — when
+    // any turn that wrote cache recorded no `cttl`: the split was never
+    // recorded for that share, and a partial sum would pass for the whole.
+    cacheWrite1h: unsplit ? null : cacheWrite1h,
     cost: sawCost ? cost : null,
     turns,
     wallS: Number.isFinite(span) ? Math.round(span) : 0,
@@ -497,7 +527,7 @@ export function ompMemberRecord(folded, agentStem, spawnDepth = 0) {
     // carries no `session_init` line to read one from.
     subagent_type: folded.agent ?? "",
     tokens_in: folded.input, tokens_cache_create: folded.cacheWrite,
-    tokens_cache_read: folded.cacheRead, tokens_out: folded.output,
+    tokens_cache_read: folded.cacheRead, tokens_cache_write_1h: folded.cacheWrite1h, tokens_out: folded.output,
     cost: folded.cost,
     wall_s: folded.wallS, turns: folded.turns,
     ticket, pr,

package/scripts/member-record.test.mjs

@@ -88,6 +88,30 @@ test("readOmpMember: cost, tokens and thinking come off real usage/thinking_leve
   assert.equal(rec.turns, 1);
 });
 
+test("readOmpMember: tokens_cache_write_1h sums each turn's usage.cttl.ephemeral1h, and is unknown when cache was written with no TTL split", () => {
+  const turn = (cacheWrite, cttl, ts) => assistantEvt("claude-opus-5", { input: 1, output: 1, cacheRead: 0, cacheWrite, ...(cttl ? { cttl } : {}), cost: { total: 0.01 } }, ts);
+  const rec = (...turns) => readOmpMember([sessionEvt("/x"), thinkingEvt("high"), ...turns].join("\n"), "/fake/path.jsonl", "impl-1");
+  // Measured shapes: `{ephemeral1h:n}` and `{ephemeral5m:n}`, only on a turn that wrote cache.
+  const mixed = rec(turn(300, { ephemeral1h: 300 }), turn(0, null, "2026-09-08T15:13:00.000Z"),
+    turn(50, { ephemeral5m: 50 }, "2026-09-08T15:14:00.000Z"), turn(20, { ephemeral1h: 20 }, "2026-09-08T15:15:00.000Z"));
+  assert.equal(mixed.tokens_cache_create, 370);
+  assert.equal(mixed.tokens_cache_write_1h, 320);
+  assert.equal(rec(turn(0, null)).tokens_cache_write_1h, 0, "nothing written is a real zero");
+  assert.equal(rec(turn(40, null)).tokens_cache_write_1h, null, "cache written with no recorded split is unknown, never zero");
+  assert.equal(rec(turn(300, { ephemeral1h: 300 }), turn(700, null, "2026-09-08T15:13:00.000Z")).tokens_cache_write_1h, null,
+    "one cache-writing turn with no recorded split makes the whole figure unknown, never the recorded share alone");
+});
+
+test("readOmpMember: cost is null, never 0, when no turn carries usage.cost.total", () => {
+  const rec = (...turns) => readOmpMember([sessionEvt("/x"), thinkingEvt("high"), ...turns].join("\n"), "/fake/path.jsonl", "impl-1");
+  const noCost = assistantEvt("claude-opus-5", { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 });
+  const priced = assistantEvt("claude-opus-5", { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0.25 } }, "2026-09-08T15:13:00.000Z");
+  assert.equal(rec(noCost).cost, null, "no figure recorded is blank, so pr-cost counts it unpriced instead of booking a free member");
+  assert.equal(rec(noCost, noCost).cost, null);
+  assert.equal(rec(noCost).turns, 1, "the turn itself still counts");
+  assert.equal(rec(priced).cost, 0.25);
+});
+
 test("foldOmpTranscript: resolvedModelIdentity comes off session_init, present before any assistant turn (#1345)", () => {
   // Measured shape: always provider-prefixed (`anthropic/claude-opus-5`),
   // written at DISPATCH — before the member's first assistant turn, which