@xhulz/nina 0.34.0 → 0.36.0

package/src/commands/release.mjs

@@ -9,9 +9,10 @@
  * Releases are never rewritten. Fixing a release means cutting the next one.
  */
 
-import { cp, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { cp, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { byVersion } from './compose.mjs';
 
 /** A release name: dotted numbers, so the directory sorts and reads like a version. */
 const VERSION = /^\d+\.\d+\.\d+$/;
@@ -80,11 +81,28 @@ export async function release(argv, ctx) {
     console.error(`  ${version} already exists — a release is immutable; cut the next one.\n`);
     return 1;
   }
+  // Above the newest, or `init` pins something older than what the package says it is, and the package's
+  // version moves backwards with the cut.
+  const newest = (await readdir(join(ctx.root, 'releases'), { withFileTypes: true }).catch(() => []))
+    .filter((e) => e.isDirectory() && VERSION.test(e.name))
+    .map((e) => e.name)
+    .sort(byVersion)
+    .at(-1);
+  if (newest && byVersion(version, newest) < 0) {
+    console.error(`  ${newest} is the newest release — a release is cut above it, not below.\n`);
+    return 1;
+  }
 
-  await mkdir(dest, { recursive: true });
+  // Frozen beside the releases and moved in whole: a cut stopped half-way used to leave a partial release,
+  // immutable by name, which `init` then pinned as the newest.
+  const partial = join(ctx.root, `.release-${version}.partial`);
+  await rm(partial, { recursive: true, force: true });
+  await mkdir(partial, { recursive: true });
   for (const layer of ['core', 'surfaces']) {
-    await cp(join(ctx.root, layer), join(dest, layer), { recursive: true });
+    await cp(join(ctx.root, layer), join(partial, layer), { recursive: true });
   }
+  await mkdir(join(ctx.root, 'releases'), { recursive: true });
+  await rename(partial, dest);
 
   const surfaces = (await readdir(join(dest, 'surfaces'), { withFileTypes: true }))
     .filter((e) => e.isDirectory())

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 { createReadStream, existsSync, readFileSync, 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 } from '../transcripts.mjs';
+import { ROLE_TOKENS, isLoopBack, runOf, transcriptsOf } from '../transcripts.mjs';
+import { localDay, namesFor, readStoreFile } from '../store.mjs';
 import { frontmatter, pillFiles } from './pills.mjs';
-import { HARNESS, snapshotsDir } from '../paths.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,41 +56,77 @@ 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;
+  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);
+}
+
+
+/** Directories already found for an encoded name: `stats` asks for the same project many times over. */
+const decoded = new Map();
+
+/**
+ * The directory a project's sessions ran in, as its own transcripts record it: every line carries the
+ * session's `cwd`. Taken only when it encodes back to the same name and is still there.
+ *
+ * @param {string} encoded - A snapshot's project name, which is also its transcript directory's.
+ * @returns {string|null}
+ */
+function recordedDir(encoded) {
+  const dir = transcriptsOf(encoded);
+  let files = [];
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+  } catch {
+    return null;
+  }
+  for (const file of files.slice(0, 5)) {
+    let head = '';
+    try {
+      const fd = openSync(join(dir, file), 'r');
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        head = buffer.toString('utf8', 0, readSync(fd, buffer, 0, buffer.length, 0));
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+      continue;
+    }
+    for (const line of head.split('\n')) {
+      let cwd;
       try {
-        const r = JSON.parse(line);
-        if (opts.since && String(r.ts).slice(0, 10) < opts.since) continue;
-        out.push(r);
+        cwd = JSON.parse(line)?.cwd;
       } catch {
-        /* skip */
+        continue;
       }
+      if (typeof cwd === 'string' && slugFor(cwd) === encoded && existsSync(cwd)) return cwd;
     }
   }
-  return out;
+  return null;
 }
 
-
 /**
  * Turns a snapshot's encoded project name back into a directory.
  *
- * The encoding replaces every separator with a dash, so `Code-IA-harness` could be
- * `Code/IA/harness` or `Code/IA-harness` and the string alone cannot say which. The
- * filesystem can, so the split is resolved against it rather than guessed.
+ * The encoding makes every character that is not a letter or a digit a dash, so the name alone cannot say
+ * what it was. The project's transcripts can: each line records the directory its session ran in. Failing
+ * that, the split is resolved against the file system — which can only rebuild `/` from a dash, so a
+ * project whose path held a `.`, a space or an `_` was never found, and its pills, models and requests went
+ * missing from every report without a word.
  *
  * @param {string} encoded - The `project` field of a snapshot record.
  * @returns {string | null} The directory, or `null` when no split of the name exists.
  */
 export function decodeProjectDir(encoded) {
+  if (decoded.has(encoded)) return decoded.get(encoded);
   const parts = encoded.replace(/^-/, '').split('-');
   const walk = (base, i) => {
     if (i === parts.length) return base;
@@ -102,7 +138,10 @@ export function decodeProjectDir(encoded) {
     }
     return null;
   };
-  return walk('/', 0);
+  const found = recordedDir(encoded) ?? walk('/', 0);
+  // Only what was found: a directory made after a miss is found the next time it is asked for.
+  if (found) decoded.set(encoded, found);
+  return found;
 }
 
 /**
@@ -335,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') +
@@ -377,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']);
@@ -489,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;
   });
@@ -622,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: [] });
     }
@@ -640,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(
@@ -688,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(
@@ -704,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(
@@ -788,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 {