agent-polygraph 0.2.0 → 0.3.0

package/README.md

@@ -47,7 +47,21 @@ Under the tables it prints the latest examples: what the agent claimed, the last
 
 **What the benchmarks actually show:** agent-polygraph detects stale test claims more reliably than a *simple any-prior-pass rule* in [25 authored replay scenarios](docs/benchmark.md) (14/14 unbacked claims versus 7/14). In [12 instrumented projects using real test executions](docs/live-evaluation.md), its selective guard requested **5** additional tests and detected **3 of 7** failing final suites; rerunning the full suite every time required **12** additional tests and detected **all 7**. That is an efficiency-versus-coverage trade-off, **not** evidence that the guard improves overall defect detection. [Public-session workload projections](docs/benchmark.md) are separate from actual executed tests. The independently labeled human study is [still open](https://github.com/EleChon-pixel/agent-polygraph/issues/3).
 
-**npm release status:** The [public npm registry](https://www.npmjs.com/package/agent-polygraph) still serves **0.1.0**, while GitHub `main` contains the security-hardened **0.2.0 release candidate**. The automated tarball test passes, but new npm code will not be available to `npx` until it has been published. For the exact manual publishing procedure (GitHub OIDC trusted publisher), see [Release instructions](docs/releasing.md).
+**npm distribution:** Install the most recently *published* release with `npx --yes agent-polygraph --demo`, or pin an exact version (for example, `npx --yes agent-polygraph@0.2.0 --demo`). Check the actual public version with `npm view agent-polygraph version`: the GitHub `main` branch may be ahead of npm. Releases use GitHub OIDC trusted publishing and require maintainer 2FA approval before going live. The [automated public-install check](.github/workflows/verify-published-npm.yml) tests the download from npm, not just the repository source. See [Release instructions](docs/releasing.md).
+
+## Explain a specific finding and check your setup
+
+**Release note:** These commands are on GitHub `main` for the upcoming `0.3.0` release. The currently published npm `0.2.1` package does not include them. Until approval of `0.3.0`, use the repository's CLI as `node bin/polygraph.js explain` or `node bin/polygraph.js doctor`.
+
+```sh
+agent-polygraph explain --since 7d --limit 10  # show flagged or uncertain claims and their evidence
+agent-polygraph explain --session abc123        # narrow by session ID prefix
+agent-polygraph doctor                         # check installed hooks, logs and recorder settings
+```
+
+`explain` shows the claim, available last-test evidence, relevant subsequent edit and why a result is inconclusive. It is **read-only**, does not run tests, and may print private transcript excerpts, commands and paths. **Do not share its output without reviewing/redacting it.** Use `explain --ci` only if you want to ask GitHub for additional CI evidence.
+
+`doctor` inspects local transcript discovery, a small sample of log formats, project/global hook settings, and recorder-directory permissions. It **never modifies settings or installs hooks**. An uninstalled direct hook is informational: the guard is optional and the Claude Code plugin may supply one separately. The default is offline; `doctor --ci` explicitly checks whether your GitHub CLI login is available, which may contact GitHub. This is a diagnostic, not a complete security audit.
 
 ## Share your numbers
 
@@ -173,7 +187,7 @@ The replay labels and scenarios were constructed by the project authors. The gua
 These are the gaps that remain. `record` and `--ci` can reduce some of them, but neither replaces running tests or provides independent proof of correctness.
 
 - Tests outside the logs. Tests the agent ran, test runs Claude Code recorded from hooks, commands you typed with `!` in Claude Code, and test output you pasted into the chat all count. So do your own bash and zsh runs with `record --shell`, and GitHub Actions runs on pushed commits with `--ci`. Other shells (fish, PowerShell, an IDE's test button), other CI services, and CI runs on commits the session never printed are still invisible.
-- "The full suite passes" is compared with the latest run about as large as the largest one in that folder, using the counts the runner printed. If no run printed a count, it's compared with the latest run, which may have been narrower. Claims that name no count, test file or full suite are compared with the latest run.
+- "The full suite passes" prefers an explicitly recognized full-suite command in the same folder, even when no count was printed. If the only observed run is targeted and there is no full-suite evidence, the result is **inconclusive**, not backed. Count-based heuristics still help when the runner cannot reliably identify the suite's scope. A passing test run is evidence of that run, never proof that all code works.
 - Output with no summary. Codex keeps each command's full output. Claude Code may save long output to a separate file that the analyzer reads if it still exists. New `record` entries retain **parsed test outcomes and pass counts, not raw test output**. A run abandoned before printing a result leaves nothing to read.
 - Files a script names at run time. Without `record` these make a claim "couldn't tell", never "backed". `record` settles them, but only in git checkouts and only for sessions after it was installed.
 - New agent versions can change the log format. Supported: Claude Code 2.x (Bash and PowerShell tools; Linux, macOS and Windows paths) and Codex CLI. The report lists the versions it read, warns about newer ones, and counts files it couldn't parse instead of dropping them silently.
@@ -191,6 +205,8 @@ These are the gaps that remain. `record` and `--ci` can reduce some of them, but
 --examples <n>      examples to show per finding type (default 3, 0 to hide)
 --html [file]       write a numbers-only report to share (default polygraph.html)
 --json              full results as JSON: findings, unclear reasons, unreadable files (keep it local)
+explain             investigate flagged/uncertain verdicts (--limit, --since, --session, --project)
+doctor              check local hooks, transcript availability and recorder permissions
 --ci                also use GitHub Actions results (goes online, through your gh login)
 --claude-dir <dir>  Claude Code projects dir (default ~/.claude/projects, or $CLAUDE_CONFIG_DIR/projects)
 --codex-dir <dir>   Codex sessions dir (default ~/.codex/sessions, or $CODEX_HOME/sessions)
@@ -209,7 +225,7 @@ npm run benchmark:replay
 npm run benchmark:live
 ```
 
-Before distributing a new version, verify `npm view agent-polygraph version`, the published tarball (`npm pack --dry-run`), and that a clean install really contains the latest privacy and guard fixes. The repository declares version `0.2.0` as the **next release candidate**; until it is published, `npx agent-polygraph` still installs the older public registry version. A green GitHub Actions badge does **not** prove npm has been updated.
+Before distributing a new version, verify `npm view agent-polygraph version`, the published tarball (`npm pack --dry-run`), and that a clean install really contains the latest privacy and guard fixes. The public npm release is currently **0.2.1**. Development on `main` may contain unreleased changes, so `npx agent-polygraph` does not necessarily have the latest GitHub fixes. A green GitHub Actions badge does **not** prove npm has been updated.
 
 ## Privacy
 
@@ -224,7 +240,7 @@ It reads files and works offline. These operations are opt-in:
 
 - `guard` and `record` edit the hook config files they print when you install or uninstall them, and `record --shell` adds or removes one marked line in `~/.bashrc` and `~/.zshrc`.
 - `record` saves snapshots and logs in `~/.agent-polygraph`.
-- `--ci` contacts api.github.com through `gh` and sends repository names and date ranges.
+- `--ci` and `explain --ci` contact api.github.com through `gh` and send repository names and date ranges.
 
 The terminal report and `--json` include excerpts from your sessions. `--html` doesn't.
 

package/bin/polygraph.js

@@ -10,6 +10,15 @@ import { renderHtml } from "../src/report/html.js";
 
 const { version } = createRequire(import.meta.url)("../package.json");
 
+if (process.argv[2] === "explain") {
+  await explainCommand(process.argv.slice(3));
+  process.exit(0);
+}
+if (process.argv[2] === "doctor") {
+  await doctorCommand(process.argv.slice(3));
+  process.exit(0);
+}
+
 if (process.argv[2] === "guard") {
   await guard(process.argv.slice(3));
   process.exit(0);
@@ -43,6 +52,15 @@ Usage: npx agent-polygraph [options]
   -h, --help          show this help
   -v, --version       show the version
 
+Investigate evidence (read-only):
+  npx agent-polygraph explain [--limit 10] [--since 7d] [--project name]
+      --session <prefix>  filter claims by session ID prefix
+      --agent claude|codex  select agent (repeatable)
+      --ci                  optionally enrich with GitHub Actions evidence (network)
+  npx agent-polygraph doctor [--agent claude|codex] [--ci]
+      Check local transcripts, hook configuration and recorder permissions.
+      --ci optionally checks GitHub CLI authentication (may contact GitHub).
+
 Guard (stop unbacked "tests pass" claims as they happen):
 
   npx agent-polygraph guard --install            add a Stop hook to this project (.claude/, .codex/)
@@ -59,6 +77,70 @@ Record (more evidence than the logs carry; stays on this machine):
   npx agent-polygraph record --uninstall [--global] [--shell]
 `;
 
+async function explainCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      since: { type: "string" },
+      project: { type: "string" },
+      session: { type: "string" },
+      agent: { type: "string", multiple: true },
+      limit: { type: "string", default: "10" },
+      ci: { type: "boolean" },
+      demo: { type: "boolean" },
+      "claude-dir": { type: "string" },
+      "codex-dir": { type: "string" },
+    },
+  });
+  const agents = values.agent?.map((s) => s.toLowerCase());
+  if (agents?.some((a) => !["claude", "codex"].includes(a))) throw Error("--agent must be claude or codex");
+  const limit = Number(values.limit);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000) throw Error("--limit must be an integer from 1 to 1000");
+  const since = parseSince(values.since);
+  if (values.since && !since) throw Error("--since must be a date or age such as 7d");
+  let roots = { claude: values["claude-dir"], codex: values["codex-dir"] };
+  let demoDir = null;
+  if (values.demo) {
+    const { makeDemo } = await import("../src/demo.js");
+    const d = makeDemo();
+    demoDir = d.root;
+    roots = { claude: d.claudeDir, codex: d.codexDir };
+  }
+  let ci;
+  if (values.ci && !values.demo) {
+    const { checkGh, makeCi } = await import("../src/ci.js");
+    await checkGh();
+    ci = makeCi();
+  }
+  try {
+    const sessions = await scan({
+      agents, since, project: values.project, roots, records: !values.demo,
+      enrich: ci?.enrich,
+    });
+    const { renderExplanations } = await import("../src/explain.js");
+    console.log(renderExplanations(sessions, { limit, sessionId: values.session }));
+  } finally {
+    if (demoDir) fs.rmSync(demoDir, { recursive: true, force: true });
+  }
+}
+
+async function doctorCommand(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      agent: { type: "string", multiple: true },
+      ci: { type: "boolean" },
+      "claude-dir": { type: "string" },
+      "codex-dir": { type: "string" },
+    },
+  });
+  const agents = values.agent?.map((s) => s.toLowerCase()) || ["claude", "codex"];
+  if (agents.some((a) => !["claude", "codex"].includes(a))) throw Error("--agent must be claude or codex");
+  const { diagnose, renderDoctor } = await import("../src/doctor.js");
+  const checks = await diagnose({ agents, checkCi: values.ci, roots: { claude: values["claude-dir"], codex: values["codex-dir"] } });
+  console.log(renderDoctor(checks));
+}
+
 async function record(argv) {
   const { values } = parseArgs({
     args: argv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-polygraph",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Check your coding agents' \"tests pass\" claims against what actually ran. Reads Claude Code and Codex session logs locally.",
   "type": "module",
   "bin": {

package/src/analyze.js

@@ -236,7 +236,7 @@ export function analyzeSession(session) {
       const forSha = before.filter((r) => r.sha === sha);
       if (forSha.some((r) => r.completed && r.completed <= ev.ts && r.conclusion === "failure")) verdict = "failed";
       else if (forSha.some((r) => !r.completed || r.completed > ev.ts)) [verdict, why] = ["unknown", "CI still running"];
-      else if (forSha.every((r) => ["success", "skipped", "neutral"].includes(r.conclusion))) verdict = "backed";
+      else if (forSha.every((r) => r.conclusion === "success")) verdict = "backed";
       else [verdict, why] = ["unknown", "CI run didn't finish normally"];
     }
     s.claims[verdict]++;
@@ -355,6 +355,11 @@ export function analyzeSession(session) {
         // "the full suite passes" to the latest run as large as the session's full runs.
         // Without such a hint, the latest run.
         const ref = referencedRun(claim, runs, lastTest) || lastTest;
+        // A passing targeted test cannot, by itself, verify an explicit
+        // "full suite passes" claim. When scope isn't established, abstain.
+        const focusedOnly = claimsFullSuite(claim) && ref &&
+          !(runs.get(ref.i)?.full ?? ref.full) &&
+          ![...runs.values()].some((r) => r.full && sameDir(r.dir, ref.dir));
         let staleEdit = ref && codeEdits.findLast((e) => e.i > ref.i && within(e.abs, ref.dir));
         // a change we couldn't follow, settled by comparing `record` snapshots of the
         // working tree after the run and after the change
@@ -384,6 +389,7 @@ export function analyzeSession(session) {
           verdict = pendingTest >= 0 || !lastCodeEdit ? "unknown" : "no-run";
           if (verdict === "unknown") why = pendingTest >= 0 ? "test still running" : "no code work in session";
         } else if (staleEdit) verdict = "stale";
+        else if (focusedOnly) [verdict, why] = ["unknown", "no full-suite test run observed"];
         else if (uncertain) [verdict, why] = ["unknown", "unresolved file change after the run"];
         // a subagent's failing run in its own worktree says little about the main checkout
         else if (ref.outcome === "fail") [verdict, why] = ref.sub ? ["unknown", "subagent run failed"] : ["failed"];
@@ -501,7 +507,12 @@ function referencedRun(claim, runs, latest) {
  * size. Judged by the counts runners printed, never by the command (too unreliable).
  */
 function fullSuiteRun(runs, latest) {
-  if (!latest || latest.count == null) return null;
+  if (!latest) return null;
+  // Prefer command-level evidence of full-suite coverage when we have it.
+  // This works even if test output omitted a reliable pass count.
+  const explicit = [...runs.values()].filter((r) => r.full && sameDir(r.dir, latest.dir));
+  if (explicit.length) return explicit.reduce((a, b) => (b.i > a.i ? b : a));
+  if (latest.count == null) return null;
   const same = [...runs.values()].filter((r) => r.count != null && !r.external && sameDir(r.dir, latest.dir));
   const max = Math.max(...same.map((r) => r.count));
   // a different command, and under half the size: a focused run, not the suite shrinking

package/src/ci.js

@@ -82,17 +82,36 @@ export function makeCi({ gh = ghApi } = {}) {
     return runsCache.get(key);
   };
 
-  /** Does this workflow run tests (a job or step named like one)? */
-  const runsTests = async (repo, r) => {
-    if (TEST_STEP.test(r.name)) return true;
+  /** Determine whether test jobs or test steps *actually* passed or failed.
+   * A test-named workflow is not evidence if its test job was skipped.
+   * Unavailable, incomplete and neutral results are not proof of a pass.
+   */
+  const testVerdict = async (repo, r) => {
     if (!jobsCache.has(r.id)) {
       jobsCache.set(
         r.id,
         (async () => {
-          stats.requests++;
-          const data = await gh(`repos/${repo}/actions/runs/${r.id}/jobs`, { per_page: "50" });
-          return (data?.jobs || []).some((j) => TEST_STEP.test(j.name) || (j.steps || []).some((s) => TEST_STEP.test(s.name)));
-        })().catch(() => false),
+          const results = [];
+          for (let page = 1; page <= 5; page++) {
+            stats.requests++;
+            const data = await gh(`repos/${repo}/actions/runs/${r.id}/jobs`, { per_page: "100", page: String(page) });
+            const jobs = data?.jobs || [];
+            for (const job of jobs) {
+              const steps = (job.steps || []).filter((step) => TEST_STEP.test(step.name || ""));
+              if (steps.length) {
+                for (const step of steps) results.push(step.conclusion || null);
+              } else if (TEST_STEP.test(job.name || "")) {
+                // For a test-named job, the job result itself is evidence.
+                results.push(job.conclusion || null);
+              }
+            }
+            if (jobs.length < 100) break;
+          }
+          if (!results.length) return null;
+          if (results.some((v) => v === "failure" || v === "timed_out")) return "fail";
+          if (results.every((v) => v === "success")) return "pass";
+          return "unknown";
+        })().catch(() => "unknown"),
       );
     }
     return jobsCache.get(r.id);
@@ -156,12 +175,17 @@ export function makeCi({ gh = ghApi } = {}) {
         forPush = forPush.filter((r) => r.sha === first);
       }
       const tests = [];
-      for (const r of forPush) if (await runsTests(p.repo, r)) tests.push(r);
+      for (const r of forPush) {
+        if (!r.completed || ["skipped", "neutral", "startup_failure", "cancelled"].includes(r.conclusion)) continue;
+        const testOutcome = await testVerdict(p.repo, r);
+        if (testOutcome) tests.push({ ...r, testOutcome });
+      }
       if (!tests.length) continue;
-      if (!tests.every((r) => r.completed)) continue; // still running when we looked: no result to use
-      const failed = tests.some((r) => r.conclusion === "failure" || r.conclusion === "timed_out");
-      const passed = tests.every((r) => ["success", "skipped", "neutral"].includes(r.conclusion));
-      if (!failed && !passed) continue; // cancelled, or GitHub never started it (startup_failure)
+      // A failed test step is definitive. All selected test results must be
+      // successful before we can back a claim.
+      const failed = tests.some((r) => r.testOutcome === "fail");
+      const passed = tests.every((r) => r.testOutcome === "pass");
+      if (!failed && !passed) continue; // unavailable, skipped or inconclusive test steps
       const finished = Math.max(...tests.map((r) => r.completed));
       const label = `CI: ${[...new Set(tests.map((r) => r.name))].join(", ")} (${tests[0].sha.slice(0, 7)})`;
       // the run starts at the push: edits after it aren't in the pushed commit

package/src/doctor.js

@@ -0,0 +1,94 @@
+// Read-only diagnostic for transcript discovery, hook wiring and local recorder paths.
+// Never prints transcript contents, credentials, or raw hook payloads.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { SOURCES } from "./scan.js";
+import { isOurHook, targets } from "./guard.js";
+import { readSettings } from "./safe-config.js";
+import { home as recordHome } from "./record.js";
+
+function checkConfig(file, sub) {
+  try {
+    const { text } = readSettings(file);
+    if (text === null) return "not installed";
+    const cfg = JSON.parse(text);
+    const event = sub === "guard" ? "Stop" : "PostToolUse";
+    const hooks = (cfg.hooks?.[event] || []).flatMap((g) => g.hooks || []);
+    return hooks.some((h) => isOurHook(h, sub)) ? "installed" : "not installed";
+  } catch (e) {
+    return `ERROR: invalid or unsafe settings (${e.code || e.name || "error"})`;
+  }
+}
+
+/** Diagnose local files without mutating settings or running any tests. */
+export async function diagnose({ cwd = process.cwd(), roots = {}, agents = ["claude", "codex"], sample = 2, checkCi = false } = {}) {
+  const checks = [];
+  for (const agent of agents) {
+    const src = SOURCES[agent];
+    if (!src) continue;
+    const root = roots[agent] || src.defaultRoot();
+    let entries;
+    try { entries = src.discover(root); }
+    catch (e) {
+      checks.push({ kind: "warn", message: `${agent}: cannot list transcripts (${e.code || e.name})` });
+      continue;
+    }
+    checks.push({ kind: entries.length ? "ok" : "info", message: `${agent}: ${entries.length} session file(s) discovered in ${root}` });
+    if (entries.length) {
+      const latest = entries.sort((a, b) => b.mtime - a.mtime).slice(0, sample);
+      let unsupported = 0, unreadable = 0;
+      for (const entry of latest) {
+        try { if ((await src.parse(entry)).unrecognized) unsupported++; }
+        catch { unreadable++; }
+      }
+      checks.push({ kind: unsupported || unreadable ? "warn" : "ok", message:
+        `${agent}: sampled ${latest.length} session(s); ${unsupported} unrecognized formats, ${unreadable} unreadable` });
+    }
+    for (const global of [false, true]) {
+      const files = targets({ agents: [agent], global, cwd });
+      for (const { file } of files) {
+        const status = checkConfig(file, "guard");
+        checks.push({ kind: status.startsWith("ERROR") ? "warn" : status === "installed" ? "ok" : "info",
+          message: `${agent}: ${global ? "global" : "project"} guard ${status} (${file})` });
+        const record = checkConfig(file, "record");
+        checks.push({ kind: record.startsWith("ERROR") ? "warn" : record === "installed" ? "ok" : "info",
+          message: `${agent}: ${global ? "global" : "project"} recorder ${record}` });
+      }
+    }
+  }
+  const dir = recordHome();
+  try {
+    const st = fs.lstatSync(dir);
+    const linked = st.isSymbolicLink() || !st.isDirectory();
+    const shared = process.platform !== "win32" && (st.mode & 0o077) !== 0;
+    checks.push({ kind: linked || shared ? "warn" : "ok", message:
+      linked ? "Local recorder directory is not a safe regular directory" :
+      shared ? "Local recorder directory permits group/other access" :
+      `Local recorder directory exists (${dir})` });
+  } catch (e) {
+    checks.push({ kind: e.code === "ENOENT" ? "info" : "warn", message:
+      e.code === "ENOENT" ? "Local recorder not initialized (optional)" : `Local recorder inaccessible (${e.code || e.name})` });
+  }
+  if (checkCi) {
+    // Explicit opt-in: checking gh login can contact GitHub, unlike the default doctor.
+    try {
+      const { checkGh } = await import("./ci.js");
+      await checkGh();
+      checks.push({ kind: "ok", message: "GitHub CLI authentication available for --ci" });
+    } catch (e) {
+      checks.push({ kind: "warn", message: `GitHub CLI authentication unavailable for --ci: ${e.message}` });
+    }
+  }
+  return checks;
+}
+
+export function renderDoctor(checks) {
+  const severity = { ok: "OK", warn: "WARN", info: "INFO" };
+  const warnings = checks.filter((c) => c.kind === "warn").length;
+  return ["agent-polygraph doctor — read-only, local diagnostics",
+    ...checks.map((c) => `[${severity[c.kind] || "INFO"}] ${c.message}`),
+    "", warnings ? `${warnings} warning(s) require investigation.` : "No diagnostic warnings in the checks performed.",
+    "Not-installed hooks are optional; a plugin can supply a separate guard.",
+    "This is not a security audit or a substitute for checking actual claim evidence."].join("\n");
+}

package/src/explain.js

@@ -0,0 +1,49 @@
+import { AGENT_NAMES } from "./report/format.js";
+
+const LABELS = {
+  "no-run": "No recognized test run",
+  stale: "Test result is stale",
+  failed: "Latest relevant test failed",
+  unknown: "Insufficient evidence",
+};
+
+const when = (ms) => Number.isFinite(ms) ? new Date(ms).toISOString() : "time unavailable";
+const printable = (s, n = 240) => String(s ?? "").replace(/[\r\n\t]+/g, " ").slice(0, n);
+
+/**
+ * Human-readable, local-only explanation of existing verdict evidence.
+ * No commands are executed and no raw transcripts are uploaded.
+ * Only recorded findings can be explained; backed claims have no finding.
+ */
+export function renderExplanations(sessions, { limit = 10, sessionId = null } = {}) {
+  const selected = sessions.filter((s) => !sessionId || s.id.startsWith(sessionId));
+  const entries = selected.flatMap((s) => (s.findings || [])
+    .filter((f) => f.type === "claim" || f.type === "unclear")
+    .map((f) => ({ s, f })))
+    .sort((a, b) => (b.f.ts || 0) - (a.f.ts || 0));
+  const count = Math.max(0, Math.trunc(limit));
+  const lines = ["agent-polygraph explain — local evidence, not proof that code is correct",
+    `Sessions: ${selected.length}; flagged or uncertain claims: ${entries.length}`];
+  if (!entries.length) {
+    lines.push("No flagged/uncertain claims found. Backed claims are counted in the main report, not listed here.");
+    return lines.join("\n");
+  }
+  for (const { s, f } of entries.slice(0, count)) {
+    const d = f.detail || {};
+    const verdict = f.type === "unclear" ? "unknown" : d.verdict;
+    lines.push("", `[${LABELS[verdict] || verdict || "Unclassified"}] ${when(f.ts)} · ${AGENT_NAMES[s.agent] || s.agent} · session ${s.id}`);
+    lines.push(`  Claim: ${printable(d.claim)}`);
+    if (d.lastTest) {
+      const lt = d.lastTest;
+      const at = typeof lt.ago === "number" && Number.isFinite(f.ts) ? when(f.ts - lt.ago) : "time not recorded";
+      lines.push(`  Test evidence: ${printable(lt.cmd, 200)} · ${lt.outcome || "outcome unknown"} · ${at}`);
+    } else lines.push("  Test evidence: none identified");
+    if (d.editedAfter) lines.push(`  Subsequent edit: ${printable(d.editedAfter, 180)}`);
+    if (d.why) lines.push(`  Missing evidence: ${printable(d.why)}`);
+    if (d.ci) lines.push("  Source: optional GitHub Actions evidence");
+    if (s.file) lines.push(`  Transcript (private): ${s.file}`);
+  }
+  if (entries.length > count) lines.push("", `Showing ${count} of ${entries.length} claims; increase --limit to see more.`);
+  lines.push("", "Contains transcript excerpts and local file paths. Review before sharing.");
+  return lines.join("\n");
+}