@sanning/proof 0.19.0 → 0.20.0

package/src/cli.ts

@@ -1,48 +1,18 @@
 #!/usr/bin/env node
 // sanning-proof verify <bundle.json> [--gateways <url,url>]
-// (`npx @sanning/proof verify ...` without installing: npm runs a package's
-// only binary whatever it is called.)
 //
-// One turnkey verifier for both producer bundles in the stack:
-//   - sanning.evidence/v1: bodies sanning.anchor.trace/v3, sanning.stamp.trace/v1,
-//     sanning.stamp.evidence/v2 and sanning.evidence.export/v2
-//   - sanning.agent.proof/v1: the agent inclusion proof
-// Dispatch is by sniffed spec_version; no flag tells the CLI which it is.
+// Verifies sanning.evidence/v1 bundles (bodies sanning.anchor.trace/v3,
+// sanning.stamp.trace/v1, sanning.stamp.evidence/v2, sanning.evidence.export/v2).
 //
-// Exit codes: one table for every verb, `./exit-codes.ts` (0.13.0):
-//   0  verified, or the export was written
-//   1  failed (bad signature / tamper / broken inclusion / on-chain mismatch)
-//   2  usage or malformed (unparseable, unknown spec major, body_hash mismatch)
-//   3  UNDETERMINED: partial, pending, incomplete or not_found. A gateway that
-//      could not be reached reads `partial`; a pack whose records nobody hashed
-//      reads `incomplete` (see below)
-//   4  mixed
-//   5  sandbox: a record is signed environment dev; would be 0, or only a
-//      simulated witness is unchecked (`sandboxExit`)
-// `sanningd verify-status` in sanning-io/agent mirrored the 0.12 table, which
-// exited 0 on `partial`; it moves with this one.
+// Exit codes, one table for every verb (`./exit-codes.ts`): 0 verified, 1 failed,
+// 2 incomplete, 3 verified sandbox evidence (a record is signed environment dev),
+// 4 could not run. 2 is not a failure: a withheld record or bytes nobody handed
+// over are not proven, never disproven.
 //
