@sanning/proof 0.18.0 → 0.19.0

package/src/cli.ts

@@ -17,6 +17,8 @@
 //      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.
 //
@@ -50,12 +52,12 @@ import { fileURLToPath } from "node:url";
 
 import { isAgentProofSpec, verifyAgentProof } from "./agent-proof.js";
 import type { AgentProofResult } from "./agent-proof.js";
-import { CHAIN_READING_SCOPE, readChains, renderChainFinding } from "./chain.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.
 type ChainOutcome = ChainReading | { unreadable: string };
-import type { ChainReading } from "./chain.js";
+import type { ChainLink, ChainReading } from "./chain.js";
 import {
   VERDICT_DISPLAY_TITLES,
   caseReliance,
@@ -78,6 +80,9 @@ 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,
@@ -107,10 +112,21 @@ import {
   EXIT_CODES_HELP,
   EXIT_FAILED,
   EXIT_MALFORMED,
+  EXIT_SANDBOX,
   EXIT_UNDETERMINED,
   EXIT_VERIFIED,
   exitCodeFor,
+  sandboxExit,
 } from "./exit-codes.js";
+import {
+  type EnvironmentMarker,
+  environmentMarker,
+  onlySimulatedUnsettled,
+  simulatedOnlyRun,
+  SANDBOX_HEADLINE,
+  SANDBOX_LINE,
+  SANDBOX_TITLE,
+} from "./environment.js";
 
 interface Cli {
   out: (s: string) => void;
@@ -416,7 +432,7 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
       gateways,
       ...(io.fetchImpl ? { fetchImpl: io.fetchImpl } : {}),
     });
-    return reportAgentProof(result, bundlePath, gateways, io, sink);
+    return reportAgentProof(result, bundlePath, gateways, io, sink, parsed);
   }
 
   // Default: treat anything else as an evidence bundle. verifyEvidenceBundle
@@ -429,8 +445,11 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
   });
   // 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 never move `exit`, because a chain is not a completeness proof and
-  // an exit code is exactly the kind of thing people read as one.
+  // 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
@@ -445,7 +464,16 @@ async function runVerify(rest: string[], io: Cli, sink: JsonSink | null): Promis
   } catch (e) {
     chains = { unreadable: errMsg(e) };
   }
