@xhulz/nina 0.35.0 → 0.36.0

package/src/commands/gate.mjs

@@ -21,7 +21,7 @@ import { join, resolve } from 'node:path';
 import { HARNESS, legacyHint, slugFor } from '../paths.mjs';
 import { GATE, hookCommand, missingWiring, shippedScripts } from '../wiring.mjs';
 import { LEDGER_TAIL, ledgerPath, loadProject, projectGateDir, readLedger, runGate } from '../gate.mjs';
-import { storedRecords } from './snapshot.mjs';
+import { projectRecords } from '../store.mjs';
 import { layerRootFor } from './compose.mjs';
 import { handsToModel } from '../detectors.mjs';
 
@@ -102,7 +102,8 @@ const LIVE_SAMPLE = 3;
  *
  * @param {string} target - The project directory.
  * @param {{graph: {stages: Set<string>}, tokens: Map<string, Set<string>>}} project - Its composed graph.
- * @returns {string|null}
+ * @returns {{problem: string}|{compared: number}|{unasked: string}} What the comparison found, how many reports it
+ *   compared, or why there was nothing to compare yet — which the selftest used to report as a comparison that passed.
  */
 function liveness(target, project) {
   const dir = projectGateDir(target);
@@ -110,10 +111,10 @@ function liveness(target, project) {
   try {
     since = readFileSync(join(dir, SINCE), 'utf8').trim();
   } catch {
-    return null;
+    return { unasked: 'no session has been measured since the gate was first asked' };
   }
   const now = Date.now();
-  const reports = (storedRecords(target) ?? []).filter(
+  const reports = (projectRecords(target) ?? []).filter(
     (r) =>
       r.verdict_source === 'handback' &&
       r.session &&
@@ -128,18 +129,20 @@ function liveness(target, project) {
     .filter((rs) => rs.length >= LIVE_SAMPLE)
     .sort((a, b) => String(a.map((r) => r.result_ts).sort().at(-1)).localeCompare(String(b.map((r) => r.result_ts).sort().at(-1))))
     .at(-1);
-  if (!last) return null;
+  if (!last) return { unasked: `no session since then holds ${LIVE_SAMPLE} reports with a verdict line to compare` };
   const path = ledgerPath(target, last[0].session);
   const entries = readLedger(path);
   // A ledger too large to read whole is read from its tail; what came before the tail is not asked about.
   const from = entries.length > 0 && statSync(path).size > LEDGER_TAIL ? String(entries[0].at) : '';
   const shown = last.filter((r) => String(r.result_ts) >= from).length;
   const recorded = entries.filter((e) => e.k === 'verdict').length;
-  if (shown < LIVE_SAMPLE || recorded * 2 >= shown) return null;
-  return (
-    `in session ${last[0].session.slice(0, 8)}, the transcripts show ${shown} report(s) with a verdict line and the gate recorded ${recorded}: ` +
-    `Claude Code may have changed what it sends to the hooks, and a loop the gate does not see is not capped (${path})`
-  );
+  if (shown < LIVE_SAMPLE) return { unasked: `the newest measured session holds ${shown} report(s) with a verdict line, too few to compare` };
+  if (recorded * 2 >= shown) return { compared: shown };
+  return {
+    problem:
+      `in session ${last[0].session.slice(0, 8)}, the transcripts show ${shown} report(s) with a verdict line and the gate recorded ${recorded}: ` +
+      `Claude Code may have changed what it sends to the hooks, and a loop the gate does not see is not capped (${path})`,
+  };
 }
 
 /**
@@ -299,11 +302,14 @@ export async function gate(argv, ctx) {
   // A gate that is not wired sees nothing, and says so above; asked whether it saw the pipeline, it would
   // say the same thing twice.
   const project = composed && unwired.length === 0 ? loadProject(target) : null;
-  const blind = project ? liveness(target, project) : null;
-  if (blind) problems.push(blind);
+  const seen = project ? liveness(target, project) : null;
+  if (seen?.problem) problems.push(seen.problem);
 
   if (problems.length === 0) {
-    console.log(`  wired, writable, no new failure, a dry run through the hook command sent the round past a cap to the owner, and it recorded the reports the transcripts show — ledgers in ${projectGateDir(target)}`);
+    const compared = seen?.compared
+      ? `and it recorded the ${seen.compared} reports the transcripts show`
+      : `and whether it records what the transcripts show is not asked yet — ${seen?.unasked ?? 'nothing to compare'}`;
+    console.log(`  wired, writable, no new failure, a dry run through the hook command sent the round past a cap to the owner, ${compared} — ledgers in ${projectGateDir(target)}`);
     console.log('gate: current');
     return 0;
   }

package/src/commands/learn.mjs

@@ -26,6 +26,7 @@ import { existsSync, readdirSync } from 'node:fs';
 import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { join, relative, resolve } from 'node:path';
 import { HARNESS, legacyHint, slugFor, snapshotsDir } from '../paths.mjs';
+import { localDay, projectRecords } from '../store.mjs';
 import { isLoopBack, runOf } from '../transcripts.mjs';
 import { REQUIRES, byVersion, layerRootFor } from './compose.mjs';
 import { GRADUATION_AT, frontmatter, graduationTarget, list, pillFiles, roleGates, tidyRetired } from './pills.mjs';
@@ -52,7 +53,8 @@ const VERIFY_MIN = 5;
 export { slugFor };
 
 /** The day part of a timestamp or a date. */
-const day = (ts) => String(ts ?? '').slice(0, 10);
+/** The owner's day a moment fell on: a pill's date is written in it. */
+const day = localDay;
 
 /** A verdict the parser actually read, as opposed to one it could not find. */
 const readable = (v) => Boolean(v) && v !== 'UNCLEAR' && v !== 'NONE';
@@ -64,19 +66,7 @@ const readable = (v) => Boolean(v) && v !== 'UNCLEAR' && v !== 'NONE';
  * @returns {Promise<object[]>}
  */
 async function recorded(target) {
-  const file = join(snapshotsDir(), `${slugFor(target)}.jsonl`);
-  const text = await readFile(file, 'utf8').catch(() => '');
-  return text
-    .split('\n')
-    .filter((l) => l.trim())
-    .map((l) => {
-      try {
-        return JSON.parse(l);
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
+  return projectRecords(target) ?? [];
 }
 
 /**
@@ -486,7 +476,7 @@ async function deepReport(target, records, known, argv) {
  */
 async function fileRequest(target, profile, layerRoot, lesson) {
   const target_ = graduationTarget(lesson.roles, await roleGates(layerRoot));
-  const date = new Date().toISOString().slice(0, 10);
+  const date = localDay(new Date().toISOString());
   // The directory separator becomes `__`, so `reviewer/a.b.md` and `reviewer-a/b.md` stay two
   // names — flattening both `/` and `.` to `-` gave them the same one.
   const name = lesson.rel.replace(/^\.claude\/pills\//, '').replace(/\.md$/, '').replace(/\//g, '__');

package/src/commands/pipeline.mjs

@@ -18,7 +18,7 @@ import { TERMINALS, parseGraph } from '../graph.mjs';
 import { required } from '../tools.mjs';
 import { isLoopBack, runOf } from '../transcripts.mjs';
 import { frontmatter } from './pills.mjs';
-import { storedRecords } from './snapshot.mjs';
+import { localDay, projectRecords } from '../store.mjs';
 
 /** A stage line under "## Stages": "- `name` — what it does". */
 const STAGE_LINE = /^- `([a-z][a-z-]*)` — (.*)$/;
@@ -149,7 +149,7 @@ export function historyOf(records, since) {
   const byRole = new Map();
   const seen = new Map();
   for (const r of records) {
-    if (!r.role || r.status === 'denied' || String(r.ts ?? '') < since) continue;
+    if (!r.role || r.status === 'denied' || localDay(r.ts) < since) continue;
     const s = byRole.get(r.role) ?? { runs: 0, rounds: 0, read: 0, back: 0 };
     const runs = seen.get(r.role) ?? new Set();
     runs.add(runOf(r));
@@ -288,8 +288,8 @@ export async function pipeline(argv) {
   for (const file of existsSync(agentsDir) ? readdirSync(agentsDir).filter((f) => f.endsWith('.md')).sort() : []) {
     specs.set(file.replace(/\.md$/, ''), readFileSync(join(agentsDir, file), 'utf8'));
   }
-  const since = arg('--since') || new Date(Date.now() - HISTORY_DAYS * 86_400_000).toISOString().slice(0, 10);
-  const runs = storedRecords(dir);
+  const since = arg('--since') || localDay(new Date(Date.now() - HISTORY_DAYS * 86_400_000).toISOString());
+  const runs = projectRecords(dir);
   const history = runs ? historyOf(runs, since) : null;
   const stages = [...graph.stages].filter((s) => covered.has(s));
   const col = Math.max(...stages.map((s) => s.length), 10) + 2;

package/src/commands/runs.mjs

@@ -16,8 +16,8 @@ import { HARNESS } from '../paths.mjs';
 import { costOf } from '../prices.mjs';
 import { isLoopBack, runOf } from '../transcripts.mjs';
 import { amber, bold, dim, pink } from '../look.mjs';
-import { storedRecords } from './snapshot.mjs';
-import { cyclesOf, projectName } from './stats.mjs';
+import { localDay, localMinute, projectRecords, zone } from '../store.mjs';
+import { WRITERS, cyclesOf, projectName } from './stats.mjs';
 
 /** What ended a cycle, in words. */
 const ENDS = {
@@ -55,7 +55,8 @@ export function summarize(cycle) {
     if (isLoopBack(r.verdict)) s.back += 1;
     stages.set(r.role, s);
   }
-  const files = rounds.filter((r) => typeof r.files_touched === 'number').map((r) => r.files_touched);
+  // The code a cycle wrote, as `stats` counts it: an architect's spec or a tester's report is not a write of code.
+  const files = rounds.filter((r) => WRITERS.has(r.role) && typeof r.files_touched === 'number').map((r) => r.files_touched);
   const peaks = rounds.filter((r) => typeof r.context_peak === 'number').map((r) => r.context_peak);
   return {
     start,
@@ -92,9 +93,14 @@ export async function runs(argv) {
   }
   const since = arg('--since');
   const last = Math.max(1, Number(arg('--last') ?? 10) || 10);
-  const records = (storedRecords(dir) ?? []).filter((r) => r.status !== 'denied' && (!since || String(r.ts).slice(0, 10) >= since));
+  const stored = (projectRecords(dir) ?? []).filter((r) => r.status !== 'denied');
+  const records = stored.filter((r) => !since || localDay(r.ts) >= since);
   if (records.length === 0) {
-    console.error('  no measured history for this project yet — `nina snapshot` captures it\n');
+    console.error(
+      stored.length === 0
+        ? '  no measured history for this project yet — `nina snapshot` captures it\n'
+        : `  nothing measured since ${since} (${zone()}) — the newest round is from ${localDay(stored.map((r) => String(r.ts)).sort().at(-1))}\n`,
+    );
     return 1;
   }
   const cycles = cyclesOf(records)
@@ -103,10 +109,10 @@ export async function runs(argv) {
   const shown = cycles.slice(0, last);
   console.log(
     `  ${bold(pink(projectName(records[0].project)))} · ${cycles.length} cycle(s)` +
-      dim(`  newest first${cycles.length > shown.length ? `, the last ${shown.length} — --last N for more` : ''}; a cycle runs up to the verdict that closes it`),
+      dim(`  newest first${cycles.length > shown.length ? `, the last ${shown.length} — --last N for more` : ''}; a cycle runs up to the verdict that closes it; times in ${zone()}`),
   );
   for (const c of shown) {
-    const when = `${c.start.slice(0, 10)} ${c.start.slice(11, 16)}`;
+    const when = localMinute(c.start);
     console.log(`\n  ${pink('▌')} ${bold(when)} · ${span(c.minutes)} · ${bold(money(c.cost))}${c.unpriced ? dim(` + ${c.unpriced} unpriced`) : ''} · ${dim(c.how)}`);
     console.log(`    ${c.name.length > 96 ? `${c.name.slice(0, 95)}…` : c.name}`);
     const chain = c.stages.map((s) => {
@@ -122,7 +128,7 @@ export async function runs(argv) {
   const costliest = shown.reduce((a, c) => (c.cost > a.cost ? c : a), shown[0]);
   console.log(
     `\n  ${shown.length} cycle(s): ${bold(money(total))} in all` +
-      (shown.length > 1 ? `; the costliest, ${money(costliest.cost)}, ${costliest.start.slice(0, 10)} — ${costliest.name.slice(0, 60)}` : '') +
+      (shown.length > 1 ? `; the costliest, ${money(costliest.cost)}, ${localDay(costliest.start)} — ${costliest.name.slice(0, 60)}` : '') +
       '\n',
   );
   return 0;

package/src/commands/snapshot.mjs

@@ -9,9 +9,10 @@
  */
 
 import { copyFile, mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { slugFor, snapshotsDir } from '../paths.mjs';
-import { createReadStream, existsSync, readFileSync, realpathSync } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { HARNESS, snapshotsDir } from '../paths.mjs';
+import { decodeProjectDir } from './stats.mjs';
+import { readStoreFile } from '../store.mjs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { listProjects, scanProject } from '../transcripts.mjs';
 
@@ -21,7 +22,8 @@ const STATE_FILE = '.state.json';
 /**
  * Reads a JSON file, or an empty object when it is missing or unreadable. A state file cut short
  * by an interrupted write used to throw on every later snapshot, and observation stopped for every
- * project on the machine with nothing saying so. An unreadable cursor costs one re-read.
+ * project on the machine with nothing saying so. An unreadable cursor costs one re-read, which keeps what the
+ * store already holds (`snapshotProject`).
  *
  * @param {string} path - The file.
  * @returns {Promise<object>}
@@ -42,35 +44,10 @@ async function readJson(path) {
  */
 async function writeAtomicText(path, text) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tmp, text);
+  await writeFile(tmp, text, { mode: 0o600 });
   await rename(tmp, path);
 }
 
-/**
- * Reads the records already captured for a project.
- *
- * @param {string} file - Path to the snapshot JSONL.
- * @returns {Promise<object[]>} The records, or an empty list.
- */
-async function readRecords(file) {
-  const records = [];
-  try {
-    await readFile(file, { flag: 'r' });
-  } catch {
-    return records;
-  }
-  const rl = createInterface({ input: createReadStream(file), crlfDelay: Infinity });
-  for await (const line of rl) {
-    if (!line.trim()) continue;
-    try {
-      records.push(JSON.parse(line));
-    } catch {
-      /* a torn line loses one record, never the file */
-    }
-  }
-  return records;
-}
-
 /**
  * Writes the snapshot through a temp file, so an interrupted run cannot leave a
  * truncated one behind.
@@ -82,41 +59,11 @@ async function writeAtomic(file, records) {
   // Unique per writer: two snapshots of one project at once used the same temporary name, and
   // could interleave into it before either renamed it into place.
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tmp, `${records.map((r) => JSON.stringify(r)).join('\n')}\n`);
+  // Its owner's alone: it holds each dispatch's description, which the orchestrator wrote.
+  await writeFile(tmp, `${records.map((r) => JSON.stringify(r)).join('\n')}\n`, { mode: 0o600 });
   await rename(tmp, file);
 }
 
-/**
- * A project's records in the measurement store, under the name Claude Code gives its directory — as
- * given, or with its links resolved, since either may be the one the sessions ran in.
- *
- * @param {string} dir - The project.
- * @returns {object[]|null} Null when the store has nothing for it.
- */
-export function storedRecords(dir) {
-  const names = new Set([slugFor(dir)]);
-  try {
-    names.add(slugFor(realpathSync(dir)));
-  } catch {
-    // A directory that cannot be resolved is looked up as given.
-  }
-  for (const name of names) {
-    const file = join(snapshotsDir(), `${name}.jsonl`);
-    if (!existsSync(file)) continue;
-    return readFileSync(file, 'utf8')
-      .split('\n')
-      .filter(Boolean)
-      .flatMap((l) => {
-        try {
-          return [JSON.parse(l)];
-        } catch {
-          return [];
-        }
-      });
-  }
-  return null;
-}
-
 /**
  * Takes a project's lock, or says it is taken. The records and the cursors are written one after the other,
  * and two snapshots of one project at once — a project's own detector and a global hook, both on every
@@ -204,6 +151,42 @@ export async function snapshot(argv, ctx) {
   return 0;
 }
 
+/** Whether a round's verdict came from the report it handed back: the one reading nothing later corrects. */
+const settledByHandback = (r) => r?.verdict_source === 'handback';
+
+/**
+ * A round as a re-read after lost cursors leaves it. What the store held stands, field by field, and the
+ * re-read fills only what it lacked — unless the re-read settled the round from the report its stage handed
+ * back and the store had not: a verdict read from a notification is the one a handback corrects, and kept
+ * over it, a round the store had as REJECTED stayed so after its stage had said APPROVED, and stayed so for
+ * good once that stage's transcript was pruned.
+ *
+ * @param {object} held - The round as the store held it.
+ * @param {object} reread - The round as the re-read found it.
+ * @returns {object}
+ */
+export function rereadOver(held, reread) {
+  const defined = (record) => Object.fromEntries(Object.entries(record).filter(([, v]) => v !== null && v !== undefined));
+  return settledByHandback(reread) && !settledByHandback(held) ? { ...held, ...defined(reread) } : { ...reread, ...defined(held) };
+}
+
+/**
+ * The release a project pins now, or null when its directory or profile cannot be found.
+ *
+ * @param {string} slug - Its store name.
+ * @returns {string|null}
+ */
+function pinOf(slug) {
+  const dir = decodeProjectDir(slug);
+  if (!dir) return null;
+  try {
+    const core = JSON.parse(readFileSync(join(dir, HARNESS, 'profile.json'), 'utf8')).core;
+    return typeof core === 'string' ? core : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Snapshots one project, under its lock.
  *
@@ -214,12 +197,28 @@ async function snapshotProject(project, { outDir, rebuild, quiet, legacy }) {
   // The store is the only copy of history older than the transcripts, and a rebuild re-reads only what is
   // still on disk: the record it replaces is kept beside it first.
   if (rebuild && existsSync(file)) await copyFile(file, `${file}.before-rebuild-${new Date().toISOString().replace(/[:.]/g, '-')}`);
-  const prior = rebuild ? [] : await readRecords(file);
+  const stored = readStoreFile(file, { raw: true });
+  const prior = rebuild ? [] : stored;
   const own = rebuild ? {} : await readJson(join(outDir, `${project.slug}.state.json`));
   const cursors = rebuild ? {} : (own.cursors ?? legacy[project.slug]?.cursors ?? {});
 
   const scanned = await scanProject(project.dir, { cursors, records: prior });
-  const records = scanned.records.map((r) => ({ project: project.slug, ...r }));
+  // With its cursors gone — a state file deleted, or cut short — the transcripts are read again from the start
+  // over records the store already holds, and read that way a notification is taken a second time: one
+  // project had 34 verdicts, 639 return times and 79 durations rewritten. What the store held stands, field
+  // by field, and the re-read adds only what it lacked; the cursors it leaves hold from then on.
+  const reread = !rebuild && prior.length > 0 && Object.keys(cursors).length === 0;
+  const held = new Map(prior.map((r) => [r.dispatch_id, r]));
+  const kept = (r) => (reread && held.has(r.dispatch_id) ? rereadOver(held.get(r.dispatch_id), r) : r);
+  // The release the project pinned when a round was first captured, so a rule is judged only on the rounds
+  // that ran under it. A round already on record keeps what it had — a rebuild included, which would
+  // otherwise stamp today's pin on weeks of history — and only a new one takes today's.
+  const pinned = new Map(stored.map((r) => [r.dispatch_id, r.core ?? null]));
+  const pin = pinOf(project.slug);
+  const records = scanned.records.map(kept).map((r) => {
+    const core = pinned.has(r.dispatch_id) ? pinned.get(r.dispatch_id) : pin;
+    return { ...r, project: project.slug, ...(core ? { core } : {}) };
+  });
   if (records.length === 0) return 0;
 
   const fresh = records.length - prior.length;

package/src/commands/stats.mjs

@@ -14,15 +14,15 @@
 import { amber, bar, bold, dim, heading, note, pink, stacked } from '../look.mjs';
 import { readFile, readdir } from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
-import { closeSync, createReadStream, existsSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { ROLE_TOKENS, isLoopBack, runOf, transcriptsOf } from '../transcripts.mjs';
+import { localDay, namesFor, readStoreFile } from '../store.mjs';
 import { frontmatter, pillFiles } from './pills.mjs';
 import { HARNESS, slugFor, snapshotsDir } from '../paths.mjs';
 import { defaultVocabulary } from '../vocabulary.mjs';
-import { layerRootFor } from './compose.mjs';
+import { byVersion, layerRootFor } from './compose.mjs';
 import { PRICES_AS_OF, costOf } from '../prices.mjs';
 
 /**
@@ -56,27 +56,16 @@ const PIPELINE_ROLES = new Set(Object.keys(ROLE_TOKENS));
  * Loads snapshot records, optionally filtered.
  *
  * @param {string} dir - Snapshot directory.
- * @param {{since: string|null, project: string|null}} opts - Filters.
+ * @param {{since: string|null, project: string|null}} opts - Filters; `project` as every report reads it.
  * @returns {Promise<object[]>} The matching records.
  */
 async function load(dir, opts) {
-  const files = (await readdir(dir).catch(() => [])).filter((f) => f.endsWith('.jsonl'));
-  const out = [];
-  for (const file of files) {
-    if (opts.project && !file.includes(opts.project)) continue;
-    const rl = createInterface({ input: createReadStream(join(dir, file)), crlfDelay: Infinity });
-    for await (const line of rl) {
-      if (!line.trim()) continue;
-      try {
-        const r = JSON.parse(line);
-        if (opts.since && String(r.ts).slice(0, 10) < opts.since) continue;
-        out.push(r);
-      } catch {
-        /* skip */
-      }
-    }
-  }
-  return out;
+  const names = opts.project
+    ? namesFor(opts.project, dir)
+    : (await readdir(dir).catch(() => [])).filter((f) => f.endsWith('.jsonl')).map((f) => f.slice(0, -'.jsonl'.length));
+  return names
+    .flatMap((name) => readStoreFile(join(dir, `${name}.jsonl`)))
+    .filter((r) => !opts.since || localDay(r.ts) >= opts.since);
 }
 
 
@@ -385,7 +374,7 @@ function modelReport(records) {
         .map((rs) => rs.map((r) => (r.tokens ? costOf(r.tokens, r.usage_model) : null)).filter((c) => c !== null))
         .filter((cs) => cs.length > 0)
         .map((cs) => cs.reduce((a, b) => a + b, 0));
-      const dates = rounds.map((r) => String(r.ts).slice(0, 10)).sort();
+      const dates = rounds.map((r) => localDay(r.ts)).sort();
       lines.push(
         `    ${i === 0 ? `${pink(role)}${' '.repeat(Math.max(20 - role.length, 1))}` : ''.padEnd(20)}${model.padEnd(26)}${String(runs.size).padStart(5)} run(s)  ${dim(`${dates[0]} → ${dates.at(-1)}`)}` +
           (clear.length ? `  loop-back ${pct(loops, clear.length)} of ${clear.length}` : '  no readable verdict') +
@@ -427,8 +416,25 @@ function modelReport(records) {
 /** The verdicts that close a pipeline cycle: the change passed its tests, reached preview, or cleared the audit. */
 const CYCLE_ENDS = { qa: 'PASS', devops: 'DEPLOYED', secops: 'SECURE' };
 
+/**
+ * The release each rule this report judges first shipped in. A round is judged on a rule only when the pin it
+ * was captured under (`core`) carries it: over every round, "0 of 16 loop-backs named their issues" read
+ * reports written before the rule existed as breaking it. Releases are never rewritten, so neither is this.
+ */
+const RULE_SINCE = { issues: '0.22.0', stepFiles: '0.28.8' };
+
+/**
+ * Whether a round ran under a release that carries a rule. One captured before rounds recorded their pin
+ * cannot say, and is left out rather than judged.
+ *
+ * @param {object} record - A round.
+ * @param {keyof RULE_SINCE} rule - The rule.
+ * @returns {boolean}
+ */
+export const ranUnder = (record, rule) => typeof record.core === 'string' && (record.core === 'dev' || byVersion(record.core, RULE_SINCE[rule]) >= 0);
+
 /** The stages that write code, whose runs' file counts size a cycle. */
-const WRITERS = new Set(['implementer', 'solidity-dev']);
+export const WRITERS = new Set(['implementer', 'solidity-dev']);
 
 /** The stages whose presence makes a cycle a designed one. */
 const DESIGNERS = new Set(['planner', 'architect']);
@@ -539,7 +545,7 @@ function proportionReport(records, stepLimit = () => null) {
   // cache read per file held near 1M up to 19 files and was 6.9M in a 52-file run. Asked only of a project
   // whose pinned release states the limit.
   const over = records.filter((r) => {
-    if (r.role !== 'implementer' || typeof r.files_touched !== 'number') return false;
+    if (r.role !== 'implementer' || typeof r.files_touched !== 'number' || !ranUnder(r, 'stepFiles')) return false;
     const limit = stepLimit(r.project);
     return limit !== null && r.files_touched > limit;
   });
@@ -672,7 +678,14 @@ export async function stats(argv, ctx) {
   // A dispatch a hook denied never ran, so it is neither a run nor a missing verdict.
   const held = records.filter((r) => r.status === 'denied').length;
   const now = Date.now();
+  // Agents outside the pipeline — Claude Code's own, a project's own — have no verdict to give. Read as
+  // stages they were 100% unreadable and were told to add a verdict token their spec never asked for.
+  const outside = new Map();
   for (const r of records.filter((r) => r.status !== 'denied')) {
+    if (!PIPELINE_ROLES.has(r.role)) {
+      outside.set(r.role, (outside.get(r.role) ?? 0) + 1);
+      continue;
+    }
     if (!byRole.has(r.role)) {
       byRole.set(r.role, { n: 0, runs: new Set(), done: 0, lost: 0, clear: 0, loop: 0, unclear: 0, declared: 0, durations: [] });
     }
@@ -690,7 +703,7 @@ export async function stats(argv, ctx) {
     if (typeof r.duration_s === 'number') s.durations.push(r.duration_s);
   }
 
-  const span = [records[0]?.ts, records.at(-1)?.ts].map((t) => String(t).slice(0, 10));
+  const span = [records[0]?.ts, records.at(-1)?.ts].map(localDay);
   const projectCount = new Set(records.map((r) => r.project)).size;
   const run = byRun(records.filter((r) => r.status !== 'denied')).size;
   console.log(
@@ -738,9 +751,14 @@ export async function stats(argv, ctx) {
   const lost = rows.reduce((a, [, s]) => a + s.lost, 0);
   const done = rows.reduce((a, [, s]) => a + s.done, 0);
   console.log('');
+  if (outside.size > 0) {
+    const named = [...outside.entries()].sort((a, b) => b[1] - a[1]).map(([role, n]) => `${role} ×${n}`).join(', ');
+    console.log(note(`${[...outside.values()].reduce((a, b) => a + b, 0)} round(s) by agents outside the pipeline (${named}) — not stages, so no verdict is asked of them.`, 'info'));
+  }
   if (unreadable === 0 && lost === 0) console.log(note("every finished round's verdict could be read.", 'ok'));
+  // The same share as the table's column: rounds that finished, or should have, with no verdict read.
   if (unreadable > 0) {
-    console.log(note(`${pct(unreadable, done + lost)} of finished rounds report no machine-readable verdict. Those stages need a verdict token on the report's first line.`, 'warn'));
+    console.log(note(`${pct(unreadable + lost, done + lost)} of finished rounds have no verdict that can be read. Those stages need a verdict token on the report's first line.`, 'warn'));
   }
   if (lost > 0) {
     console.log(
@@ -754,7 +772,7 @@ export async function stats(argv, ctx) {
 
   // Whether the stages that send work back say what they send back. Counted only over reports read
   // since the record learned the field, and only over declared loop-backs, which are all it asks of.
-  const named = records.filter((r) => typeof r.issues === 'number');
+  const named = records.filter((r) => typeof r.issues === 'number' && ranUnder(r, 'issues'));
   if (named.length > 0) {
     const withIds = named.filter((r) => r.issues > 0).length;
     console.log(
@@ -838,7 +856,7 @@ export async function stats(argv, ctx) {
         : note(`${pills.retired} of ${pills.total} pill(s) retired into a rule.`, 'ok'),
     );
     if (newest) {
-      const since = records.filter((r) => String(r.ts).slice(0, 10) > newest).length;
+      const since = records.filter((r) => localDay(r.ts) > newest).length;
       if (since > 0) console.log(note(`${since} round(s) since the newest pill (${newest}).`));
     }
   }

package/src/commands/status.mjs

@@ -22,7 +22,7 @@ import { amber, bold, dim, green, pink } from '../look.mjs';
 import { byVersion, layerRootFor } from './compose.mjs';
 import { filedRequests } from './learn.mjs';
 import { frontmatter, pillFiles } from './pills.mjs';
-import { storedRecords } from './snapshot.mjs';
+import { projectRecords } from '../store.mjs';
 
 /** How long the registry gets to say which version is newest; a status is not worth waiting on. */
 const REGISTRY_MS = 3000;
@@ -123,7 +123,7 @@ export async function status(argv, ctx) {
   const check = verdictOf(bin, ['check', '--project', target]);
   row('check', check.ok ? green(check.line) : warn(`${check.line} — \`nina check\` lists them`));
 
-  const records = storedRecords(target) ?? [];
+  const records = projectRecords(target) ?? [];
   if (records.length === 0) {
     row('measured', dim('nothing yet — `nina snapshot` captures it'));
   } else {