-// ── The headline is the PACK verdict, not the bundle status (proof#110) ──
-//
-// This command used to print `result.status` as its headline and map it to an
-// exit code directly. That is the verdict on the signed BUNDLE, and it is not
-// the verdict the rest of the product prints. `gradePack` in `./grading.ts` is
-// the kernel's one rule for what a verification SURFACE may claim about a pack,
-// the browser verify page calls it, and this command referenced it zero times.
-// So the same file read `Incomplete` on the page and `VERIFIED`, exit 0, at the
-// terminal: two answers to one question, from one kernel, which is the exact
-// defect `grading.ts` was brought into the kernel to end.
-//
-// The two layers stay distinct, deliberately (`grading.ts` says so in its own
-// comments, and `incomplete` is a pack verdict in `evidence-bundle.md` §3,
-// never a bundle status): the BUNDLE status is still reported, unchanged, on
-// its own line. What changed is
-// which of the two is the headline and which one the exit code follows.
-//
-// `payloadHashOk === null` (a withheld record) is semantics-undetermined and
-// surfaces as a per-event note, and it does NOT fail the run. It does hold the
-// PACK at `incomplete`, because a record nobody hashed is a record nobody
-// checked, and exit 3 is how this command says "undetermined".
+// The headline is the pack verdict, read off the six claims (`claims.ts`), the
+// same rule the verify page prints. The report prints the person layer first
+// (the title, one line per claim that is not proven, the next action, the notes,
+// the sandbox line and the witness line), then the detail.
 
 import { lstat, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { constants as fsConstants, realpathSync } from "node:fs";
@@ -50,12 +20,11 @@ import { createHash, randomBytes } from "node:crypto";
 import { basename, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { isAgentProofSpec, verifyAgentProof } from "./agent-proof.js";
-import type { AgentProofResult } from "./agent-proof.js";
+import { renderAgentReading, type AgentRecordReading } from "./agent-record.js";
+
 import { CHAIN_READING_SCOPE, readChainLinks, readChains, renderChainFinding } from "./chain.js";
 
-// What this command holds after asking for a chain reading: the reading, or a
-// named statement that one could not be produced. Three states, not two.
+// The reading, or a named statement that one could not be produced.
 type ChainOutcome = ChainReading | { unreadable: string };
 import type { ChainLink, ChainReading } from "./chain.js";
 import {
@@ -66,6 +35,7 @@ import {
   renderCaseSummary,
   renderException,
   renderWitnessLine,
+  type WitnessLine,
 } from "./case.js";
 import {
   CASE_FILE_INDEX_NAME,
@@ -80,9 +50,6 @@ import { composeExport } from "./compose.js";
 import type { ComposeExportOptions } from "./compose.js";
 import { isHexField, sha256Hex, utf8 } from "./crypto.js";
 import { verifyEvidenceBundle } from "./evidence.js";
-import { readRuns, renderAccountLine, renderEnclaveLines } from "./run.js";
-import type { RunReading } from "./run.js";
-import { loadInstalledAdapters } from "./run-adapters.js";
 import { DuplicateKeyError, parseRefusingDuplicates } from "./verifier.js";
 import {
   fileMatchToJson,
@@ -97,36 +64,46 @@ import {
   WITNESS_CACHE_NAME,
   readWitnessCache,
 } from "./witness-cache.js";
-// The public-record (witness) lookup this command runs with `--gateways`:
-// moved to its own pure module (proof#200) so a consumer that is not this CLI,
-// the verify page, can call the SAME implementation. `onChainHalf` and
-// `witnessLine` are this command's own two building blocks, unchanged; see
-// `./witness-lookup.ts` for the exported entry point, `lookupPublicRecord`.
-import { type OnChainHalf, onChainHalf, witnessLine } from "./witness-lookup.js";
-import type { AttestationRecord, EvidenceBundle, EvidenceBundleResult, ExportResult } from "./evidence.js";
+import {
+  type OnChainHalf,
+  onChainHalf,
+  onChainOutcome,
+  onChainRow,
+  witnessLine,
+} from "./witness-lookup.js";
+import type { AttestationRecord, EvidenceBundle, EvidenceBundleResult } from "./evidence.js";
 import { checkDeclaration, renderDeclarationSummary, renderNote } from "./declaration.js";
 import { completenessNotes, gradePack, renderCause } from "./grading.js";
-import type { DisclosureAccount, PackGrade } from "./grading.js";
+import type { DisclosureAccount, PackGrade, PackGradeCause } from "./grading.js";
 
 import {
   EXIT_CODES_HELP,
+  EXIT_COULD_NOT_RUN,
   EXIT_FAILED,
-  EXIT_MALFORMED,
-  EXIT_SANDBOX,
-  EXIT_UNDETERMINED,
   EXIT_VERIFIED,
   exitCodeFor,
-  sandboxExit,
 } from "./exit-codes.js";
+import { type EnvironmentMarker, environmentMarker, simulatedOnlyRun } from "./environment.js";
 import {
-  type EnvironmentMarker,
-  environmentMarker,
-  onlySimulatedUnsettled,
-  simulatedOnlyRun,
-  SANDBOX_HEADLINE,
-  SANDBOX_LINE,
-  SANDBOX_TITLE,
-} from "./environment.js";
+  VERDICT_TITLES,
+  bundleProblems,
+  claimsOf,
+  note,
+  type NoteEntry,
+  type Claim,
+  type NotInScopeReason,
+  orderedNotes,
+  personText,
+  problem,
+  renderFindingNote,
+  renderPerson,
+  restOnSigned,
+  verdictOf,
+  type ClaimEntry,
+  type Person,
+  type Problem,
+  type VerdictJson,
+} from "./claims.js";
 
 interface Cli {
   out: (s: string) => void;
@@ -134,25 +111,20 @@ interface Cli {
   fetchImpl?: typeof fetch;
 }
 
-// ── What a person reads is escaped at one choke point ──
-//
-// Every human-readable line this command prints passes through `guard`, which
-// `runCli` and `runCase` apply to the streams they are handed. It escapes each
-// control character, so a value the audited party wrote (a folder or file
-// name, a `contents.json` field, a zip entry name, an exception built from
-// one) cannot move the cursor, clear the screen or reorder the line. Before
-// this, a case file whose name carried `\x1b[2J\x1b[H` printed "Verified" over
-// a FAILED headline. `outJson` is the one way around it, and it carries JSON
-// only, which escapes its own control characters. The twin is `Io` in
-// `src/sanning_proof/cli.py`, and the two print byte-identical escapes.
+// Every human-readable line passes through `guard`, which escapes control
+// characters, so a value the audited party wrote (a file name, a zip entry, a
+// field) cannot move the cursor or overwrite a headline. `outJson` is the one
+// way around it, and JSON escapes its own control characters. Python's `Io` in
+// `cli.py` prints byte-identical escapes.
 
 // C0, DEL, C1, the two Unicode line and paragraph separators, and the bidi
 // embedding, override and isolate controls.
 const CONTROL_CHARACTERS = /[\x00-\x1f\x7f-\x9f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
 
-/** Each control character in `text` as a visible escape: `\x1b` for ESC,
- * `\u202e` for RIGHT-TO-LEFT OVERRIDE. Every other character is unchanged, a
- * backslash included, so a line with none is printed as it was. */
+/**
+ * Each control character in `text` as a visible escape (`\x1b`, `‮`).
+ * Every other character, a backslash included, is unchanged.
+ */
 export function escapeControl(text: string): string {
   return text.replace(CONTROL_CHARACTERS, (c) => {
     const code = c.charCodeAt(0);
@@ -162,16 +134,12 @@ export function escapeControl(text: string): string {
   });
 }
 
-// The colors this command writes on a TTY are its own control characters, and
-// the choke point would escape them with everything else. So `paint` and
-// `mark` write this marker instead, and the choke point turns it into ESC
-// after escaping. It is random per process, so no input can spell it.
+// `paint` and `mark` write this marker instead of ESC, so the escaping choke
+// point does not escape our own colors; it becomes ESC after escaping. Random
+// per process, so no input can spell it.
 const COLOR_MARK = `sgr${randomBytes(16).toString("hex")}:`;
 const G = `${COLOR_MARK}32m`;
 const R = `${COLOR_MARK}31m`;
-const Y = `${COLOR_MARK}33m`;
-const DIM = `${COLOR_MARK}2m`;
-const B = `${COLOR_MARK}1m`;
 const X = `${COLOR_MARK}0m`;
 
 function forTerminal(text: string): string {
@@ -201,8 +169,7 @@ function outJson(io: Cli, text: string): void {
   rawOf(io).out(text);
 }
 
-/** A block this command wrote itself, such as a usage text: its own newlines
- * are kept, and each line is escaped as `out` escapes it. */
+/** A block this command wrote itself: its newlines are kept, each line escaped. */
 function outBlock(io: Cli, text: string): void {
   rawOf(io).out(text.split("\n").map(forTerminal).join("\n"));
 }
@@ -213,13 +180,6 @@ function useColor(): boolean {
   return Boolean(process.stdout.isTTY);
 }
 
-function mark(ok: boolean | null): string {
-  const c = useColor();
-  if (ok === null) return c ? `${Y}~${X}` : "~";
-  if (ok) return c ? `${G}✓${X}` : "✓";
-  return c ? `${R}✗${X}` : "✗";
-}
-
 function paint(s: string, c: string): string {
   return useColor() ? `${c}${s}${X}` : s;
 }
@@ -230,16 +190,13 @@ export async function runCli(argv: string[], stream: Cli): Promise<number> {
 
   if (command === undefined || command === "help" || command === "--help" || command === "-h") {
     printUsage(io);
-    return command === undefined ? EXIT_MALFORMED : EXIT_VERIFIED;
+    return command === undefined ? EXIT_COULD_NOT_RUN : EXIT_VERIFIED;
   }
   if (command === "version" || command === "--version" || command === "-v") {
     io.out("@sanning/proof verify CLI");
     return EXIT_VERIFIED;
   }
-  // `export` composes an attested export (`sanning.evidence.export/v2`). It
-  // was taught as `bundle` until 0.13.0, and `bundle` is now the one verb that
-  // builds a pack (`anchor bundle`, DL-59), so this command no longer answers
-  // to it: `proof bundle` is an unknown command and exits 2, with no alias.
+  // `export` composes an attested export (`sanning.evidence.export/v2`).
   if (command === "export") {
     if (rest.includes("--json")) {
       return runJson(
@@ -256,7 +213,7 @@ export async function runCli(argv: string[], stream: Cli): Promise<number> {
   if (command !== "verify") {
     io.err(`unknown command: ${command}`);
     printUsage(io);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
   if (rest.includes("--json")) {
     return runJson(
@@ -268,16 +225,10 @@ export async function runCli(argv: string[], stream: Cli): Promise<number> {
   return runVerify(rest, io, null);
 }
 
-// ─── `--json` on `verify` and `export` (C-03, 0.13.0) ──────────────────────
-//
-// `case --json` printed the reading as JSON and the other two verbs had no
-// machine-readable form, so a script parsed the text. Each verb now runs as it
-// does for a person, with its text discarded, and hands this one object back
-// through `sink`: the same keys in both kernels, sorted at every depth, and
-// printed byte for byte the same (`cross-kernel/run_cli.sh`,
-// `cross-kernel/run_export_cli.sh`). A run that stops before it has anything to
-// report (a bad flag, an unreadable file) prints `{ error, exit_code }`, as
-// `case --json` does. `note:` lines still go to stderr.
+// `--json` on `verify` and `export`: the verb runs as for a person with its
+// text discarded, and hands one object back through `sink`. Same keys in both
+// kernels, sorted at every depth, printed byte for byte the same. A run that
+// stops early prints `{ error, exit_code }`. `note:` lines still go to stderr.
 interface JsonSink {
   data: Record<string, unknown> | null;
 }
@@ -306,23 +257,25 @@ async function runJson(rest: string[], io: Cli, verb: JsonVerb): Promise<number>
 
 async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promise<number> {
 
-  // `--logs <path>` feeds disclosed raw-log bytes for content verification
-  // (the evidence-bundle path only); `--gateways <url,url>` asks for the
-  // on-chain re-fetch, as it does on `case` (0.13.0: the gateway list was a
-  // second positional argument until then, and a second positional is now a
-  // usage error). The one positional is the bundle.
+  // `--logs <path>` supplies disclosed raw-log bytes (evidence-bundle path
+  // only); `--gateways <url,url>` asks for the on-chain re-fetch. The one
+  // positional is the bundle.
   let logsPath: string | undefined;
   let filePaths: string[] | undefined;
   let gatewayArg: string | undefined;
   const positional: string[] = [];
   for (let i = 0; i < rest.length; i++) {
     const a = rest[i]!;
+    if ((a === "--help" || a === "-h") && positional.length === 0) {
+      printUsage(io);
+      return EXIT_VERIFIED;
+    }
     if (a === "--gateways") {
       const next = rest[i + 1];
       if (next === undefined) {
         io.err("verify: --gateways requires a comma-separated list of URLs");
         printUsage(io);
-        return EXIT_MALFORMED;
+        return EXIT_COULD_NOT_RUN;
       }
       gatewayArg = next;
       i++;
@@ -333,7 +286,7 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
       if (next === undefined) {
         io.err("verify: --logs requires a path (a logs directory, or a JSON map file)");
         printUsage(io);
-        return EXIT_MALFORMED;
+        return EXIT_COULD_NOT_RUN;
       }
       logsPath = next;
       i++;
@@ -344,7 +297,7 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
       if (taken.length === 0) {
         io.err("verify: --files requires at least one file path");
         printUsage(io);
-        return EXIT_MALFORMED;
+        return EXIT_COULD_NOT_RUN;
       }
       filePaths = [...(filePaths ?? []), ...taken];
       i += taken.length;
@@ -357,12 +310,12 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
   if (!bundlePath) {
     io.err("verify: a bundle file path is required");
     printUsage(io);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
   if (positional.length > 1) {
     io.err("verify: takes one bundle; pass gateways as --gateways <url,url>");
     printUsage(io);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
   const gateways = (gatewayArg ?? "")
     .split(",")
@@ -372,7 +325,7 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
   let logs: LoadedLogs | undefined;
   if (logsPath !== undefined) {
     logs = await loadLogs(logsPath, io);
-    if (logs === undefined) return EXIT_MALFORMED;
+    if (logs === undefined) return EXIT_COULD_NOT_RUN;
     for (const n of logs.notes) io.err(`note: ${n}`);
   }
   const content = logs?.content;
@@ -383,7 +336,7 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
     const read = await readOfferedFiles(filePaths);
     if (typeof read === "string") {
       io.err(`verify: ${read}`);
-      return EXIT_MALFORMED;
+      return EXIT_COULD_NOT_RUN;
     }
     offered = read.offered;
     skipped = read.skipped;
@@ -394,12 +347,10 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
     raw = new Uint8Array(await readFile(bundlePath));
   } catch (e) {
     io.err(`cannot read ${bundlePath}: ${e instanceof Error ? e.message : String(e)}`);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
 
-  // The one reader both commands use, in both kernels: `case` reads each pack's
-  // bundle.json through it too, so the two commands classify one bundle the
-  // same way (see `readBundleBytes`).
+  // The same reader `case` uses, so both commands classify a bundle alike.
   let parsed: unknown;
   try {
     parsed = readBundleBytes(raw);
@@ -411,79 +362,62 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
     } else {
       io.err(`${bundlePath} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
-
-  const specVersion =
-    parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as { spec_version?: unknown }).spec_version
-      : undefined;
-
-  if (isAgentProofSpec(specVersion)) {
-    if (content) {
-      // --logs binds raw logs to anchor-trace events; an agent inclusion proof
-      // has no such per-event content. Say so rather than silently ignoring it.
-      io.err("note: --logs has no effect on a sanning.agent.proof/v1 bundle (ignored)");
-    }
-    if (offered) {
-      io.err("note: --files has no effect on a sanning.agent.proof/v1 bundle (ignored)");
-    }
-    const result = await verifyAgentProof(parsed, {
-      gateways,
-      ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}),
-    });
-    return reportAgentProof(result, bundlePath, gateways, io, sink, parsed);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    // Not a pack at all: nothing in it names a claim to read.
+    io.err(`${bundlePath} is not an evidence bundle: not a JSON object`);
+    return EXIT_COULD_NOT_RUN;
   }
 
-  // Default: treat anything else as an evidence bundle. verifyEvidenceBundle
-  // rejects an unknown major as "malformed" so a genuinely unknown shape still
-  // exits 2 with a clear message.
+  // An evidence bundle; an unknown major is unreadable, and incomplete.
   const result = await verifyEvidenceBundle(parsed, {
     gateways,
     ...(content ? { content } : {}),
     ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}),
   });
-  // Read the chains from the SAME parsed bundle the verifier saw. Findings are
-  // evidence about the records in front of us, not a verdict: they are printed
-  // and they move `exit` only through the pack's own declaration, where a v3
-  // declaration claims a chain complete and in order and a finding under that
-  // claim contradicts it (rule 11). Without a claim a chain is not a
-  // completeness proof, and an exit code is exactly the kind of thing people
-  // read as one.
-  //
-  // A READING THAT COULD NOT BE PRODUCED SAYS SO. This was an unguarded call:
-  // a throw out of `readChains` would have escaped the command entirely and
-  // exited 1, which is the code for "failed" and would have named the
-  // customer's evidence tampered over a fault in this reader. The Python twin
-  // had the opposite half of the same defect and swallowed the throw into "no
-  // event chain was found to follow in this bundle" (the gate on proof#154).
-  // Neither kernel is entitled to either answer, so both now print the third.
+  // The same pack read without the bytes handed in beside it, so a disproof that only those
+  // bytes make reads as not proven (evidence-bundle.md section 5.1).
+  // Offline: what the public record holds does not turn on the bytes beside the pack.
+  const bare = content ? await verifyEvidenceBundle(parsed) : null;
+  // Chain findings are evidence, not a verdict: they move `exit` only through a
+  // v3 declaration's chain claim (rule 11). A reading that cannot be produced
+  // says so, rather than exiting 1 (failed) over a fault in this reader.
   let chains: ChainOutcome;
   try {
     chains = await readChains(parsed);
   } catch (e) {
     chains = { unreadable: errMsg(e) };
   }
-  // The links rule 11 holds a claimed chain to (evidence-bundle.md 5.4.2), from
-  // the same parsed bundle. Links that cannot be read are none, which reads a
-  // claim UNKNOWN and never clean.
+  // Links for rule 11. Unreadable links are none, which reads a claim unknown,
+  // never clean.
   let links: ChainLink[] | null;
   try {
     links = "unreadable" in chains ? null : await readChainLinks(parsed);
   } catch {
     links = null;
   }
-  const exit = reportEvidence(result, bundlePath, gateways, io, chains, links, parsed, logs, sink);
-  // Files handed in beside the pack (evidence-bundle.md 5.7, A29): findings
-  // beside the verdict, never inside it, so `exit` is untouched.
+  const exit = reportEvidence(
+    result,
+    bundlePath,
+    gateways,
+    io,
+    chains,
+    links,
+    parsed,
+    logs,
+    sink,
+    bare,
+  );
+  // Files handed in beside the pack (evidence-bundle.md §5.7): findings beside
+  // the verdict, never inside it.
   if (offered !== undefined) {
     const reading = { ...(await matchFiles(parsed, offered, content)), skipped };
     for (const line of renderFileMatch(reading)) io.out(line);
     if (sink !== null && sink.data !== null) sink.data.files = fileMatchToJson(reading);
   }
-  // Coverage is reported only once the bundle parsed far enough to have events
-  // to compare against; over a MALFORMED bundle there is nothing to say.
-  if (logs && result.status !== "malformed") reportLogsCoverage(logs, result, io);
+  // Over a malformed bundle there are no events to compare against.
+  if (logs && result.unreadable !== true) reportLogsCoverage(logs, result, io);
   return exit;
 }
 
@@ -497,35 +431,30 @@ function takeFilePaths(args: readonly string[], start: number): string[] {
   return out;
 }
 
-// A file is hashed in pieces this big, so a file is read without being held.
 const HASH_CHUNK = 1 << 20;
 
-// The most a command reads from the files it finds in folders it was handed, in
-// all: the cap the zip reader puts on an archive. A file that would push the
-// total past it is skipped as `too_large` and never read past it, so a sparse
-// file of a terabyte cannot hold a command for hours (A41). A file a person
-// names on the command line is the person's choice and is read at any size.
+// The total a command reads from files found in folders it was handed. A file
+// that would pass it is skipped as `too_large` unread, so a sparse terabyte
+// cannot stall the command. A file named on the command line is read at any
+// size.
 export const MAX_FOLDER_BYTES = MAX_ZIP_BYTES;
 
-// What `hashFile` returns for a file that would push the total past the cap.
 export const TOO_LARGE = "too_large";
 
-// A child of a folder, by concatenation. `path.join` collapses `link/..`
-// lexically, where the operating system, and the Python command, resolve it
-// on disk: the same typed path then names two different folders (proof#219).
+// By concatenation: `path.join` collapses `link/..` lexically, while the OS and
+// the Python command resolve it on disk.
 function childPath(directory: string, name: string): string {
   return directory.endsWith("/") ? `${directory}${name}` : `${directory}/${name}`;
 }
 
 // The SHA-256 of a regular file, read in pieces, or null when it cannot be
-// read. Inside a folder the file is opened without following a link and
-// without blocking, then checked again, so a file swapped for a link or a pipe
-// after the walk listed it is skipped and never followed or waited on. A path a
-// person typed (`follow`) is opened as the shell would.
+// read. Inside a folder the file is opened without following a link or
+// blocking, then rechecked, so a file swapped for a link or pipe is skipped. A
+// typed path (`follow`) is opened as the shell would.
 //
-// `budget` is the bytes still allowed across the folders of a run. A file
-// larger than it returns TOO_LARGE before a byte is read, and so does a file
-// that grows past it while it is read; only a file read whole is charged.
+// `budget` is the bytes still allowed across the run's folders. A file larger
+// than it, or one that grows past it while read, returns TOO_LARGE; only a file
+// read whole is charged.
 export async function hashFile(
   path: string,
   follow: boolean,
@@ -563,15 +492,11 @@ export async function hashFile(
   }
 }
 
-// The regular files under a `--files` folder, recursively, hidden files
-// included, into `offered` as `<folder>/<path inside>` in UTF-16 code unit
-// order of that path; a link or anything that is not a regular file, and a
-// file or folder that cannot be read, into `skipped`. Returns the one error
-// line, or null. Iterative, bounded as the case walk is.
-//
-// The files are hashed once the walk is done, in the order they are listed, so
-// which file a full `budget` turns away does not depend on how the walk
-// happened to reach it.
+// The regular files under a `--files` folder, recursively, hidden ones
+// included, into `offered` as `<folder>/<path inside>` in UTF-16 order; links,
+// non-regular and unreadable entries into `skipped`. Returns the one error line,
+// or null. Files are hashed after the walk, in listed order, so which file the
+// budget turns away does not depend on walk order.
 async function walkOfferedFolder(
   typed: string,
   offered: OfferedFile[],
@@ -644,16 +569,12 @@ async function walkOfferedFolder(
   return null;
 }
 
-// Each `--files` path as `{ name, sha256 }`, or the one error line.
-//
-// A path that is a regular file is one file, its name exactly as typed. A path
-// that is a folder stands for the regular files inside it, recursively and
-// hidden files included, each named `<folder as typed>/<path inside>` (A40,
-// proof#214). The rest is returned as `skipped`, named, never dropped. A path
-// that is neither a readable file nor a readable folder is the one error line,
-// which names the path and not the operating system's words, which differ by
-// kernel. A path typed is followed as a shell would; a link found inside a
-// folder is not.
+// Each `--files` path as `{ name, sha256 }`, or the one error line. A file is
+// named as typed; a folder stands for its regular files, recursively, named
+// `<folder as typed>/<path inside>`. The rest is returned as `skipped`, never
+// dropped. A typed path is followed as a shell would; a link inside a folder is
+// not. The error line names the path, not the OS's words, which differ by
+// kernel.
 export async function readOfferedFiles(
   paths: readonly string[],
   cap: number = MAX_FOLDER_BYTES,
@@ -683,15 +604,12 @@ export async function readOfferedFiles(
 
 // `proof export <source-bundle.json> --attestations <f> --key <f> [--out <out>]`
 //
-// Compose a signed, offline-verifiable sanning.evidence.export/v2 artifact from a
-// source sanning.anchor.trace/v3 bundle + operator attestation records + an exporter
-// Ed25519 key (evidence-export.md §5, composer). Writes the export to `--out <out>`
-// (or stdout when omitted, so it can be piped straight into `proof verify`).
+// Compose a signed, offline-verifiable sanning.evidence.export/v2 artifact
+// (evidence-export.md §5). Writes to `--out`, or stdout so it pipes into
+// `proof verify`.
 //
-// Exit codes: 0 composed OK · 1 the recomputed export is FAILED (a bad source or
-// forged/mis-bound attestation — the composer refuses to emit a green artifact
-// over failing evidence) · 2 usage / malformed input (missing flag, unreadable
-// or non-JSON input, bad exporter key, malformed attestation record).
+// Exit codes: 0 composed; 1 the recomputed export is `failed` (the composer never
+// emits a green artifact over failing evidence); 2 usage or malformed input.
 async function runExport(rest: string[], io: Cli, sink: JsonSink | null): Promise<number> {
   if (rest[0] === "--help" || rest[0] === "-h" || rest[0] === "help") {
     usageExport(io);
@@ -743,9 +661,7 @@ async function runExport(rest: string[], io: Cli, sink: JsonSink | null): Promis
       if (v === undefined) return usageExport(io);
       opts.generatedAt = v;
     } else if (a.startsWith("-")) {
-      // A flag this verb does not take is a usage error, never a path: `-o`
-      // was a short form of `--out` until 0.13.0, and read as a path it would
-      // send the export to stdout while the caller waits for a file.
+      // An unknown flag is a usage error, never a path.
       io.err(`export: unknown option ${a}`);
       return usageExport(io);
     } else {
@@ -768,30 +684,28 @@ async function runExport(rest: string[], io: Cli, sink: JsonSink | null): Promis
   }
 
   const sourceBundle = await readJson<EvidenceBundle>(bundlePath, io);
-  if (sourceBundle === undefined) return EXIT_MALFORMED;
+  if (sourceBundle === undefined) return EXIT_COULD_NOT_RUN;
   const attestationsRaw = await readJson<unknown>(attestationsPath, io);
-  if (attestationsRaw === undefined) return EXIT_MALFORMED;
+  if (attestationsRaw === undefined) return EXIT_COULD_NOT_RUN;
   const attestations = coerceAttestations(attestationsRaw);
   if (attestations === undefined) {
     io.err(`export: ${attestationsPath} must be a JSON array of attestation records ` +
       `(or an object with an "attestations" array)`);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
 
   const privateKey = await readExporterKey(keyPath, io);
-  if (privateKey === undefined) return EXIT_MALFORMED;
+  if (privateKey === undefined) return EXIT_COULD_NOT_RUN;
 
   let composed;
   try {
     composed = await composeExport(sourceBundle, attestations, { privateKey }, opts);
   } catch (e) {
-    io.err(`export: cannot compose — ${e instanceof Error ? e.message : String(e)}`);
-    return EXIT_MALFORMED;
+    io.err(`export: cannot compose: ${e instanceof Error ? e.message : String(e)}`);
+    return EXIT_COULD_NOT_RUN;
   }
 
-  // The composer refuses to hand back a green artifact over failing evidence: a
-  // FAILED recompute (bad source / forged / mis-bound attestation) exits 1 and
-  // still writes the artifact so the caller can inspect it.
+  // A `failed` recompute exits 1 and still writes the artifact for inspection.
   const serialized = JSON.stringify(composed.bundle, null, 2) + "\n";
   if (sink) {
     sink.data = {
@@ -800,8 +714,7 @@ async function runExport(rest: string[], io: Cli, sink: JsonSink | null): Promis
       source_bundle_hash: composed.sourceBundleHash,
       attestations: attestations.length,
       attestations_bound: composed.boundAttestations,
-      // Without --out the artifact rides inside this object, since stdout
-      // carries the object and not the artifact.
+      // Without --out, stdout carries this object, so the artifact rides inside it.
       export: outPath ? null : composed.bundle,
     };
   }
@@ -810,7 +723,7 @@ async function runExport(rest: string[], io: Cli, sink: JsonSink | null): Promis
       await writeFile(outPath, serialized, "utf8");
     } catch (e) {
       io.err(`export: cannot write ${outPath}: ${e instanceof Error ? e.message : String(e)}`);
-      return EXIT_MALFORMED;
+      return EXIT_COULD_NOT_RUN;
     }
     io.out(
       `${paint("exported", composed.status === "failed" ? R : G)} ${outPath}  ` +
@@ -846,11 +759,10 @@ function usageExport(io: Cli): number {
   for (const line of EXIT_CODES_HELP.split("\n")) io.out(line);
   io.out("");
   io.out("export: 1 means the recomputed export is failed; it is still written.");
-  return EXIT_MALFORMED;
+  return EXIT_COULD_NOT_RUN;
 }
 
-// Read + parse a JSON file; report a clear error and return undefined on any
-// failure (mirrors the verify path's read/parse error handling → exit 2).
+// Read and parse a JSON file, or report the error and return undefined (exit 4).
 async function readJson<T>(path: string, io: Cli): Promise<T | undefined> {
   let raw: string;
   try {
@@ -871,8 +783,7 @@ async function readJson<T>(path: string, io: Cli): Promise<T | undefined> {
   }
 }
 
-// Accept either a bare array of attestation records or an object wrapping one
-// under `attestations`. Returns undefined for anything else.
+// A bare array of attestation records, or one under `attestations`.
 function coerceAttestations(raw: unknown): AttestationRecord[] | undefined {
   if (Array.isArray(raw)) return raw as AttestationRecord[];
   if (raw !== null && typeof raw === "object") {
@@ -882,9 +793,8 @@ function coerceAttestations(raw: unknown): AttestationRecord[] | undefined {
   return undefined;
 }
 
-// Read the exporter Ed25519 key: a file that is either a bare 32-byte hex seed
-// (whitespace-trimmed) or a JSON object carrying it under `privateKey` / `seed` /
-// `private_key`. Validates the 64-hex-char (32-byte) shape.
+// The exporter Ed25519 key: a bare 32-byte hex seed, or a JSON object carrying
+// it under `privateKey`, `seed` or `private_key`.
 async function readExporterKey(path: string, io: Cli): Promise<string | undefined> {
   let raw: string;
   try {
@@ -915,64 +825,28 @@ async function readExporterKey(path: string, io: Cli): Promise<string | undefine
   return seed.toLowerCase();
 }
 
-// ─── the `--logs` side input ────────────────────────────────────────────────
-//
-// Two shapes, one flag (proof#27):
-//
-//   DIRECTORY  `logs/<event_id>.json`, each file's RAW BYTES being the
-//              disclosure. This is the layout `materializeBundle` writes
-//              (bundle.json + logs/) and the layout the verify page hashes,
-//              so a pack verifies with NO side-input construction step.
-//   JSON MAP   `{ event_id: <even-length hex, either case | utf8 text> }`, the
-//              original form. Unchanged.
-//
-// **Why the directory form exists at all.** Handing a pack to the CLI used to
-// require the caller to read `logs/` and hex-encode it into a map, and that
-// read-and-encode step has been got wrong twice in shipped code: claims-demo#9
-// wrote the hex TEXT into the log files (SHA-256 of hex text is not SHA-256 of
-// the bytes it encodes, so genuine evidence failed), and a runbook handed the
-// directory straight to `--logs` and got EISDIR, exit 2. The directory form
-// removes the encoding decision from the caller entirely — bytes in, bytes
-// hashed — so that whole class stops being reachable from this direction.
-//
-// **Nothing is re-encoded, re-parsed or re-serialised on the way in.** A log
-// file's bytes are passed to the verifier as a `Uint8Array`, which the verifier
-// uses as-is; only the map form's *strings* go through `decodeLogValue`. That
-// is the invariant this feature exists to hold, and it is what makes the CLI
-// and the verify page agree about one pack.
+// `--logs` takes a directory of `logs/<event_id>.json` files, each file's raw
+// bytes being the disclosure (the layout `materializeBundle` writes), or a JSON
+// map `{ event_id: <even-length hex, either case | utf8 text> }`. File bytes go
+// to the verifier as-is; only map strings go through `decodeLogValue`.
 export interface LoadedLogs {
-  // Keyed by event id. A `Uint8Array` is raw bytes (directory form); a `string`
-  // is hex in either case (map form). Those are exactly the two the verifier
-  // distinguishes.
-  //
-  // A `Map`, NOT a plain object, and that is load-bearing rather than stylistic.
-  // An event id is producer-chosen — here it arrives as a FILE NAME or a JSON
-  // key — and `content["__proto__"] = <bytes>` on an object literal does not
-  // store anything: it REPLACES the map's prototype with the Uint8Array. The
-  // disclosed bytes are then silently lost (the holder disclosed them and we
-  // report the record undisclosed), and every later lookup on that map resolves
-  // through `Uint8Array.prototype`, so an event named `slice` or `set` finds an
-  // inherited function and an event named `byteLength` or `buffer` THROWS a
-  // TypeError out of the verifier. A Map keys on the string itself and has none
-  // of that.
+  // By event id: `Uint8Array` is raw bytes (directory), `string` is hex (map).
+  // A `Map`, not an object: an event id is producer-chosen, and
+  // `obj["__proto__"] = bytes` replaces the prototype instead of storing the
+  // disclosure, after which lookups resolve through `Uint8Array.prototype` and
+  // can throw.
   content: Map<string, Uint8Array | string>;
-  // Event ids the side input actually supplied — for the post-verify coverage
-  // cross-check, which needs to know what was offered, not just what bound.
+  // Event ids the side input supplied, for the post-verify coverage check.
   suppliedIds: string[];
-  // Advisory lines about the INPUT ITSELF (skipped entries, a directory that
-  // disclosed nothing). None of them moves a verdict or an exit code.
+  // Advisory lines about the input itself. None moves a verdict or exit code.
   notes: string[];
 }
 
-// The suffix the directory form reads, matched exactly — lowercase, which is
-// what `materializeBundle` writes. Anything else is skipped and NAMED rather
-// than guessed at, so a `.JSON` or extensionless file shows up as a note
-// instead of a mysteriously undisclosed event.
+// Matched exactly, lowercase. Anything else is skipped and named in a note.
 const LOG_SUFFIX = ".json";
 
-// Which shape was passed is decided by `stat`, never by the extension: a pack's
-// log directory can be called anything, and `logs.json` is a legal directory
-// name. `stat` follows symlinks, so a symlinked logs directory works.
+// The shape is decided by `stat`, never by extension. `stat` follows symlinks,
+// so a symlinked logs directory works.
 async function loadLogs(logsPath: string, io: Cli): Promise<LoadedLogs | undefined> {
   let isDirectory: boolean;
   try {
@@ -984,7 +858,7 @@ async function loadLogs(logsPath: string, io: Cli): Promise<LoadedLogs | undefin
   return isDirectory ? loadLogsDirectory(logsPath, io) : loadLogsMap(logsPath, io);
 }
 
-// The JSON-map form, unchanged: `{ event_id: <hex | utf8 text> }`.
+// The JSON-map form: `{ event_id: <hex | utf8 text> }`.
 async function loadLogsMap(logsPath: string, io: Cli): Promise<LoadedLogs | undefined> {
   let logsRaw: string;
   try {
@@ -998,8 +872,7 @@ async function loadLogsMap(logsPath: string, io: Cli): Promise<LoadedLogs | unde
     logsParsed = parseRefusingDuplicates(logsRaw);
   } catch (e) {
     if (e instanceof DuplicateKeyError) {
-      // One event id named twice hands the reader two contents for one
-      // record, and the last one silently won (proof#144).
+      // A repeated event id would hand the reader two contents for one record.
       io.err(`--logs ${logsPath} ${NOT_I_JSON}: ${e.message}`);
       return undefined;
     }
@@ -1025,8 +898,7 @@ async function loadLogsMap(logsPath: string, io: Cli): Promise<LoadedLogs | unde
     content.set(k, decodeLogValue(v));
     suppliedIds.push(k);
   }
-  // Named, every name, in the one sentence the Python command writes (A42): a
-  // value that is not a string is never coerced and never dropped unnamed.
+  // Every non-string value is named, never coerced or dropped.
   const notes =
     notStrings.length === 0
       ? []
@@ -1037,53 +909,24 @@ async function loadLogsMap(logsPath: string, io: Cli): Promise<LoadedLogs | unde
   return { content, suppliedIds, notes };
 }
 
-// The directory form, read by the one rule both kernels apply
-// (evidence-bundle.md §5.1.4, A42). The twin is `_load_logs_directory` in
-// `src/sanning_proof/cli.py`, and `cross-kernel/logs_folder_cli_leg.py` holds
-// the two commands to the same stdout, stderr and exit code.
-//
-// A regular file named `<event_id>.json` is that record's disclosed bytes, and
-// nothing else in the folder is read. None of the following is a verification
-// failure, because an absent or unusable disclosure is UNDISCLOSED and absence
-// is not evidence of tampering (evidence-bundle.md §5.1), and every one of them
-// is NAMED in a note, every name, so no file is dropped without being named:
-//
-//   - a file whose name is not a known event id  → loaded, binds to nothing,
-//     named in a post-verify note
-//   - an event with no corresponding file        → undetermined (`~`), noted
-//   - an empty directory                         → valid; discloses nothing,
-//     noted, exit code unchanged
-//   - a subdirectory                             → never entered, noted (the
-//     "you pointed at the pack root, not its logs/" case)
-//   - a symbolic link                            → never followed, whatever it
-//     points at, noted; `case` never follows one under a pack's `logs/` and
-//     `--files` never follows one in a folder (A40), so a link named
-//     `<event_id>.json` discloses nothing here either
-//   - anything that is not a regular file        → never opened, noted
-//   - anything else not named `<event_id>.json`  → never read, noted
+// The directory form (evidence-bundle.md §5.1.4; Python's twin is
+// `_load_logs_directory`). Only a regular file named `<event_id>.json` is read:
+// links are never followed and subdirectories never entered. Everything else,
+// and every event with no file, is named in a note, because an absent or
+// unusable disclosure is undisclosed, not a failure (§5.1).
 //
-// The Python command read every regular file by its STEM until 0.17.0, so a
-// forged `<id>.txt` beside a genuine `<id>.json` failed the pack there and was
-// never read here, and the forged-`.json` direction read clean there and
-// failed here: whoever assembled the folder chose the verdict.
-//
-// The hard stops (exit 2): a `<event_id>.json` file that cannot be read (we were
-// pointed at it, so a permissions error must not read as minimal disclosure),
-// more than MAX_WALK_ENTRIES names, a name that is not valid UTF-8 (escaping it
-// would let two names read as one), and `<event_id>.json` files holding more
-// than MAX_LOGS_BYTES in all.
+// Hard stops (exit 4): an unreadable `<event_id>.json` (a permissions error must
+// not read as minimal disclosure), more than MAX_WALK_ENTRIES names, a name that
+// is not valid UTF-8, or more than MAX_LOGS_BYTES in all.
 export const MAX_LOGS_BYTES = MAX_ZIP_BYTES;
 
 export class LogsTooLarge extends Error {}
 
-// A `<event_id>.json` file's bytes. Opened without following a link and without
-// blocking, then checked again, so a file swapped for a link or a pipe after the
-// folder was listed is refused rather than followed or waited on; and read no
-// further than `budget` allows. Two checks, and each is reachable without the
-// other: the size `fstat` reports refuses a sparse file before a byte is read,
-// and the count of bytes read refuses a file that reports less than it holds
-// (a file in /proc reports 0) or grows while it is read. `opener` is for the
-// tests, which must reach the second check with the first one passing.
+// A `<event_id>.json` file's bytes, opened without following a link or
+// blocking and then rechecked, so a swapped-in link or pipe is refused. Two
+// independent size checks: `fstat` refuses a sparse file before reading, and
+// the byte count refuses a file that under-reports (as /proc does) or grows.
+// `opener` lets tests reach the second check.
 export async function readLogFile(
   path: string,
   budget: { n: number },
@@ -1114,8 +957,7 @@ export async function readLogFile(
   }
 }
 
-// `limits` is for the tests, which cannot write a gigabyte or fifty thousand
-// names per case; the command always passes the defaults.
+// `limits` is for tests; the command always passes the defaults.
 export async function loadLogsDirectory(
   dirPath: string,
   io: Cli,
@@ -1154,7 +996,7 @@ export async function loadLogsDirectory(
     const p = childPath(dirPath, name);
     let s;
     try {
-      // `lstat`, never `stat`: a link in the folder is never followed.
+      // `lstat`: a link in the folder is never followed.
       s = await lstat(p);
     } catch {
       io.err(`cannot read --logs entry ${p}`);
@@ -1172,15 +1014,13 @@ export async function loadLogsDirectory(
       notRegular.push(name);
       continue;
     }
-    // Not named `<event_id>.json`, including a file named exactly `.json`,
-    // whose event id would be the empty string.
+    // Includes a file named exactly `.json`, whose event id would be empty.
     if (!name.endsWith(LOG_SUFFIX) || name.length === LOG_SUFFIX.length) {
       notNamed.push(name);
       continue;
     }
     const eventId = name.slice(0, -LOG_SUFFIX.length);
     try {
-      // Bytes, exactly as they sit on disk.
       content.set(eventId, await readLogFile(p, budget));
     } catch (e) {
       if (e instanceof LogsTooLarge) {
@@ -1200,7 +1040,7 @@ export async function loadLogsDirectory(
   if (dirs.length > 0) {
     notes.push(
       `--logs ${dirPath}: skipped ${count(dirs.length, "subdirectory", "subdirectories")} ` +
-        `(${quoted(dirs)}) — the directory form reads <event_id>${LOG_SUFFIX} files ` +
+        `(${quoted(dirs)}); the directory form reads <event_id>${LOG_SUFFIX} files ` +
         `and does not recurse`,
     );
   }
@@ -1227,24 +1067,20 @@ export async function loadLogsDirectory(
   }
   if (suppliedIds.length === 0) {
     notes.push(
-      `--logs ${dirPath} disclosed nothing (no <event_id>${LOG_SUFFIX} files) — every event ` +
-        `stays undisclosed, which is undetermined, not failed`,
+      `--logs ${dirPath} disclosed nothing (no <event_id>${LOG_SUFFIX} files); every event ` +
+        `stays undisclosed, which is not checked, not failed`,
     );
   }
   return { content, suppliedIds, notes };
 }
 
-// What the side input covered, reported once the bundle's own event ids are
-// known. Both directions are ADVISORY — neither moves the verdict or the exit
-// code — and both exist because the silent version of each has already cost
-// somebody an afternoon:
+// What the side input covered, once the bundle's event ids are known. Advisory
+// only:
 //
-//   - an entry matching no event binds to nothing. A typo'd id, or a directory
-//     scoped to a different bundle, otherwise looks identical to minimal
-//     disclosure.
-//   - an event whose content stayed undetermined disclosed no usable bytes.
-//     That is UNDISCLOSED, never a failure (evidence-bundle.md §5.1): absence
-//     of a disclosure is not evidence of tampering.
+//   - an entry matching no event binds to nothing (a typo or the wrong
+//     directory otherwise looks like minimal disclosure).
+//   - an event whose content stayed undetermined disclosed no usable bytes:
+//     undisclosed, never a failure (evidence-bundle.md §5.1).
 function reportLogsCoverage(logs: LoadedLogs, result: EvidenceBundleResult, io: Cli): void {
   const eventIds = new Set(result.events.map((e) => e.eventId));
   const unmatched = logs.suppliedIds.filter((id) => !eventIds.has(id)).sort();
@@ -1254,13 +1090,13 @@ function reportLogsCoverage(logs: LoadedLogs, result: EvidenceBundleResult, io:
         `in the bundle, ignored: ${quoted(unmatched)}`,
     );
   }
-  const undetermined = result.events.filter((e) => e.contentOk === null);
-  if (undetermined.length > 0) {
+  const unchecked = result.events.filter((e) => e.contentOk === null);
+  if (unchecked.length > 0) {
     io.err(
-      `note: ${undetermined.length} of ${result.events.length} event(s) have undetermined ` +
-        `content: no bytes disclosed, or no committed content_hash (message_hash for a ` +
+      `note: ${unchecked.length} of ${result.events.length} event(s) have content that ` +
+        `was not checked: no bytes disclosed, or no committed content_hash (message_hash for a ` +
         `hand-off record) to bind them to. ` +
-        `Undisclosed, not failed: ${sample(undetermined.map((e) => e.eventId))}`,
+        `Undisclosed, not failed: ${sample(unchecked.map((e) => e.eventId))}`,
     );
   }
 }
@@ -1273,43 +1109,24 @@ function count(n: number, one: string, many: string): string {
   return `${n} ${n === 1 ? one : many}`;
 }
 
-// Every name, quoted. Every one, not the first few: a file left out of a note
-// is a file dropped without being named.
+// Every name, quoted: a file left out of a note is a file dropped unnamed.
 function quoted(names: string[]): string {
   return names.map((n) => JSON.stringify(n)).join(", ");
 }
 
-// First few names, quoted, with a tail count — enough to recognise the mistake
-// without pasting a whole directory into the terminal.
+// The first few names, quoted, with a count of the rest.
 function sample(names: string[], max = 3): string {
   const shown = names.slice(0, max).map((n) => JSON.stringify(n)).join(", ");
   return names.length > max ? `${shown}, +${names.length - max} more` : shown;
 }
 
-// The --logs MAP lane decides each disclosed value's encoding: a clean,
-// even-length hex string is hex bytes; anything else is utf8 text. (The
-// verifier itself only distinguishes "string ⇒ hex" from "Uint8Array ⇒ raw
-// bytes", so the human-facing encoding choice is made here. The DIRECTORY lane
-// never reaches this: its bytes are already bytes.)
-//
-// EITHER CASE, through the one charset rule (proof#146). This test was
-// `/^[0-9a-f]+$/`, lower case only, and it was the last copy of the hex rule
-// in either kernel that answered differently from the others: the Python CLI
-// passes every string to the kernel, and the kernel decodes it with the
-// case-open `hexToBytes` on BOTH sides. So a disclosure map written in
-// upper-case hex was read as 4 bytes of evidence there and as 8 bytes of TEXT
-// here, and this command told the auditor their genuine, correctly disclosed
-// evidence had FAILED: `proof verify --logs map.json` exited 3 in Python and
-// 1 here, on one pack and one map. Telling an auditor their evidence is forged
-// is the worst direction to be wrong in, which is the argument the Python
-// twin's own docstring already makes about this exact lane.
-//
-// Pinned by `cross-kernel/run_cli.sh`'s `logs/hex-map-upper`, beside the
-// lowercase lane that existed before and only ever exercised the one spelling
-// the two commands happened to agree on.
+// The map form's encoding: a non-empty, even-length hex string (either case,
+// through the shared charset rule) is hex; anything else is UTF-8 text. Python
+// decodes the same way, so a map in upper-case hex is evidence in both
+// kernels, never text in one and a failure in the other.
 function decodeLogValue(v: string): Uint8Array | string {
-  if (v.length > 0 && v.length % 2 === 0 && isHexField(v, v.length)) return v; // hex passthrough
-  return utf8(v); // raw utf8 bytes
+  if (v.length > 0 && v.length % 2 === 0 && isHexField(v, v.length)) return v;
+  return utf8(v);
 }
 
 function printUsage(io: Cli): void {
@@ -1327,10 +1144,10 @@ function printUsage(io: Cli): void {
   io.out("");
   io.out("Verify a sanning.evidence/v1 bundle (body sanning.anchor.trace/v3,");
   io.out("sanning.stamp.trace/v1, sanning.stamp.evidence/v2 or the attested export");
-  io.out("sanning.evidence.export/v2) or a sanning.agent.proof/v1 inclusion bundle,");
+  io.out("sanning.evidence.export/v2),");
   io.out("fully offline. Pass --gateways <url,url> to also re-fetch each");
   io.out("checkpoint and stamp on-chain. Only arweave witnesses are re-fetched;");
-  io.out("a witness of any other kind is not checked and the run exits 3.");
+  io.out("a witness of any other kind is not checked, and the witness line says so.");
   io.out("");
   io.out("--json              Print the verdict, the causes and the exit code as");
   io.out("                    JSON, for a script, instead of the report.");
@@ -1354,9 +1171,9 @@ function printUsage(io: Cli): void {
   io.out("--logs <path>       Bind disclosed raw logs to each event's committed");
   io.out("                    content_hash, or message_hash for a hand-off record.");
   io.out("                    Either shape works, and which one you");
-  io.out("                    passed is decided by stat(), not by the extension:");
+  io.out("                    passed is determined by stat(), not by the extension:");
   io.out("");
-  io.out("                      a DIRECTORY of <event_id>.json files — the file's");
+  io.out("                      a DIRECTORY of <event_id>.json files; the file's");
   io.out("                      raw bytes ARE the content, nothing is decoded.");
   io.out("                      This is a materialized pack's logs/ directory:");
   io.out("                        sanning-proof verify <pack>/bundle.json --logs <pack>/logs");
@@ -1370,36 +1187,27 @@ function printUsage(io: Cli): void {
   io.out("");
   io.out("                    In-body events[].content is verified automatically");
   io.out("                    and takes precedence. An event with no disclosed");
-  io.out("                    bytes is undetermined (~), never a failure.");
+  io.out("                    bytes is not checked, never a failure.");
   io.out("");
-  io.out("The headline is the PACK verdict, the same one the verify page prints:");
-  io.out("a record nobody hashed leaves the pack INCOMPLETE even when the signed");
-  io.out("bundle itself is verified. Both verdicts are printed when they differ.");
+  io.out("The headline is the pack verdict, the same one the verify page prints, read");
+  io.out("off six claims: signed, unchanged, witnessed, complete, agreed and follows the");
+  io.out("rules. A record nobody hashed leaves the pack incomplete even when the signed");
+  io.out("bundle itself verifies. The report prints one line for each claim that is");
+  io.out("disproven or not proven, and one next action.");
   io.out("");
   for (const line of EXIT_CODES_HELP.split("\n")) io.out(line);
   io.out("");
-  io.out("verify: an unreachable gateway reads partial, and a pack with a record");
-  io.out("nobody hashed reads incomplete; both exit 3, and neither is a failure.");
+  io.out("verify: a pack with a record nobody hashed reads incomplete and exits 2, which");
+  io.out("is not a failure. A gateway that cannot be reached moves nothing: the witness");
+  io.out("line says so.");
 }
 
 /**
- * The disclosure account this command can honestly make, from what the VERIFIER
- * determined rather than from what the loader happened to read.
- *
- * `accountDisclosure` is offered by `grading.ts` as a convenience and is
- * explicitly "NOT THE ONLY WAY TO BUILD AN ACCOUNT". It reads the side map
- * only, and this command has a second disclosure lane the side map cannot see:
- * `events[].content`, carried INSIDE the bundle and bound by the verifier
- * without any `--logs` at all. Accounting off the side map would file every
- * in-body disclosure as `missing` and print a shortfall the pack does not have,
- * which is the shape of manufactured accusation `grading.ts` keeps warning
- * about.
- *
- * So `present` is "the verifier reached a determination for this record's
- * content" and `missing` is "it could not", which is the same tri-state that
- * decides the verdict, so the causes printed can never contradict the headline.
- * `extra` still comes from the side input, because bytes that bound to nothing
- * are a fact about the pack that only the loader knows.
+ * The disclosure account, from what the verifier determined rather than what
+ * the loader read. `accountDisclosure` sees only the side map and would file
+ * every in-body `events[].content` disclosure as missing. Here `present` and
+ * `missing` follow the same tri-state as the verdict, so the causes printed
+ * cannot contradict the headline; `extra` comes from the side input.
  */
 function cliDisclosureAccount(
   result: EvidenceBundleResult,
@@ -1411,14 +1219,63 @@ function cliDisclosureAccount(
     expected,
     present: result.events.filter((e) => e.contentOk !== null).map((e) => e.eventId),
     missing: result.events.filter((e) => e.contentOk === null).map((e) => e.eventId),
-    // The loader hard-stops (exit 2) on a file it selected and could not read,
-    // and NAMES everything it skipped as a note, so nothing reaches here as an
-    // unusable disclosure bound to a named record.
+    // The loader hard-stops on an unreadable selected file and names every
+    // skip, so nothing unusable reaches here.
     unreadable: [],
     extra: (logs?.suppliedIds ?? []).filter((id) => !known.has(id)),
   };
 }
 
+// The chain reading could not be produced, which is not a reading of nothing.
+function chainsUnreadableText(reason: string): string {
+  return (
+    "this kernel could not read the event chains in this bundle " +
+    `(${reason}), so the chain evidence is unknown here. That is ` +
+    "not the same as there being none to read."
+  );
+}
+
+/**
+ * One note per record-layer finding (agent-events.md section 10.1), in the order each
+ * is first met, counted over the records that carry it, its kind the finding's name. A
+ * finding never moves a verdict.
+ */
+function findingNotes(readings: Iterable<AgentRecordReading | null>): NoteEntry[] {
+  const counts = new Map<string, number>();
+  for (const reading of readings) {
+    if (reading === null) continue;
+    for (const finding of new Set(reading.findings)) {
+      counts.set(finding, (counts.get(finding) ?? 0) + 1);
+    }
+  }
+  return [...counts].map(([f, n]) => note(f, renderFindingNote(f, n)));
+}
+
+/** The witness line without its `Witness:` label, which the person layer prints. */
+function witnessText(line: WitnessLine): string {
+  return renderWitnessLine(line).slice("Witness: ".length);
+}
+
+/**
+ * The witness line of one pack read by `verify`: the lookup `verifyEvidenceBundle` ran
+ * with the gateways, in the words the case reading uses.
+ */
+function verifyWitness(result: EvidenceBundleResult, gateways: readonly string[]): WitnessLine {
+  // No lookup ran: none was asked for, or the run read no witness to look up (a wrapper that
+  // does not hold, a body this kernel does not read).
+  if (gateways.length === 0 || result.checkpoints.length + (result.stamps ?? []).length === 0) {
+    return witnessLine({ checked: false, gateways: [], packs: [], verdict: "not_checked" });
+  }
+  const { row, answered } = onChainRow("", result);
+  return witnessLine({
+    answered: gateways.filter((g) => answered.has(g)),
+    checked: true,
+    gateways: [...gateways],
+    packs: [row],
+    verdict: onChainOutcome([row]),
+  });
+}
+
 function reportEvidence(
   result: EvidenceBundleResult,
   path: string,
@@ -1429,486 +1286,302 @@ function reportEvidence(
   parsed: unknown,
   logs: LoadedLogs | undefined,
   sink: JsonSink | null,
+  bare: EvidenceBundleResult | null = null,
 ): number {
-  if (result.status === "malformed") {
-    if (sink) sink.data = verifyJson(result, null, null, null);
-    io.err(paint("MALFORMED", R) + `  ${path}`);
-    for (const e of result.errors) io.err(`  - ${e}`);
-    return EXIT_MALFORMED;
-  }
-
-  io.out(paint("Evidence bundle", B) + `  ${path}`);
-  io.out(`  body_type     ${result.bodyType ?? "<unknown>"}`);
-  io.out(
-    `  wrapper       sig ${mark(result.signatureOk)}  body_hash ${mark(result.bodyHashOk)}  spec ${mark(result.specVersionOk)}`,
+  // What the pack says it holds, against what it does (evidence-bundle.md section
+  // 5.4). A pack with no declaration leaves `complete` out of scope, and a note says
+  // so. A pack that carries a declaration this reader cannot read is incomplete: the
+  // holder chose that field, so unknown is the honest answer. A v3 chain claim is
+  // checked against this command's links (rule 11); unreadable links read the claim
+  // unknown.
+  const declaration = checkDeclaration(parsed, logs?.content, links);
+  const grade = gradePack(
+    result,
+    cliDisclosureAccount(result, logs),
+    completenessNotes(parsed),
+    declaration,
   );
 
+  // Sandbox evidence: read from the signed envelopes the pack holds. A label, never a
+  // verdict: a sandbox pack that verifies exits 3.
+  const marker = environmentMarker([parsed]);
+  const agents = result.events.filter((ev) => ev.agent).map((ev) => ev.agent);
+  const inScope: string[] = [];
+  const notInScope: Partial<Record<Claim, NotInScopeReason>> = { agreed: "no_handoff" };
+  if (declaration.present) inScope.push("complete");
+  else notInScope.complete = "no_declaration";
+  if (agents.length > 0) inScope.push("follows_rules");
+  else notInScope.follows_rules = "no_agent_records";
+  let problems = [...grade.problems];
+  if (result.unreadable === true) {
+    // A pack this reader cannot read says nothing about the bytes beside it: its own
+    // problem is the one line, as `case` reads it.
+    problems = bundleProblems(result, 0);
+  } else if (bare !== null && grade.verdict === "failed") {
+    // No disproof rests on bytes nobody signed: `bare` is the same pack read without the
+    // bytes handed in beside it, as `case` reads it.
+    const signed = gradePack(
+      bare,
+      cliDisclosureAccount(bare, undefined),
+      completenessNotes(parsed),
+      checkDeclaration(parsed, undefined, links),
+    );
+    problems = restOnSigned(problems, signed.problems);
+  }
+  const eventIds = result.events.map((ev) => ev.eventId);
+  const claims = claimsOf(problems, inScope, {
+    notInScope,
+    labels: (_pack, record) => [null, record !== null ? (eventIds[record] ?? null) : null],
+  });
+  const verdict = verdictOf(claims);
+  const exit = exitCodeFor(verdict.status, marker);
+
+  const unreadable = "unreadable" in chains ? chains.unreadable : null;
+  const summaries = "unreadable" in chains ? [] : chains.chains;
+  const findings = "unreadable" in chains ? [] : chains.findings;
+  const notes = (result.notes ?? []).map((n) => note("co_signatures_present", n));
+  if (!declaration.present && result.unreadable !== true) {
+    notes.push(note("pack_undeclared", renderDeclarationSummary(declaration)));
+  }
+  notes.push(...declaration.notes.map((n) => note(n.kind, renderNote(n))));
+  if (unreadable !== null) notes.push(note("chains_unreadable", chainsUnreadableText(unreadable)));
+  notes.push(...findings.map((f) => note(f.kind, renderChainFinding(f, "this bundle"))));
+  notes.push(...findingNotes(agents));
+  const witness = verifyWitness(result, gateways);
+  const person = renderPerson(verdict, claims, orderedNotes(notes), marker, witnessText(witness), witness.state);
+
+  for (const line of personText(person)) io.out(line);
+  io.out("");
+  io.out(`Evidence bundle  ${path}`);
+  io.out(`  body_type     ${result.bodyType || "<unknown>"}`);
+  // Both verdicts, whenever they differ: a pack can be incomplete over an impeccable
+  // bundle, and the headline alone would read it as broken.
+  if (verdict.status !== result.status) {
+    io.out(
+      `  bundle        the signed bundle is "${result.status}"; the pack ` +
+        `around it is "${verdict.status}"`,
+    );
+  }
+
   if (result.checkpoints.length > 0) {
     io.out("");
-    io.out(paint("  Checkpoints", DIM));
+    io.out("  Checkpoints");
     for (const cp of result.checkpoints) {
-      const onChain = cp.onChainOk === null ? "" : `  on-chain ${mark(cp.onChainOk)}`;
-      io.out(
-        `    ${mark(cp.ok)} ${shortTx(cp.checkpointRef)}  envelope ${mark(cp.envelopeOk)}  root ${mark(cp.merkleRootOk)}${onChain}`,
-      );
-      for (const e of cp.errors) io.out(paint(`        - ${e}`, R));
+      io.out(`    ${cp.ok ? "OK" : "XX"}  ${cp.checkpointRef || "<no ref>"}`);
+      for (const e of cp.errors) io.out(`        - ${e}`);
     }
   }
 
-  // Stamps (evidence-bundle.md §5.2 / §5.3). Printed rather than summarised,
-  // because for a stamp body the WITNESS is the entire independent part
-  // (§5.2.4) — and until now this reporter showed nothing about it at all, so a
-  // §5.3 pack printed a rollup line claiming an on-chain scope with no visible
-  // on-chain result anywhere above it.
-  //
-  // The on-chain column distinguishes all four states in the same three
-  // characters the checkpoint block uses, plus its absence: `✓` confirmed,
-  // `✗` mismatched, `~` asked and unreachable, and NO COLUMN AT ALL when
-  // nothing was checked. A reader must never have to infer "not checked" from
-  // a symbol that also means "could not be reached".
-  if (result.stamps && result.stamps.length > 0) {
+  // The stamps. For a stamp body the witness is the entire independent part (section 5.2.4).
+  // No on-chain column when nothing was checked: "not checked" must not be inferred
+  // from a word that also means "we asked and nobody answered".
+  const stamps = result.stamps ?? [];
+  if (stamps.length > 0) {
     io.out("");
-    io.out(paint("  Stamps", DIM));
-    for (const st of result.stamps) {
+    io.out("  Stamps");
+    for (const st of stamps) {
       const witness =
-        st.anchorRef === null
-          ? paint("~ no witness", Y)
-          : `witness ${st.anchorRef.kind}:${shortTx(st.anchorRef.id)}`;
-      const onChain =
-        st.onChain === null ? "" : `  on-chain ${mark(st.onChainOk)} (${st.onChain.rollup})`;
+        st.anchorRef === null ? "no witness" : `witness ${st.anchorRef.kind}:${st.anchorRef.id}`;
+      const onChain = st.onChain === null ? "" : `  on-chain ${st.onChain.rollup}`;
       io.out(
-        `    ${mark(st.ok)} ${shortTx(st.stampRef)}  bytes ${mark(st.stampRefOk && st.bodyOk)}` +
-          `  ranges ${mark(st.subtreesOk)}  ${witness}${onChain}`,
+        `    ${st.ok ? "OK" : "XX"}  ${st.stampRef || "<no stamp_ref>"}  ` +
+          `bytes ${st.stampRefOk && st.bodyOk ? "OK" : "XX"}  ` +
+          `ranges ${st.subtreesOk ? "OK" : "XX"}  ${witness}${onChain}`,
       );
-      for (const e of st.errors) io.out(paint(`        - ${e}`, R));
+      for (const e of st.errors) io.out(`        - ${e}`);
     }
   }
 
   if (result.events.length > 0) {
     io.out("");
-    io.out(paint("  Events", DIM));
+    io.out("  Events");
     for (const ev of result.events) {
-      // `~` is "not determined", and the words after it must say only that.
-      // This read "record withheld", which is a statement about the PRODUCER:
-      // it says the customer chose minimum disclosure and kept these bytes
-      // back, which is legitimate and expected. An event whose envelope was
-      // never an envelope produces the same `null` on this dimension, and
-      // there the sentence is simply untrue: the record may be sitting in the
-      // bundle, and nothing about the producer has been established either
-      // way. A renderer cannot tell the two apart from a tri-state, so it
-      // states what the verifier did and leaves WHY to the error lines below,
-      // which now name the malformed envelope instead of a signature check
-      // that never ran (proof#76).
-      const binding =
-        ev.payloadBindingOk === null
-          ? paint("~ record not checked", Y)
-          : `record ${mark(ev.payloadBindingOk)}`;
-      // Show the content (logs) segment only when content was disclosed and
-      // evaluated (non-null) — undisclosed content is the default and would just
-      // be noise on every line.
-      const logs = ev.contentOk === null ? "" : `  logs ${mark(ev.contentOk)}`;
-      io.out(
-        `    ${mark(ev.ok)} ${shortId(ev.eventId)}  envelope ${mark(ev.envelopeOk)}  ${binding}  inclusion ${mark(ev.inclusionOk)}${logs}`,
-      );
-      for (const e of ev.errors) io.out(paint(`        - ${e}`, R));
+      io.out(`    ${ev.ok ? "OK" : "XX"}  ${ev.eventId || "<no event_id>"}`);
+      for (const e of ev.errors) io.out(`        - ${e}`);
+      // The agent reading, with the pack's other records held beside it. Its findings
+      // are notes and move nothing; a reading that is not verified is also a cause
+      // of the pack verdict below.
+      if (ev.agent !== null) io.out(`        agent  ${renderAgentReading(ev.agent)}`);
     }
   }
 
-  reportChains(chains, io);
-
-  if (result.export) {
-    reportExport(result.export, io);
-  }
-
-  // What the pack SAYS it holds, against what it does (evidence-bundle.md
-  // §5.4). A pack that deviates from its own declaration FAILS here and exits
-  // 1, which is the point: every other check in this command is a check on a
-  // record that is present, so a trimmed hand-over passes all of them.
-  //
-  // A pack with NO declaration exits exactly as it did before §5.4. The check
-  // answers `partial` and the line below says so in words, and pack grading
-  // keeps its own verdict: every pack built before §5.4 carries no
-  // declaration, and re-grading them all as undetermined would be a change to
-  // their verdicts rather than a new check. A pack that DOES
-  // carry a declaration this reader cannot read is a different case and exits
-  // 3: the holder chose that field, so UNKNOWN is the honest answer.
-  //
-  // A v3 declaration that claims a chain is checked against this command's
-  // own chain links (rule 11, evidence-bundle.md 5.4.2 v1.36, A45). Links
-  // that could not be read are passed as none, which reads the claim UNKNOWN
-  // and never clean.
-  const declaration = checkDeclaration(parsed, logs?.content, links);
-  const grade = gradePack(
-    result,
-    cliDisclosureAccount(result, logs),
-    completenessNotes(parsed),
-    declaration,
-  );
-
-  // Sandbox evidence: read from the signed envelopes the pack holds.
-  const marker = environmentMarker([parsed]);
-  // A pack whose records are all signed `dev`, undetermined only because a
-  // simulated witness cannot be looked up, would grade `verified` with that
-  // witness accepted: it is sandbox evidence, exit 5, never 3.
-  const simulatedOnly =
-    grade.verdict === "partial" &&
-    onlySimulatedUnsettled(result) &&
-    gradePack(
-      { ...result, status: "verified" },
-      cliDisclosureAccount(result, logs),
-      completenessNotes(parsed),
-      declaration,
-    ).verdict === "verified";
-  const exit = sandboxExit(mapGradeToExit(grade), marker, simulatedOnly);
+  for (const e of result.errors) io.err(`  - ${e}`);
 
+  // The chain block: the chains walked (their findings are notes, printed above); no
+  // chain to follow; or a reading that could not be produced, printed as itself.
   io.out("");
-  printRollup(
-    grade.verdict,
-    result.status,
-    result.assertedStatus,
-    gateways,
-    result.onChainChecked,
-    io,
-    marker,
-    exit === EXIT_SANDBOX,
-    simulatedOnlyRun(result, gateways),
-  );
-  io.out(
-    paint(
-      `  declaration: ${renderDeclarationSummary(declaration)}`,
-      declaration.verdict === "failed" ? R : declaration.verdict === "verified" ? DIM : Y,
-    ),
-  );
-  for (const n of declaration.notes) io.out(paint(`  note: ${renderNote(n)}`, Y));
-  for (const e of result.errors) io.out(paint(`  note: ${e}`, DIM));
-  // Every reason the pack is not verified, in the kernel's own words. An
-  // `incomplete` with no cause is a surface saying "unknown" and unable to say
-  // why, which `grading.ts` calls out by name as a defect of its own.
-  for (const c of grade.causes) io.out(paint(`  - ${renderCause(c, "the pack")}`, Y));
-
-  // The fraction describes the PACK, not the disclosure. It used to divide by
-  // the number of records that happened to disclose bytes, so a pack that
-  // disclosed two of three records printed `logs: 2/2`, a full score for a
-  // partial hand-over, and the one line a reader skims for exactly this.
-  if (result.events.length > 0) {
+  if (unreadable !== null) {
+    io.out(`  Chain         ${chainsUnreadableText(unreadable)}`);
+  } else if (summaries.length === 0) {
     io.out(
-      paint(
-        `  logs: ${grade.recordsVerified}/${result.events.length} record(s) content-verified`,
-        DIM,
-      ),
+      "  Chain         no event chain was found to follow in this " +
+        "bundle, so nothing was checked here",
     );
+  } else {
+    io.out("  Event chains");
+    for (const c of summaries) {
+      const where = c.namespace === undefined ? "record" : `${c.namespace} metadata`;
+      io.out(
+        `    ${c.chainKey}  ${c.events} record${c.events === 1 ? "" : "s"} present` +
+          `  (linked in ${where})`,
+      );
+    }
+    io.out(`    ${CHAIN_READING_SCOPE}`);
   }
 
-  if (sink) sink.data = verifyJson(result, grade, declaration, chains, marker);
-  return exit;
-}
-
-/**
- * What `verify --json` prints for an evidence bundle, the same keys and the
- * same words as `_verify_json` in the Python twin. `grade`, `declaration` and
- * `chains` are null for a bundle no verdict could be rendered over.
- */
-function verifyJson(
-  result: EvidenceBundleResult,
-  grade: PackGrade | null,
-  declaration: ReturnType<typeof checkDeclaration> | null,
-  chains: ChainOutcome | null,
-  marker: EnvironmentMarker | null = null,
-): Record<string, unknown> {
-  let chainBlock: Record<string, unknown> | null = null;
-  if (chains !== null) {
-    chainBlock =
-      "unreadable" in chains
-        ? { unreadable: chains.unreadable, chains: 0, findings: [] }
-        : {
-            unreadable: null,
-            chains: chains.chains.length,
-            findings: chains.findings.map((f) => renderChainFinding(f, "this bundle")),
-          };
-  }
-  return {
-    verdict: grade ? grade.verdict : result.status,
-    bundle_status: result.status,
-    asserted_status: result.assertedStatus ?? null,
-    body_type: result.bodyType ?? null,
-    on_chain_checked: result.onChainChecked,
-    declaration: declaration ? declaration.verdict : null,
-    declaration_notes: declaration ? declaration.notes.map(renderNote) : [],
-    causes: grade ? grade.causes.map((c) => renderCause(c, "the pack")) : [],
-    notes: [...result.errors],
-    records: grade
-      ? { presented: result.events.length, content_verified: grade.recordsVerified }
-      : null,
-    chains: chainBlock,
-    // Present only where the pack holds an envelope signed `dev`
-    // (envelope-spec §2 MAY), so a production pack's JSON is unchanged.
-    ...(marker !== null ? { environment_marker: marker } : {}),
-  };
-}
-
-/**
- * The chain block: what following each record's pointer to the record before it
- * showed, over the records THIS bundle presents.
- *
- * Three deliberate choices, all of them about not overclaiming.
- *
- * 1. It prints the chains it READ, not just the findings. "3 chains, nothing to
- *    report" and silence are different statements, and a reader that quietly
- *    matched no records at all would produce the second one while covering
- *    nothing.
- * 2. It prints the scope sentence whenever it read a chain, findings or not.
- *    "Delete an event and the next pointer dangles" is true; "so the bundle is
- *    complete" does not follow, and two customer-facing documents had already
- *    made that leap. The limit travels with the result or it gets dropped.
- * 3. It does not touch the exit code. Findings are evidence; the exit code is
- *    the verdict surface, and the one exit-code table (`./exit-codes.ts`) reads
- *    the verdict and nothing else. A dangling link is something for a person to look at, not a machine
- *    decision this check is entitled to make.
- */
-function reportChains(reading: ChainOutcome, io: Cli): void {
-  if ("unreadable" in reading) {
-    io.out("");
+  if (simulatedOnlyRun(result, gateways)) {
     io.out(
-      paint(
-        `  Event chains  this kernel could not read the event chains in this bundle ` +
-          `(${reading.unreadable}), so the chain evidence is UNKNOWN here. That is not ` +
-          `the same as there being none to read.`,
-        Y,
-      ),
+      `  Gateways      ${gateways.join(", ")}; a simulated witness is not ` +
+        "on a chain, so nothing was looked up",
     );
-    return;
+  } else if (gateways.length > 0) {
+    io.out(`  Gateways      ${gateways.join(", ")}`);
+  } else {
+    io.out("  Gateways      none supplied; the on-chain half was not checked");
   }
-  if (reading.chains.length === 0) return;
 
-  io.out("");
-  io.out(paint("  Event chains", DIM));
-  for (const c of reading.chains) {
-    const where = c.namespace === undefined ? "record" : `${c.namespace} metadata`;
+  io.out(`  declaration   ${renderDeclarationSummary(declaration)}`);
+
+  // Every reason the pack is not verified, in the kernel's own words.
+  for (const c of grade.causes) io.out(`  - ${renderCause(c, "the pack")}`);
+
+  // The fraction describes the pack, not the disclosure.
+  if (result.events.length > 0) {
     io.out(
-      paint(
-        `    ${c.chainKey}  ${count(c.events, "record", "records")} present  (linked in ${where})`,
-        DIM,
-      ),
+      `  logs          ${grade.recordsVerified}/${result.events.length} ` +
+        "record(s) content-verified",
     );
   }
-  for (const f of reading.findings) {
-    io.out(paint(`    ! ${renderChainFinding(f, "this bundle")}`, Y));
-  }
-  io.out(paint(`    ${CHAIN_READING_SCOPE}`, DIM));
-}
 
-// Render the export-specific block (evidence-export.md §5): source-bundle
-// linkage, cached-vs-recomputed verdict agreement, and each embedded operator
-// attestation (RSA-PSS sig · operator-address binding · data_hash binding).
-function reportExport(exp: ExportResult, io: Cli): void {
-  io.out("");
-  io.out(paint("  Attested export", DIM));
-  io.out(
-    `    source linkage ${mark(exp.sourceLinkageOk)}  verdict agreement ${mark(exp.verdictAgreementOk)}`,
-  );
-  if (exp.attestations.length > 0) {
-    io.out(paint("    Operator attestations", DIM));
-    for (const a of exp.attestations) {
-      const subj = a.subjectRefOk === null ? "" : `  subject ${mark(a.subjectRefOk)}`;
-      io.out(
-        `      ${mark(a.ok)} ${shortId(a.operator)}  sig ${mark(a.signatureOk)}` +
-          `  operator ${mark(a.operatorAddressBound)}  data_hash ${mark(a.dataHashBound)}${subj}`,
-      );
-      for (const e of a.errors) io.out(paint(`          - ${e}`, R));
-    }
-  }
-}
-
-function reportAgentProof(
-  result: AgentProofResult,
-  path: string,
-  gateways: string[],
-  io: Cli,
-  sink: JsonSink | null,
-  parsed: unknown,
-): number {
-  const marker = result.status === "malformed" ? null : environmentMarker([parsed]);
   if (sink) {
-    sink.data = {
-      verdict: result.status,
-      bundle_status: result.status,
-      spec_version: "sanning.agent.proof/v1",
-      on_chain_checked: result.onChainChecked,
-      notes: [...result.errors],
-      ...(marker !== null ? { environment_marker: marker } : {}),
-    };
-  }
-  if (result.status === "malformed") {
-    io.err(paint("MALFORMED", R) + `  ${path}`);
-    for (const e of result.errors) io.err(`  - ${e}`);
-    return EXIT_MALFORMED;
+    sink.data = verifyJson(result, grade, declaration, chains, marker, verdict, claims, person);
   }
+  return exit;
+}
 
-  io.out(paint("Agent inclusion proof", B) + `  ${path}`);
-  io.out(`  spec_version  sanning.agent.proof/v1`);
-  io.out(`  checkpoint    ${shortTx(result.checkpointTxId ?? "")}  envelope ${mark(result.checkpointOk)}`);
-  const onChain = result.onChainOk === null ? "" : `  on-chain ${mark(result.onChainOk)}`;
-  io.out(
-    `  leaf          index ${result.leafIndex} / ${result.leafCount ?? "?"}  inclusion ${mark(result.inclusionOk)}${onChain}`,
-  );
-  io.out("");
-  // An agent inclusion proof carries no records and no disclosed bytes, so
-  // there is no pack to grade: the bundle status IS the headline here.
-  const exit = sandboxExit(exitCodeFor(result.status), marker);
-  printRollup(result.status, result.status, null, gateways, result.onChainChecked, io, marker, exit === EXIT_SANDBOX);
-  for (const e of result.errors) io.out(paint(`  note: ${e}`, DIM));
+/** One agent reading in `--json`: the same keys in `verify` and `case` and in both kernels. */
+interface AgentJson {
+  verdict: string | null;
+  reason: string | null;
+  at: string | null;
+  reasons: { reason: string; at: string }[];
+  findings: string[];
+  rendered: string;
+}
 
-  return exit;
+function agentJson(reading: AgentRecordReading, where: Record<string, unknown> = {}): AgentJson {
+  return {
+    ...where,
+    verdict: reading.verdict,
+    reason: reading.reason ?? null,
+    at: reading.at ?? null,
+    reasons: (reading.reasons ?? []).map((r) => ({ reason: r.reason, at: r.at })),
+    findings: [...reading.findings],
+    rendered: renderAgentReading(reading),
+  };
 }
 
-function printRollup(
-  headline: string,
-  bundleStatus: string,
-  asserted: string | null,
-  gateways: string[],
-  onChainChecked: boolean,
-  io: Cli,
-  marker: EnvironmentMarker | null = null,
-  sandbox = false,
-  simulatedOnly = false,
-): void {
-  // Three scopes, not two. A run with gateways whose only witnesses are
-  // simulated looked nothing up (`simulatedOnlyRun`): saying "on-chain" there
-  // claims a check that never happened, and saying "no gateway re-fetch
-  // requested" denies the flag the reader passed. Every other run that is not
-  // counted as checked on a chain, a run that stopped early among them, keeps
-  // the second scope as before.
-  const scope = onChainChecked
-    ? `verified offline + on-chain against ${gateways.length} gateway(s)`
-    : simulatedOnly
-      ? "verified offline; a simulated witness is not on a chain, so nothing was looked up"
-      : "verified offline (no gateway re-fetch requested)";
-  let head: string;
-  switch (sandbox ? "sandbox" : headline) {
-    // Sandbox evidence (exit 5) never prints VERIFIED.
-    case "sandbox":
-      head = paint(SANDBOX_HEADLINE, Y);
-      break;
-    case "verified":
-      head = paint("VERIFIED", G);
-      break;
-    // Undetermined, in both of its words. Neither is an accusation, so neither
-    // is printed in the color this command uses for one.
-    case "partial":
-    case "pending":
-    case "incomplete":
-      head = paint(headline.toUpperCase(), Y);
-      break;
-    case "failed":
-      head = paint("FAILED", R);
-      break;
-    default:
-      head = paint(headline.toUpperCase(), R);
-  }
-  io.out(`${head}  ${paint(scope, DIM)}`);
-  if (marker !== null) io.out(paint(`  ${SANDBOX_LINE}`, Y));
-  // Both verdicts, whenever they differ, because they answer different
-  // questions: §3 grades the signed bundle, the pack verdict grades the bundle
-  // plus whatever bytes travelled beside it. A pack can be incomplete while the
-  // bundle it carries is impeccable, and a reader told only the headline would
-  // read a sound bundle as a broken one.
-  if (headline !== bundleStatus) {
-    io.out(
-      paint(`  (the signed bundle is "${bundleStatus}"; the pack around it is "${headline}")`, DIM),
-    );
-  }
-  if (asserted && asserted !== bundleStatus) {
-    io.out(
-      paint(
-        `  (the asserting party said "${asserted}"; the recomputed verdict is "${bundleStatus}", ` +
-          `and the recomputed verdict wins)`,
-        DIM,
-      ),
-    );
+const CAUSE_FIELDS = [
+  ["checkpoint_ref", "checkpointRef"],
+  ["signed", "signed"],
+  ["presented", "presented"],
+  ["count", "count"],
+  ["of", "of"],
+  ["first_event_id", "firstEventId"],
+  ["reason", "reason"],
+  ["deviation", "deviation"],
+  ["at", "at"],
+  ["listed_event_id", "listedEventId"],
+] as const;
+
+/**
+ * One pack grade cause in `--json`: its kind, every value it carries, and the sentence
+ * the report prints for it.
+ */
+function causeJson(cause: PackGradeCause): Record<string, unknown> {
+  const out: Record<string, unknown> = { kind: cause.kind };
+  for (const [name, field] of CAUSE_FIELDS) {
+    const value = cause[field];
+    if (value !== undefined && value !== null) out[name] = value;
   }
+  out.rendered = renderCause(cause, "the pack");
+  return out;
 }
 
 /**
- * The exit code is the PACK verdict's, through the one table (`./exit-codes.ts`).
- *
- * `incomplete` and `partial` are 3: undetermined, which is what 3 means for an
- * unreachable gateway too, and emphatically not 1: the bytes being absent is
- * never reported as tamper (`evidence-bundle.md` §5.1). Until 0.13.0 `partial`
- * exited 0 here unless a gateway was unreachable, while `case` exited 3 on it.
+ * What `verify --json` prints for an evidence bundle: the same keys and words as
+ * Python's `_verify_json`. Every reason and count the person layer prints is here, so a
+ * surface can render `person` from this object alone (`renderPerson`).
  */
-function mapGradeToExit(grade: PackGrade): number {
-  return exitCodeFor(grade.verdict);
+function verifyJson(
+  result: EvidenceBundleResult,
+  grade: PackGrade,
+  declaration: ReturnType<typeof checkDeclaration>,
+  chains: ChainOutcome,
+  marker: EnvironmentMarker | null,
+  verdict: VerdictJson,
+  claims: ClaimEntry[],
+  person: Person,
+): Record<string, unknown> {
+  const chainBlock =
+    "unreadable" in chains
+      ? { unreadable: chains.unreadable, chains: 0, findings: [] }
+      : {
+          unreadable: null,
+          chains: chains.chains.length,
+          findings: chains.findings.map((f) => renderChainFinding(f, "this bundle")),
+        };
+  return {
+    // Present only for a pack with an envelope signed `dev` (envelope-spec section 2).
+    ...(marker !== null ? { environment_marker: marker } : {}),
+    verdict,
+    title: VERDICT_TITLES[verdict.status],
+    claims,
+    person,
+    notes: [...person.notes],
+    sandbox: marker !== null,
+    witness: person.witness,
+    witness_state: person.witness_state,
+    bundle_status: result.status,
+    bundle_errors: [...result.errors],
+    body_type: result.bodyType ?? null,
+    on_chain_checked: result.onChainChecked,
+    declaration: declaration.verdict,
+    declaration_notes: declaration.notes.map(renderNote),
+    causes: grade.causes.map(causeJson),
+    records: { presented: result.events.length, content_verified: grade.recordsVerified },
+    chains: chainBlock,
+    events: result.events.map((ev) => ({ event_id: ev.eventId, ok: ev.ok, errors: [...ev.errors] })),
+    agent_records: result.events
+      .filter((ev) => ev.agent !== null)
+      .map((ev) => agentJson(ev.agent!, { event_id: ev.eventId })),
+  };
 }
 
-// ─── What `proof case` reads (proof#141) ─────────────────────────────────────
-//
-// Directories on disk, split into packs. This lives in the CLI module, and not
-// in a kernel module, because it is the command's own read of files a person
-// named on the command line, the same class of read as `verify`'s read of
-// `bundle.json`, and it reads `bundle.json` with `verify`'s own reader,
-// `readBundleBytes`.
-//
-// The case READING is `readCase`, and nothing here touches it. This turns the
-// directories a reader typed into a list of packs. Its twin is the same section
-// of `src/sanning_proof/cli.py`, and both are held to one table,
-// `vectors/case-split.json`, whose rows are directory trees.
-//
-// ── Directories only ──
-//
-// A `.zip` named on the command line is read as the folder `unzip` would make,
-// by the reader in `zip-reader.ts` and nothing else, one reader restated in both
-// kernels because two zip libraries disagree on the edges. A `.zip` INSIDE a
-// folder is a file like any other: outside every pack, hashed like any other
-// file and never unzipped, because a reader does not open a zip inside a zip
-// (§5.6.1).
+// `proof case` input: directories (or a `.zip` read as the folder `unzip`
+// makes) split into packs, held to `vectors/case-split.json` in both kernels.
+// A `.zip` inside a folder is a file like any other (§5.6.1).
 //
-// ── The walk ──
+// The walk is iterative and bytewise-sorted, never follows a link, opens only
+// regular files and directories, and refuses the whole input (exit 4) past
+// MAX_WALK_DEPTH or MAX_WALK_ENTRIES or on a name that is not valid UTF-8.
 //
-// Iterative, never recursive, bytewise-sorted at each level, and bounded:
+// The split restates the verify page's rule:
 //
-//   - A directory nested more than MAX_WALK_DEPTH levels below an argument
-//     refuses the whole input (exit 2).
-//   - More than MAX_WALK_ENTRIES names listed, across every argument, refuses
-//     the whole input (exit 2).
-//   - A name that is not valid UTF-8 refuses the whole input (exit 2). It is
-//     not escaped or replaced: two different names would then read as one.
-//   - A symbolic link is never followed, whatever it points at, and anything
-//     else that is not a regular file or a directory is never opened. Each is
-//     listed as outside every pack and not read, even when it sits under a
-//     pack's `logs/` or is named `bundle.json`.
-//
-// ── The split: the verify page's rule over the tree ──
-//
-// The verify page (`sanning-io/verify-page`, `src/lib/case.ts` `splitCase` and
-// `src/lib/pack.ts` `assemble`) is the other surface that reads a case. Both
-// apply the same splitting rule to the same unpacked tree. The page's rule
-// lives in the page, so neither kernel can call it; it is restated here and in
-// the Python twin, and the shared table pins it:
-//
-//   1. Every regular file whose path ends in `/bundle.json` is a pack, rooted
-//      at the directory that holds it.
-//   2. A file belongs to the pack with the LONGEST root it sits under, and only
-//      if it is that root's `bundle.json` or under that root's `logs/`.
-//   3. A file under no pack is OUTSIDE: listed, never read as part of a pack, and
-//      hashed to be matched against the records (§5.7.6, A41).
-//   4. Roots and outside paths are sorted by UTF-16 code unit (the default
-//      `Array.prototype.sort`).
-//   5. Inside a pack, `logs/<event_id>.json` (one level) is disclosed content,
-//      and any other file under `logs/` is UNACCOUNTED.
+//   1. Every regular file at `.../bundle.json` is a pack rooted at its folder.
+//   2. A file belongs to the pack with the longest root it sits under, only if
+//      it is that root's `bundle.json` or under its `logs/`.
+//   3. Any other file is outside: listed, and hashed to match against records.
+//   4. Roots and outside paths sort by UTF-16 code unit.
+//   5. In a pack, `logs/<event_id>.json` (one level) is disclosed content; any
+//      other file under `logs/` is unaccounted.
 //   6. A pack's `ref` is its root without the trailing slash.
 //   7. No `bundle.json` anywhere refuses.
 //
-// One directory argument is read at `<its name>/<path inside it>`, which is how
-// the page names the files of a dropped folder. Several are read as one folder
-// holding them, each under its own name, and two that would land at one name
-// refuse.
-//
-// Known differences from the page: the page drops a leading byte-order mark from
-// `bundle.json` and `verify`'s reader refuses one; the page reads whatever the
-// browser hands it for a link, a name that is not UTF-8 or a very deep tree,
-// where this command applies the walk's rules above; and the page keys
-// disclosed content by a plain object, so it loses a record named `__proto__`,
-// which this command keeps.
+// One directory argument reads as `<its name>/<path inside>`; several read as
+// one folder holding them, and two landing at one name refuse. Unlike the page,
+// this command refuses a leading BOM in `bundle.json` and keeps a record named
+// `__proto__`.
 
 /** The error text for an input with no pack in it, word for word the page's. */
 export const NO_BUNDLE =
@@ -1935,7 +1608,7 @@ const UNZIP_FIRST =
 
 /**
  * The input could not be read as a case. The message is the whole report,
- * identical in both kernels, and the command exits 2 on it. `hint` is an
+ * identical in both kernels, and the command exits 4 on it. `hint` is an
  * optional second line naming a way through.
  */
 export class CaseInputError extends Error {
@@ -1955,11 +1628,10 @@ export class CaseInputError extends Error {
 export class WholeReadRefused extends CaseInputError {}
 
 /**
- * `bundle.json` bytes that `readBundleBytes` will not read. `tooDeep` separates
- * the one refusal that is not a parse error; `detail` is the parser's own words,
- * which differ by kernel and are printed by `verify` only. `duplicate` marks the
- * one parse refusal whose `detail` is kernel wording, identical in both kernels
- * (`duplicate key "<name>"`, proof#144), so both commands print it.
+ * `bundle.json` bytes `readBundleBytes` will not read. `tooDeep` marks the one
+ * refusal that is not a parse error. `detail` is the parser's words, which
+ * differ by kernel, so only `verify` prints it; `duplicate` marks the one
+ * `detail` both kernels word identically.
  */
 export class BundleReadError extends Error {
   readonly tooDeep: boolean;
@@ -1973,24 +1645,22 @@ export class BundleReadError extends Error {
   }
 }
 
-// What both commands say about bytes that repeat a member name, before the
-// kernel's own `duplicate key "<name>"`. RFC 8259 JSON permits a repeat and
-// I-JSON (RFC 7493), which JCS is defined over, does not, so "not valid JSON"
-// would be the wrong sentence. `NOT_I_JSON` in the Python twin.
+// The prefix for a repeated member name. JCS is defined over I-JSON (RFC 7493),
+// which forbids it, so "not valid JSON" would be the wrong sentence.
 export const NOT_I_JSON = "is not I-JSON (RFC 7493)";
 
-// `ignoreBOM: true` KEEPS a byte-order mark in the text, as Node's
-// `readFile(path, "utf8")` did for `verify`, so a leading one is not JSON.
+// `ignoreBOM: true` keeps a byte-order mark in the text, so a leading one is
+// not JSON.
 const bundleDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
 const nameDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 
 /**
- * How both `verify` and `case` turn `bundle.json` bytes into JSON, in both
- * kernels (`read_bundle_bytes` in the Python twin). UTF-8 with each ill-formed
- * sequence read as U+FFFD, and a byte-order mark kept; then nesting deeper than
- * MAX_JSON_DEPTH is refused before any parser walks into it; then `JSON.parse`,
- * refusing an object that repeats a member name (I-JSON, RFC 7493; proof#144).
- * Throws `BundleReadError`.
+ * How `verify` and `case` turn `bundle.json` bytes into JSON, in both kernels:
+ * UTF-8 with ill-formed sequences as U+FFFD and a BOM kept; nesting past
+ * MAX_JSON_DEPTH refused before parsing; then `JSON.parse`, refusing a repeated
+ * member name.
+ *
+ * @throws BundleReadError
  */
 export function readBundleBytes(bytes: Uint8Array): unknown {
   const text = bundleDecoder.decode(bytes);
@@ -2010,9 +1680,8 @@ export interface SplitPack {
   bundlePath: string;
   bundleBytes: Uint8Array;
   /**
-   * `logs/<event_id>.json` bytes by event id. A `Map` and not an object: an
-   * event id is written by the audited party, and `obj["__proto__"] = bytes`
-   * replaces the prototype instead of storing the disclosure.
+   * `logs/<event_id>.json` bytes by event id. A `Map`, because an event id is
+   * written by the audited party and `obj["__proto__"]` would not store it.
    */
   content: Map<string, Uint8Array>;
   unaccounted: string[];
@@ -2020,7 +1689,7 @@ export interface SplitPack {
 
 export interface SplitCase {
   packs: SplitPack[];
-  /** Paths that belong to no pack, sorted. Never read as part of a pack; a regular one is hashed, and nothing else is read of it (A41). */
+  /** Paths that belong to no pack, sorted. Never read as part of a pack; a regular one is hashed. */
   outside: string[];
   /** The part of `outside` that is not a regular file. Never followed, never opened. */
   notRegular: string[];
@@ -2037,19 +1706,15 @@ export interface TreeEntry {
   regular: boolean;
   /** The bytes of an entry read out of a case-file `.zip`. */
   data?: Uint8Array | null;
-  /**
-   * `true` for a symbolic link, on disk or an entry of a `.zip`: the one reason
-   * a link is skipped under, here and under `--files`.
-   */
+  /** `true` for a symbolic link, on disk or in a `.zip`. */
   link?: boolean;
   /** The `.zip` reader's own words for an entry it refused (not a link). */
   refused?: string;
 }
 
 /**
- * The page's `splitCase` followed by its `assemble` per pack, over the walk's
- * tree. `read` opens a file; it is called for the files a pack owns and for
- * nothing else.
+ * The page's `splitCase` then `assemble` per pack, over the walk's tree. `read`
+ * is called only for the files a pack owns.
  */
 export async function splitCase(
   tree: Map<string, TreeEntry>,
@@ -2114,15 +1779,10 @@ export async function splitCase(
 
 /**
  * The bytes of the `witness-cache.json` beside a pack's `bundle.json`
- * (evidence-bundle 5.6.6, v1.25, A30), or `null`.
- *
- * The split rule is not changed for it: the file stays outside every pack,
- * listed as such, and is read here, for its contents, and hashed with the other
- * outside files (A41). It is read as a cache only where it is a regular file the split left outside every pack, so a file under another
- * pack's `logs/` is that pack's, and a link is never followed. A file that
- * cannot be read is no cache, never a refusal of the drop. One the run's
- * whole-read total has no room for is pushed onto `refused` when it is given,
- * so the output says so.
+ * (evidence-bundle.md §5.6.6), or `null`. Read only where it is a regular file
+ * the split left outside every pack, and it stays outside. An unreadable file
+ * is no cache, never a refusal; one the whole-read total has no room for is
+ * pushed onto `refused` when given.
  */
 export async function witnessCacheBytes(
   tree: Map<string, TreeEntry>,
@@ -2146,33 +1806,30 @@ export async function witnessCacheBytes(
   }
 }
 
-/** `verify`'s reader, with the refusal named by the pack's path. */
-export function loadBundle(pack: SplitPack): unknown {
+/**
+ * `verify`'s reader over one pack's `bundle.json`: the bundle, or an empty object and why
+ * it could not be read. One pack that cannot be read is that pack's problem, never the
+ * case's: every other pack is still read.
+ */
+export function loadBundle(pack: SplitPack): [unknown, string | null] {
   try {
-    return readBundleBytes(pack.bundleBytes);
+    return [readBundleBytes(pack.bundleBytes), null];
   } catch (e) {
     if (e instanceof BundleReadError && e.tooDeep) {
-      throw new CaseInputError(`${pack.bundlePath} nests deeper than ${MAX_JSON_DEPTH} levels`);
+      return [{}, `nests deeper than ${MAX_JSON_DEPTH} levels`];
     }
     if (e instanceof BundleReadError && e.duplicate) {
-      throw new CaseInputError(`${pack.bundlePath} ${NOT_I_JSON}: ${e.detail}`);
+      return [{}, `${NOT_I_JSON}: ${e.detail}`];
     }
-    throw new CaseInputError(`${pack.bundlePath} is not valid JSON`);
+    return [{}, "is not valid JSON"];
   }
 }
 
-/**
- * The refusal for a file `case` would hold whole that does not fit in what is
- * left of the 1 GiB a run reads whole. The same words in both kernels.
- */
+/** The refusal for a file `case` would read whole past the run's 1 GiB. Same words in both kernels. */
 export const wholeReadRefusal = (key: string): string =>
   `${key} cannot be read: it would take case past the 1 GiB it reads whole in one run; refusing to read it`;
 
-/**
- * Why `contents.json` reads as an unreadable index when the run's whole-read
- * total has no room for it, and when it cannot be read. The same words in both
- * kernels.
- */
+/** Why `contents.json` reads as unreadable when it is over budget or cannot be read. */
 export const INDEX_OVER_BUDGET =
   "it would take case past the 1 GiB it reads whole in one run, so it was not read";
 export const INDEX_NOT_READ = "it could not be read";
@@ -2186,15 +1843,13 @@ export const zipFileRefusal = (arg: string): string =>
   `${arg} is larger than 1.25 GiB on disk; refusing to read it`;
 
 /**
- * A regular file's bytes. Opened without following a link and without
- * blocking, then checked again, so a file swapped for a link or a pipe after
- * the walk listed it is refused rather than followed or waited on.
+ * A regular file's bytes, opened without following a link or blocking, then
+ * rechecked, so a swapped-in link or pipe is refused.
  *
- * `budget` is the bytes a run may still hold whole from files on disk
- * (MAX_FOLDER_BYTES at the start). A file larger than what is left, or that
- * grows past it while it is read, is refused before it is held, so a file of a
- * terabyte under a pack's own names cannot exhaust memory. A `.zip` entry is
- * already in memory, inside the archive's own cap, and is not charged.
+ * `budget` is the bytes a run may still hold whole (MAX_FOLDER_BYTES at the
+ * start). A file larger than that, or that grows past it, is refused before it
+ * is held. A `.zip` entry is already in memory under the archive cap and is not
+ * charged.
  */
 export async function readFileEntry(
   entry: TreeEntry,
@@ -2215,8 +1870,8 @@ export async function readFileEntry(
     if (!st.isFile()) throw new CaseInputError(`cannot read ${key}`);
     if (budget === undefined) return new Uint8Array(await handle.readFile());
     if (st.size > budget.n) throw new WholeReadRefused(wholeReadRefusal(key));
-    // Once, at what the file says it holds and one byte more to see it grow:
-    // the bytes are read into the buffer the result is a view of, never copied.
+    // Ask for one byte more than the size, to see it grow; read in place, never
+    // copied.
     const want = Math.min(st.size, budget.n) + 1;
     const buf = Buffer.allocUnsafeSlow(want);
     let total = 0;
@@ -2226,8 +1881,7 @@ export async function readFileEntry(
       total += bytesRead;
     }
     if (total > st.size) {
-      // The file grew since it was measured: take the rest in pieces, never
-      // past the budget.
+      // It grew: read the rest in pieces, never past the budget.
       const rest: Buffer[] = [];
       let all = total;
       while (all <= budget.n) {
@@ -2254,9 +1908,8 @@ export async function readFileEntry(
 }
 
 /**
- * Every name under `root`, into `tree` at `<prefix><path inside>`. Breadth
- * first from an explicit queue, never by recursion. `seen` is the count of
- * names listed so far, across every argument.
+ * Every name under `root`, into `tree` at `<prefix><path inside>`, breadth
+ * first, without recursion. `seen` counts names across every argument.
  */
 async function walk(
   root: string,
@@ -2312,8 +1965,7 @@ async function walk(
   }
 }
 
-// The name the page would see for a dropped folder: the last segment of the
-// absolute path, so `.` and `pack/` name the directory itself.
+// The last segment of the absolute path, so `.` and `pack/` name the directory.
 function baseName(path: string): string {
   return basename(resolve(path));
 }
@@ -2359,8 +2011,7 @@ export async function treeFromArguments(paths: readonly string[]): Promise<Map<s
     }
     let name = baseName(arg);
     if (isZip) {
-      // `unzip <name>.zip -d <name>` is the command HOW-TO-VERIFY.txt pins, so
-      // the archive is read under the folder that command makes.
+      // Read under the folder `unzip <name>.zip -d <name>` makes.
       name = name.slice(0, -".zip".length);
       if (name.length === 0) throw new CaseInputError(`${arg} has no name before .zip; rename it`);
     }
@@ -2376,11 +2027,9 @@ export async function treeFromArguments(paths: readonly string[]): Promise<Map<s
 }
 
 /**
- * A case file named on the command line, read as the folder `unzip` would make
- * of it: `<name>.zip` is read at `<name>/<entry>` (5.6.4), so the zip and its
- * unpacked folder give one reading. The archive is read by `readZip` and
- * nothing else; an entry it refuses is listed as outside every pack and never
- * read, as the walk lists a link.
+ * A case file named on the command line, read as the folder `unzip` would make:
+ * `<name>.zip` reads at `<name>/<entry>` (§5.6.4). An entry `readZip` refuses
+ * is listed outside every pack and never read.
  */
 async function unzip(
   arg: string,
@@ -2398,8 +2047,7 @@ async function unzip(
   try {
     const size = (await handle.stat()).size;
     if (size > MAX_ZIP_ARCHIVE_BYTES) throw new CaseInputError(zipFileRefusal(arg));
-    // One more byte than the size on disk, so a file that grew is noticed; the
-    // archive is read straight into this buffer, once, and never copied.
+    // One byte past the size, to notice growth; read in place, never copied.
     const buf = Buffer.allocUnsafe(size + 1);
     let have = 0;
     for (;;) {
@@ -2440,30 +2088,18 @@ async function unzip(
   }
 }
 
-// ─── `proof case` (proof#141) ────────────────────────────────────────────────
-//
-// The case reading from a terminal, so an auditor holding several packs does
-// not depend on Sanning's page for the one check the audited party cannot
-// write for itself. The twin is `run_case` in `src/sanning_proof/cli.py`, and
-// the two commands are compared as child processes by
-// `cross-kernel/run_case_cli.sh`: same stdout, same `--json`, same exit code,
-// over every `case/` vector.
+// `proof case`: the case reading from a terminal, so an auditor holding several
+// packs does not depend on Sanning's page. Python's twin is `run_case`;
+// `cross-kernel/run_case_cli.sh` holds both to the same stdout, `--json` and
+// exit code. No color, so both print the same bytes.
 //
-// The reading is `readCase`, entire. This command splits the input into packs
-// (the section above, the verify page's rule) and prints what the kernel said.
-// No color: the two commands print the same bytes.
-
-// The exit code of a case verdict is the one table's (`./exit-codes.ts`).
-// `mixed` has its own code, 4, because each other code would say something a
-// mixed case has not established: 0 would soften a case with an unsettled or
-// unreadable outcome in it, 3 would hide the outcomes that did settle, and 1
-// would accuse a case in which nothing was proven wrong. A case holding a
-// failure never exits 4: a proven failure keeps the headline (evidence-bundle
-// 5.5.4 v1.16, A17), so it reads `failed` and exits 1.
+// `mixed` exits 4 because every other code would claim something unproven: 0
+// softens an unsettled outcome, 3 hides the settled ones, 1 accuses. A proven
+// failure keeps the headline (evidence-bundle.md §5.5.4) and exits 1.
 
 export const CASE_USAGE = `sanning-proof case -- a case reading: one verdict over one pack or many, offline
 
-  sanning-proof case <folder or case file>... [--gateways <url,url>] [--files <path>...] [--enclave-policy <file>] [--enclave-rpc <url>] [--json]
+  sanning-proof case <folder or case file>... [--gateways <url,url>] [--files <path>...] [--json]
 
   <folder>    a pack folder (bundle.json plus logs/), a folder that holds
               several packs, or an unzipped case file. Packs are found by the
@@ -2476,7 +2112,7 @@ export const CASE_USAGE = `sanning-proof case -- a case reading: one verdict ove
               read, even under a pack's logs/. Several arguments are read as
               one folder holding them, each under its own name. A folder
               nested more than 32 levels deep, more than 50000 files and
-              folders in all, or a name that is not valid UTF-8 exits 2.
+              folders in all, or a name that is not valid UTF-8 exits 4.
   <case file> a case file named as <name>.zip, read as the folder
               unzip <name>.zip -d <name> would make, so the two give one
               reading. An entry that is encrypted, a symbolic link, stored by
@@ -2487,7 +2123,9 @@ export const CASE_USAGE = `sanning-proof case -- a case reading: one verdict ove
               is listed; the index never moves the verdict.
   --gateways  comma-separated gateway URLs. Each pack's witnesses are then
               looked up on the public record, pack by pack, and reported on
-              the witness line. The lookup never changes the verdict word.
+              the witness line. Only a lookup that finds other bytes, or
+              another witness time, changes the verdict: it disproves
+              witnessed, and the case reads failed.
   --files     files handed in beside the packs, every path up to the next
               option, matched by SHA-256 alone against what every pack's
               signed records commit to. A folder stands for the regular files
@@ -2495,23 +2133,13 @@ export const CASE_USAGE = `sanning-proof case -- a case reading: one verdict ove
               inside it is listed as skipped and never followed. A file under
               a pack's logs/ is offered only when it is named here. The
               verdict never moves.
-  --json      the full reading as JSON: the verdict, every exception and note
+  --json      the full reading as JSON: the verdict, the six claims, the
+              person layer, every exception and note
               with its rendered line, every record of every pack with its
               status (read clean, read flagged, or not read and why), every
               contribution, the packs, each with its index, the files outside
               them, the case file index comparison, the witness line and the
               on-chain half.
-  --enclave-policy
-              a sanning.enclave-policy/v1 file: what this reader accepts of
-              an enclave attestation. Where the packs hold a runner's run, an
-              enclave attestation line and a run-account line print beside
-              the witness line (DRAFT); neither moves the verdict or the exit
-              code. Without a policy, or without an adapter for the provider
-              installed, the line reads not_checked.
-  --enclave-rpc
-              a chain JSON-RPC endpoint: a flare-fcc run also gets the online
-              line, read from the contracts the policy names. It moves
-              nothing either.
 
 Files outside every pack are matched too, always, so
 sanning-proof case audit-file.zip checks a whole download in one command: each
@@ -2529,7 +2157,7 @@ kernel and graded as a pack; every record every pack supplied is read, in one
 pile, under the hand-off rules of envelope-spec section 4.1; a hand-off record
 with no counterpart among the records read is always named, and when a pack
 signed by the key it names is in the reading, it says that pack holds none,
-unless every candidate it had was accounted for by another record (A20),
+unless every candidate it had was accounted for by another record,
 which reads as no counterpart and names no pack.
 
 What it does not establish: that the set of packs is complete (a party can
@@ -2540,19 +2168,18 @@ that any witness is on the public record, which the reading never looks up.
 ${EXIT_CODES_HELP}
 
 case: an input that cannot be read as packs, or an unexpected error in this
-command, exits 2. With --gateways, a witness that does not match on chain exits
-1, and an on-chain half that could not be settled turns 0 into 3.`;
+command, exits 4. With --gateways, a witness that does not match on chain
+exits 1; a lookup that could not be settled moves nothing, and the witness line
+says so.`;
 
-// What Node writes for a lone surrogate on a UTF-8 stream is U+FFFD. Done here
-// rather than left to the stream, so the lines a test captures in process are
-// the lines a reader sees.
+// Node writes U+FFFD for a lone surrogate; doing it here makes captured lines
+// match what a reader sees.
 function noLoneSurrogates(text: string): string {
   return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "�");
 }
 
-// Keys sorted at every depth, arrays left in their order: the Python twin
-// writes `json.dumps(sort_keys=True, indent=2, ensure_ascii=False)` and this is
-// that, byte for byte.
+// Keys sorted at every depth, arrays in order: byte for byte Python's
+// `json.dumps(sort_keys=True, indent=2, ensure_ascii=False)`.
 function sortKeys(v: unknown): unknown {
   if (Array.isArray(v)) return v.map(sortKeys);
   if (v !== null && typeof v === "object") {
@@ -2570,32 +2197,19 @@ function jsonText(v: unknown): string {
 }
 
 
-/**
- * The case verdict's code, moved only by an on-chain half that was asked for:
- * a witness that does not match is a failure whatever the reading said, and an
- * on-chain half that could not be settled is never a clean 0.
- */
-export function caseExitCode(verdict: string, onChainVerdict: string): number {
-  const code = exitCodeFor(verdict);
-  if (onChainVerdict === "failed") return EXIT_FAILED;
-  if (onChainVerdict === "undetermined" && code === EXIT_VERIFIED) return EXIT_UNDETERMINED;
-  return code;
-}
-
 export interface CaseFileData {
   root: string;
   index: string;
   case_id: string | null;
-  findings: { rendered: string }[];
+  findings: { kind: string; rendered: string }[];
 }
 
 interface CaseData {
   title: string;
+  person: Person;
   reliance: string;
   summary: string;
   witness: { rendered: string };
-  enclave_attestation?: { rendered: string[] }[];
-  run_account?: { rendered: string }[];
   exceptions: { rendered: string }[];
   notes: { rendered: string }[];
   packs: {
@@ -2607,7 +2221,13 @@ interface CaseData {
     grade: string | null;
     environment_marker?: EnvironmentMarker;
   }[];
-  records: { pack_index: number; status: string }[];
+  records: {
+    pack_index: number;
+    status: string;
+    pack_ref: string;
+    event_id: string;
+    agent: AgentJson | null;
+  }[];
   environment_marker?: EnvironmentMarker;
   outside: string[];
   not_regular: string[];
@@ -2622,26 +2242,16 @@ const titleOf = (word: string): string =>
     : word;
 
 /**
- * The text report, one line per entry, identical in both kernels. The headline
- * is the verdict's one display title and nothing else sets it (5.5.6, D7); the
- * scope sentence and the witness line are printed with it every time.
+ * The text report, one line per list entry, identical in both kernels. The person
+ * layer comes first (the title, one line per claim that is not proven, the next action,
+ * the notes, the sandbox line and the witness line), then the scope sentence (section
+ * 5.5.6), what a reader may rely on, and the detail.
  */
 function caseReport(data: CaseData): string[] {
-  const lines = [data.title];
-  // Sandbox evidence: printed with every headline the marker is on.
-  if (data.environment_marker !== undefined) lines.push(`  ${SANDBOX_LINE}`);
-  lines.push(`  ${data.summary}`, `  ${data.witness.rendered}`);
-  // Where the packs hold a runner's run: its enclave attestation line and its
-  // run-account line, beside the witness line.
-  const enclave = data.enclave_attestation ?? [];
-  const account = data.run_account ?? [];
-  for (let i = 0; i < Math.min(enclave.length, account.length); i++) {
-    for (const line of enclave[i]!.rendered) lines.push(`  ${line}`);
-    lines.push(`  ${account[i]!.rendered}`);
-  }
-  lines.push(`  ${data.reliance}`);
+  const lines = personText(data.person);
+  lines.push("");
+  lines.push(data.summary, data.reliance);
   for (const e of data.exceptions) lines.push(`  - ${e.rendered}`);
-  for (const n of data.notes) lines.push(`  note: ${n.rendered}`);
   lines.push(`packs         ${data.packs.length}`);
   for (const p of data.packs) {
     const key = p.signing_key !== null ? p.signing_key : "a key this reader cannot read";
@@ -2649,9 +2259,9 @@ function caseReport(data: CaseData): string[] {
       p.grade === null
         ? "not graded"
         : p.grade === "verified" && p.environment_marker !== undefined
-          ? SANDBOX_TITLE
+          ? "Verified, sandbox"
           : titleOf(p.grade);
-    // Each record's status, counted per pack (A43): the JSON lists every one.
+    // Counted per pack; the JSON lists every record.
     const mine = data.records.filter((r) => r.pack_index === p.index);
     const count = (status: string) => mine.filter((r) => r.status === status).length;
     const records =
@@ -2667,6 +2277,17 @@ function caseReport(data: CaseData): string[] {
     }
     lines.push(line);
   }
+  // Every agent record that did not read verified, or carries a finding. A
+  // finding is reported beside its record and moves no verdict.
+  const agents = data.records.filter((r) => r.agent !== null);
+  if (agents.length > 0) {
+    const shown = agents.filter((r) => r.agent!.verdict !== "verified" || r.agent!.findings.length > 0);
+    lines.push(
+      `agent records ${agents.length} read across every pack, ` +
+        `${agents.length - shown.length} verified with no finding`,
+    );
+    for (const r of shown) lines.push(`  ${r.pack_ref}/${r.event_id}  ${r.agent!.rendered}`);
+  }
   if (data.outside.length > 0) {
     lines.push(
       `outside       ${data.outside.length} file(s) sit outside every ` +
@@ -2677,9 +2298,6 @@ function caseReport(data: CaseData): string[] {
       lines.push(links.has(path) ? `  - ${path} (not a regular file: not followed, not read)` : `  - ${path}`);
     }
   }
-  for (const path of data.witness_cache_not_read ?? []) {
-    lines.push(`note          ${witnessCacheRefusedNote(path)}`);
-  }
   for (const c of data.case_file) {
     if (c.index === "absent") continue;
     const label = c.case_id !== null ? `, which says it is about ${c.case_id}` : "";
@@ -2692,8 +2310,7 @@ function caseReport(data: CaseData): string[] {
   }
   const oc = data.on_chain;
   if (oc.checked) {
-    // A drop whose only witnesses are simulated had nothing looked up on a
-    // chain, and the header says so rather than "looked up against".
+    // Only simulated witnesses: nothing was looked up on a chain.
     const simulated = oc.packs.reduce((n, r) => n + (r.simulated ?? 0), 0);
     const onlySimulated =
       simulated > 0 &&
@@ -2720,12 +2337,10 @@ function caseReport(data: CaseData): string[] {
 }
 
 /**
- * The index comparison, once per argument (5.6.3): each folder or case file
- * whose root holds `contents.json`. Every file under `packs/` and `report/` is
- * hashed for it, in pieces, as bytes, and nothing is parsed but the index. The
- * files share one total of 1 GiB across the run, charged in path order; a file
- * larger than what is left is reported as too large to hash, never as a match
- * and never as absent. It is never an input to the reading.
+ * The index comparison, once per argument with a `contents.json` at its root
+ * (§5.6.3). Files under `packs/` and `report/` are hashed in pieces, sharing a
+ * 1 GiB total in path order; a file past what is left reports as too large,
+ * never as a match or absent. Never an input to the reading.
  */
 export async function caseFileReadings(
   tree: Map<string, TreeEntry>,
@@ -2758,9 +2373,8 @@ export async function caseFileReadings(
         .filter((key) => key.startsWith(prefix) && tree.get(key)!.regular)
         .map((key) => [key, key.slice(prefix.length)] as const)
         .filter(([, rel]) => rel.startsWith("packs/") || rel.startsWith("report/"));
-      // The files the index lists are charged first, then the rest, each group
-      // in UTF-16 order, so a file it does not list cannot use up the total and
-      // turn a real mismatch into `too_large`.
+      // Listed files are charged first, so an unlisted file cannot use up the
+      // total and turn a real mismatch into `too_large`.
       for (const [key, rel] of [
         ...candidates.filter(([, rel]) => listed.has(rel)),
         ...candidates.filter(([, rel]) => !listed.has(rel)),
@@ -2803,25 +2417,23 @@ export async function caseFileReadings(
   return out as CaseFileData[];
 }
 
-// One pack's environment marker, as the key its JSON row carries only where
-// the pack holds an envelope signed `dev`.
+// The pack's environment marker, present only for a pack with a `dev` envelope.
 function packMarker(bundle: unknown): { environment_marker?: EnvironmentMarker } {
   const m = environmentMarker([bundle]);
   return m !== null ? { environment_marker: m } : {};
 }
 
 function caseError(e: CaseInputError, asJson: boolean, io: Cli): number {
-  if (asJson) outJson(io, jsonText({ error: e.message, exit_code: EXIT_MALFORMED, hint: e.hint }));
+  if (asJson) outJson(io, jsonText({ error: e.message, exit_code: EXIT_COULD_NOT_RUN, hint: e.hint }));
   io.err(noLoneSurrogates(`case: ${e.message}`));
   if (e.hint) io.err(noLoneSurrogates(`case: ${e.hint}`));
-  return EXIT_MALFORMED;
+  return EXIT_COULD_NOT_RUN;
 }
 
 /**
- * `proof case <folder>... [--gateways <urls>] [--json]`. Every path out of the
- * command is an exit code from the table: an exception nobody expected exits 2,
- * never 1, because 1 would name the evidence failed over a defect in this
- * command.
+ * `proof case <folder>... [--gateways <urls>] [--json]`. An unexpected
+ * exception exits 4, never 1: 1 would call the evidence failed over a defect in
+ * this command.
  */
 export async function runCase(argv: readonly string[], stream: Cli): Promise<number> {
   const io = guard(stream);
@@ -2839,26 +2451,16 @@ export async function runCase(argv: readonly string[], stream: Cli): Promise<num
         io,
       );
     } catch {
-      return EXIT_MALFORMED; // a stream that cannot be written
+      return EXIT_COULD_NOT_RUN; // the stream cannot be written
     }
   }
 }
 
-// The files that sit outside every pack, as files offered (A41, proof#215).
-//
-// Every regular file the split left outside, in the split's order, hashed
-// exactly as a `--files` file is (a folder's file in pieces, a `.zip` entry
-// from the bytes the reader already holds) and named by its path in the tree,
-// `<case name>/<path inside>`, so a `.zip` and the folder `unzip` makes of it
-// name each file alike. A link, a pipe, an entry the zip reader refused (with
-// its own words) and a file that cannot be read are returned as skipped, named
-// and never opened as a pack file. A pack's own files, `bundle.json` and what
-// is under `logs/`, are not outside and are not offered.
-//
-// The files share one total of 1 GiB, the cap the zip reader puts on an
-// archive, charged in that order. A file larger than what is left is skipped as
-// `too_large` and read no further, so a sparse file of a terabyte in a
-// downloaded folder cannot keep `case` from reaching its verdict.
+// The files outside every pack, as files offered (§5.7), in split order. Each
+// is hashed as a `--files` file is and named `<case name>/<path inside>`, so a
+// `.zip` and its unzipped folder name files alike. Links, pipes, refused zip
+// entries and unreadable files are returned as skipped. They share the 1 GiB
+// total; a file past it is `too_large` and read no further.
 export async function looseFiles(
   tree: Map<string, TreeEntry>,
   split: SplitCase,
@@ -2898,67 +2500,11 @@ export async function looseFiles(
   return { offered, skipped };
 }
 
-// A policy file that is not JSON: read, and unreadable (`policy_unreadable`).
-const POLICY_NOT_JSON = Symbol("policy not JSON");
-
-async function readEnclavePolicy(path: string | null): Promise<unknown> {
-  if (path === null) return null;
-  let raw: Uint8Array;
-  try {
-    if (!(await stat(path)).isFile()) throw new CaseInputError(`--enclave-policy ${path} is not a readable file`);
-    raw = new Uint8Array(await readFile(path));
-  } catch (e) {
-    if (e instanceof CaseInputError) throw e;
-    throw new CaseInputError(`--enclave-policy ${path} is not a readable file`);
-  }
-  try {
-    return parseRefusingDuplicates(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(raw));
-  } catch {
-    return POLICY_NOT_JSON;
-  }
-}
-
-/** The two line members of `--json`: one entry per run, with the lines it prints. */
-function runLines(runs: readonly RunReading[]): [Record<string, unknown>[], Record<string, unknown>[]] {
-  const enclave = runs.map((r) => ({
-    pack_ref: r.packRef,
-    pack_index: r.packIndex,
-    event_id: r.eventId,
-    runner_public_key: r.runnerPublicKey,
-    agent_public_key: r.agentPublicKey,
-    state: r.enclave.state,
-    kinds: r.enclave.kinds,
-    notes: r.enclave.notes,
-    reason: r.enclave.reason,
-    provider: r.enclave.provider,
-    evaluation: r.enclave.evaluation,
-    evaluated_at: r.enclave.evaluatedAt,
-    token_checked: r.enclave.tokenChecked,
-    online: r.online !== null ? { state: r.online.state, kinds: r.online.kinds } : null,
-    rendered: renderEnclaveLines(r).map(escapeControl),
-  }));
-  const account = runs.map((r) => ({
-    pack_ref: r.packRef,
-    pack_index: r.packIndex,
-    event_id: r.eventId,
-    runner_public_key: r.runnerPublicKey,
-    state: r.account.state,
-    findings: r.account.findings.map((f) => ({ kind: f.kind, event_id: f.eventId })),
-    notes: r.account.notes.map((n) => ({ kind: n.kind, event_id: n.eventId })),
-    closing_event_id: r.account.closingEventId,
-    reason: r.account.reason,
-    rendered: escapeControl(renderAccountLine(r)),
-  }));
-  return [enclave, account];
-}
-
 async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
   let asJson = false;
   let gateways: string[] = [];
   const paths: string[] = [];
   let filePaths: string[] | undefined;
-  let enclavePolicy: string | null = null;
-  let enclaveRpc: string | null = null;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]!;
     if ((arg === "--help" || arg === "-h" || arg === "help") && paths.length === 0) {
@@ -2972,7 +2518,7 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       if (next === undefined) {
         io.err("case: --gateways requires a comma-separated list of URLs");
         outBlock(io, CASE_USAGE);
-        return EXIT_MALFORMED;
+        return EXIT_COULD_NOT_RUN;
       }
       gateways = next
         .split(",")
@@ -2984,24 +2530,14 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       if (taken.length === 0) {
         io.err("case: --files requires at least one file path");
         outBlock(io, CASE_USAGE);
-        return EXIT_MALFORMED;
+        return EXIT_COULD_NOT_RUN;
       }
       filePaths = [...(filePaths ?? []), ...taken];
       i += taken.length;
-    } else if (arg === "--enclave-policy" || arg === "--enclave-rpc") {
-      const next = argv[i + 1];
-      if (next === undefined) {
-        io.err(arg === "--enclave-policy" ? "case: --enclave-policy requires a policy file" : "case: --enclave-rpc requires a URL");
-        outBlock(io, CASE_USAGE);
-        return EXIT_MALFORMED;
-      }
-      if (arg === "--enclave-policy") enclavePolicy = next;
-      else enclaveRpc = next;
-      i++;
     } else if (arg.startsWith("--")) {
       io.err(`case: unknown option ${arg}`);
       outBlock(io, CASE_USAGE);
-      return EXIT_MALFORMED;
+      return EXIT_COULD_NOT_RUN;
     } else {
       paths.push(arg);
     }
@@ -3009,7 +2545,7 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
   if (paths.length === 0) {
     io.err("case: at least one pack is required");
     outBlock(io, CASE_USAGE);
-    return EXIT_MALFORMED;
+    return EXIT_COULD_NOT_RUN;
   }
 
   let offered: OfferedFile[] | undefined;
@@ -3020,29 +2556,23 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
     offered = read.offered;
     skipped = read.skipped;
   }
-  let policy: unknown;
-  try {
-    policy = await readEnclavePolicy(enclavePolicy);
-  } catch (e) {
-    if (e instanceof CaseInputError) return caseError(e, asJson, io);
-    throw e;
-  }
 
   const whole = { n: MAX_FOLDER_BYTES };
   let split;
   let tree: Map<string, TreeEntry>;
-  let bundles: [SplitPack, unknown][];
+  let loaded: [SplitPack, [unknown, string | null]][];
   try {
     tree = await treeFromArguments(paths);
     split = await splitCase(tree, (entry, key) => readFileEntry(entry, key, whole));
-    bundles = split.packs.map((p): [SplitPack, unknown] => [p, loadBundle(p)]);
+    loaded = split.packs.map((p): [SplitPack, [unknown, string | null]] => [p, loadBundle(p)]);
   } catch (e) {
     if (e instanceof CaseInputError) return caseError(e, asJson, io);
     throw e;
   }
+  const bundles = loaded.map(([p, [bundle]]): [SplitPack, unknown] => [p, bundle]);
 
   const reading = await readCase(
-    bundles.map(([p, bundle]) => ({ ref: p.ref, bundle, content: p.content })),
+    loaded.map(([p, [bundle, why]]) => ({ ref: p.ref, bundle, content: p.content, unreadable: why })),
   );
   let caseFile: CaseFileData[];
   try {
@@ -3056,34 +2586,68 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
   for (const [p, bundle] of bundles) {
     caches.push(readWitnessCache(bundle, await witnessCacheBytes(tree, split, p, whole, cacheRefused)));
   }
-  const confirmedStamps: string[][] = [];
   const onChain = await onChainHalf(
     bundles.map(([p, bundle], i): [string, unknown, CachedWitnessTime[]] => [p.ref, bundle, caches[i]!]),
     gateways,
     { ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}) },
-    confirmedStamps,
   );
   const witness = witnessLine(onChain, caches.flat());
-  // Sandbox evidence: over every envelope every pack holds, and per
-  // pack for its row. Only a case that would otherwise exit 0 exits 5.
+  // Sandbox evidence, over every pack and per pack for its row. A label, never a
+  // verdict: a case that verifies over a `dev` record exits 3.
   const marker = environmentMarker(bundles.map(([, b]) => b));
-  // Undetermined only because a simulated witness cannot be looked up: every
-  // other witness confirmed, none unreachable or mismatched, every pack names
-  // one. With every record signed `dev` that is sandbox evidence, exit 5.
-  const simulatedOnly =
-    reading.verdict === "verified" &&
-    onChain.verdict === "undetermined" &&
-    onChain.packs.some((r) => (r.simulated ?? 0) > 0) &&
-    onChain.packs.every(
-      (r) => r.witnesses > 0 && r.unreachable === 0 && r.mismatched === 0 && r.not_checked === (r.simulated ?? 0),
-    );
-  const code = sandboxExit(caseExitCode(reading.verdict, onChain.verdict), marker, simulatedOnly);
+  // The lookup is outside the reading (it makes network calls the reading never does).
+  // Only a lookup that finds other bytes, or another time, disproves `witnessed`.
+  const problems: Problem[] = [...reading.problems];
+  onChain.packs.forEach((row, index) => {
+    if (row.mismatched > 0) problems.push(problem("witness_differs", [[index, null]]));
+    if ((row.witness_times ?? []).some((t) => t.outcome === "differs")) {
+      problems.push(problem("witness_time_differs", [[index, null]]));
+    }
+  });
+  const inScope: string[] = [];
+  const notInScope: Partial<Record<Claim, NotInScopeReason>> = {};
+  if (reading.handoffRecords > 0 || reading.packs.some((p) => p.declarationVersion !== null)) {
+    inScope.push("complete");
+  } else {
+    notInScope.complete = "no_declaration_and_no_handoff";
+  }
+  if (reading.handoffRecords > 0) inScope.push("agreed");
+  else notInScope.agreed = "no_handoff";
+  if (reading.handoffRecords > 0 || reading.records.some((r) => r.agent !== null)) {
+    inScope.push("follows_rules");
+  } else {
+    notInScope.follows_rules = "no_agent_or_handoff_records";
+  }
+  const packRefs = reading.packs.map((p) => p.ref);
+  const recordIds = new Map(reading.records.map((r) => [`${r.packIndex}/${r.recordIndex}`, r.eventId]));
+  const claims = claimsOf(problems, inScope, {
+    notInScope,
+    labels: (pack, record) => [
+      pack !== null ? (packRefs[pack] ?? null) : null,
+      recordIds.get(`${pack}/${record}`) ?? null,
+    ],
+  });
+  const verdict = verdictOf(claims);
+  const code = exitCodeFor(verdict.status, marker);
+  const notes = reading.notes.map((n) => note(n.kind, renderCaseNote(n)));
+  notes.push(...findingNotes(reading.records.map((r) => r.agent)));
+  notes.push(...caseFile.flatMap((c) => c.findings.map((f) => note(f.kind, f.rendered))));
+  notes.push(...cacheRefused.map((p) => note("witness_cache_refused", witnessCacheRefusedNote(p))));
+  const person = renderPerson(verdict, claims, orderedNotes(notes), marker, witnessText(witness), witness.state);
   const nil = <T>(v: T | undefined): T | null => (v === undefined ? null : v);
 
   const data = {
-    verdict: reading.verdict,
-    title: reading.verdict === "verified" && marker !== null ? SANDBOX_TITLE : titleOf(reading.verdict),
-    reliance: caseReliance(reading.verdict, reading.handoffRecords),
+    verdict,
+    title: titleOf(verdict.status),
+    reliance: caseReliance(
+      verdict.status,
+      reading.handoffRecords,
+      marker,
+      verdict.reason_kind ?? null,
+    ),
+    claims,
+    person,
+    sandbox: marker !== null,
     exit_code: code,
     summary: renderCaseSummary(reading),
     witness: {
@@ -3130,6 +2694,7 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       findings: r.findings,
       failed_checks: r.failedChecks,
       counterparts: r.counterparts,
+      agent: r.agent === null ? null : agentJson(r.agent),
     })),
     contributions: reading.contributions.map(([who, verdict]) => [who, verdict]),
     packs: bundles.map(([p], i) => ({
@@ -3151,24 +2716,9 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
     ...(cacheRefused.length > 0 ? { witness_cache_not_read: cacheRefused } : {}),
     ...(marker !== null ? { environment_marker: marker } : {}),
   };
-  // The runs in the drop (DRAFT, specs/enclave-attestation.md and
-  // run-records.md): an enclave attestation line and a run-account line per
-  // run, beside the witness line. Neither moves `code`, and a drop that holds
-  // no run prints and writes exactly what it did before.
-  const runs = (
-    await readRuns(
-      bundles.map(([p, bundle]) => ({ ref: p.ref, bundle, content: p.content })),
-      { policy, adapters: await loadInstalledAdapters(), rpc: enclaveRpc, witnessed: confirmedStamps },
-    )
-  ).runs;
-  const withRuns: Record<string, unknown> = data;
-  if (runs.length > 0) [withRuns.enclave_attestation, withRuns.run_account] = runLines(runs);
-  // The files outside every pack (evidence-bundle.md 5.7, A29, A41), always,
-  // then the files after --files. A pack's logs/ is its side content and is
-  // never an offered file; only the paths after --files are. Both are matched
-  // by SHA-256 alone and nothing here moves `code`. The section is printed when
-  // there is a file to say something about, so a case with nothing outside
-  // every pack and no --files prints what it always did.
+  // Files outside every pack, then the `--files` paths (evidence-bundle.md
+  // §5.7). A pack's `logs/` is never offered. Matched by SHA-256 alone; nothing
+  // here moves `code`. Printed only when there is something to say.
   const loose = await looseFiles(tree, split);
   let fileLines: string[] = [];
   const out: Record<string, unknown> = data;
@@ -3181,9 +2731,8 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       skipped: [...loose.skipped, ...skipped],
     };
     out.files = fileMatchToJson(fileReading);
-    // No --files: one count line for the recorded files no loose file matched,
-    // not a line for each of them, and none for a record the pack's own logs
-    // disclose and bind. With --files, and in --json, every one is listed.
+    // Without --files, one count line for unmatched recorded files; with
+    // --files or --json, every one is listed.
     fileLines = renderFileMatch(
       fileReading,
       offered !== undefined
@@ -3196,23 +2745,12 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
   return code;
 }
 
-function shortTx(tx: string): string {
-  if (tx.length <= 16) return tx;
-  return `${tx.slice(0, 8)}…${tx.slice(-4)}`;
-}
-
-function shortId(id: string): string {
-  if (id.length <= 12) return id;
-  return `${id.slice(0, 8)}…`;
-}
-
-// Entry point when run as a binary (not when imported by tests).
+// Entry point when run as a binary, not when imported.
 const isMain = (() => {
   try {
     if (!process.argv[1]) return false;
-    // realpath BOTH sides: when run via a bin symlink (npx / node_modules/.bin/proof
-    // -> dist/cli.js), process.argv[1] is the symlink and import.meta.url is the target,
-    // so a naive compare skips main(). Resolving both to the real path makes them match.
+    // Resolve both sides: under a bin symlink, argv[1] is the link and
+    // import.meta.url the target.
     return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
   } catch {
     return false;
@@ -3229,6 +2767,6 @@ if (isMain) {
     })
     .catch((e) => {
       process.stderr.write(`fatal: ${escapeControl(e instanceof Error ? e.stack ?? e.message : String(e))}\n`);
-      process.exitCode = EXIT_MALFORMED;
+      process.exitCode = EXIT_COULD_NOT_RUN;
     });
 }