-  const exit = reportEvidence(result, bundlePath, gateways, io, chains, parsed, logs, sink);
+  // 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.
+  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.
   if (offered !== undefined) {
@@ -1397,6 +1425,7 @@ function reportEvidence(
   gateways: string[],
   io: Cli,
   chains: ChainOutcome,
+  links: ChainLink[] | null,
   parsed: unknown,
   logs: LoadedLogs | undefined,
   sink: JsonSink | null,
@@ -1503,7 +1532,12 @@ function reportEvidence(
   // 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.
-  const declaration = checkDeclaration(parsed, logs?.content);
+  //
+  // 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),
@@ -1511,8 +1545,34 @@ function reportEvidence(
     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);
+
   io.out("");
-  printRollup(grade.verdict, result.status, result.assertedStatus, gateways, result.onChainChecked, io);
+  printRollup(
+    grade.verdict,
+    result.status,
+    result.assertedStatus,
+    gateways,
+    result.onChainChecked,
+    io,
+    marker,
+    exit === EXIT_SANDBOX,
+    simulatedOnlyRun(result, gateways),
+  );
   io.out(
     paint(
       `  declaration: ${renderDeclarationSummary(declaration)}`,
@@ -1539,8 +1599,8 @@ function reportEvidence(
     );
   }
 
-  if (sink) sink.data = verifyJson(result, grade, declaration, chains);
-  return mapGradeToExit(grade);
+  if (sink) sink.data = verifyJson(result, grade, declaration, chains, marker);
+  return exit;
 }
 
 /**
@@ -1553,6 +1613,7 @@ function verifyJson(
   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) {
@@ -1579,6 +1640,9 @@ function verifyJson(
       ? { 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 } : {}),
   };
 }
 
@@ -1661,7 +1725,9 @@ function reportAgentProof(
   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,
@@ -1669,6 +1735,7 @@ function reportAgentProof(
       spec_version: "sanning.agent.proof/v1",
       on_chain_checked: result.onChainChecked,
       notes: [...result.errors],
+      ...(marker !== null ? { environment_marker: marker } : {}),
     };
   }
   if (result.status === "malformed") {
@@ -1687,10 +1754,11 @@ function reportAgentProof(
   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.
-  printRollup(result.status, result.status, null, gateways, result.onChainChecked, io);
+  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));
 
-  return exitCodeFor(result.status);
+  return exit;
 }
 
 function printRollup(
@@ -1700,12 +1768,27 @@ function printRollup(
   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)`
-    : "verified offline (no gateway re-fetch requested)";
+    : 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 (headline) {
+  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;
@@ -1723,6 +1806,7 @@ function printRollup(
       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
@@ -2379,7 +2463,7 @@ async function unzip(
 
 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>...] [--json]
+  sanning-proof case <folder or case file>... [--gateways <url,url>] [--files <path>...] [--enclave-policy <file>] [--enclave-rpc <url>] [--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
@@ -2417,6 +2501,17 @@ export const CASE_USAGE = `sanning-proof case -- a case reading: one verdict ove
               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
@@ -2499,6 +2594,8 @@ interface CaseData {
   reliance: string;
   summary: string;
   witness: { rendered: string };
+  enclave_attestation?: { rendered: string[] }[];
+  run_account?: { rendered: string }[];
   exceptions: { rendered: string }[];
   notes: { rendered: string }[];
   packs: {
@@ -2508,8 +2605,10 @@ interface CaseData {
     unaccounted: string[];
     signing_key: string | null;
     grade: string | null;
+    environment_marker?: EnvironmentMarker;
   }[];
   records: { pack_index: number; status: string }[];
+  environment_marker?: EnvironmentMarker;
   outside: string[];
   not_regular: string[];
   case_file: CaseFileData[];
@@ -2528,18 +2627,30 @@ const titleOf = (word: string): string =>
  * scope sentence and the witness line are printed with it every time.
  */
 function caseReport(data: CaseData): string[] {
-  const lines = [
-    data.title,
-    `  ${data.summary}`,
-    `  ${data.witness.rendered}`,
-    `  ${data.reliance}`,
-  ];
+  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}`);
   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";
-    const grade = p.grade !== null ? titleOf(p.grade) : "not graded";
+    const grade =
+      p.grade === null
+        ? "not graded"
+        : p.grade === "verified" && p.environment_marker !== undefined
+          ? SANDBOX_TITLE
+          : titleOf(p.grade);
     // Each record's status, counted per pack (A43): the JSON lists every one.
     const mine = data.records.filter((r) => r.pack_index === p.index);
     const count = (status: string) => mine.filter((r) => r.status === status).length;
@@ -2581,16 +2692,27 @@ 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".
+    const simulated = oc.packs.reduce((n, r) => n + (r.simulated ?? 0), 0);
+    const onlySimulated =
+      simulated > 0 &&
+      oc.packs.every((r) => (r.simulated ?? 0) === r.witnesses && (r.witness_times ?? []).length === 0);
     lines.push(
-      `on-chain      looked up against ${oc.gateways.length} gateway(s), ` +
-        "pack by pack; the reading above is offline and this does not " +
-        "change it",
+      onlySimulated
+        ? "on-chain      nothing looked up: every witness here is simulated, " +
+            "which is not on a chain; the reading above is offline and this " +
+            "does not change it"
+        : `on-chain      looked up against ${oc.gateways.length} gateway(s), ` +
+            "pack by pack; the reading above is offline and this does not " +
+            "change it",
     );
     for (const r of oc.packs) {
+      const sim = r.simulated ? `, ${r.simulated} of them simulated (not on a chain)` : "";
       lines.push(
         `  ${r.ref}  ${r.witnesses} witness(es): ${r.confirmed} ` +
           `confirmed, ${r.mismatched} mismatched, ${r.unreachable} ` +
-          `unreachable, ${r.not_checked} not checked`,
+          `unreachable, ${r.not_checked} not checked${sim}`,
       );
     }
   }
@@ -2681,6 +2803,13 @@ 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`.
+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 }));
   io.err(noLoneSurrogates(`case: ${e.message}`));
@@ -2769,11 +2898,67 @@ 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) {
@@ -2803,6 +2988,16 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       }
       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);
@@ -2825,6 +3020,13 @@ 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;
@@ -2854,18 +3056,33 @@ 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());
-  const code = caseExitCode(reading.verdict, onChain.verdict);
+  // Sandbox evidence: over every envelope every pack holds, and per
+  // pack for its row. Only a case that would otherwise exit 0 exits 5.
+  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);
   const nil = <T>(v: T | undefined): T | null => (v === undefined ? null : v);
 
   const data = {
     verdict: reading.verdict,
-    title: titleOf(reading.verdict),
+    title: reading.verdict === "verified" && marker !== null ? SANDBOX_TITLE : titleOf(reading.verdict),
     reliance: caseReliance(reading.verdict, reading.handoffRecords),
     exit_code: code,
     summary: renderCaseSummary(reading),
@@ -2925,13 +3142,27 @@ async function caseCommand(argv: readonly string[], io: Cli): Promise<number> {
       grade: reading.packs[i]!.grade,
       records_withheld: reading.packs[i]!.recordsWithheld,
       declaration_version: reading.packs[i]!.declarationVersion,
+      ...packMarker(bundles[i]![1]),
     })),
     outside: split.outside,
     not_regular: split.notRegular,
     case_file: caseFile,
     on_chain: onChain,
     ...(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