humanish 0.109.1 → 0.110.1

package/dist/run/sandbox-ids.js

@@ -0,0 +1,198 @@
+// A run's raw sandbox ids live in one place: sandbox-receipts.ndjson, which reclaim reads to kill
+// them and export omits. Every other record a run writes (run.json, its review and projections, the
+// cleanup and reclaim receipts) and every result or CLI line names a sandbox by marker and digest,
+// so output an agent pastes into an issue never carries an id.
+import { opendir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { readPlainText } from "../evidence/plain-text.js";
+import { collectSandboxIds, redactSandboxIds, sandboxIdDigest, REDACTED_SANDBOX_ID, } from "../evidence/redaction.js";
+import { readContainedRegularFile, writeContainedOutputFile, } from "./contained-output.js";
+import { bindExistingRunArtifactPaths, isSafeRunIdSegment, validatePreparedRunRootIdentity, } from "./paths.js";
+import { appendedSandboxIds, parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT, } from "./sandbox-receipts.js";
+/** How text names a sandbox: the marker with the id's digest. */
+function sandboxIdLabel(id) {
+    return `${REDACTED_SANDBOX_ID.slice(0, -1)} ${sandboxIdDigest(id)}]`;
+}
+/**
+ * How YAML names a sandbox: the label without its brackets, since a plain scalar that starts with
+ * `[` reads as a list. Every other byte of the file stays as written.
+ */
+function yamlSandboxIdLabel(id) {
+    return `redacted-sandbox-id-${sandboxIdDigest(id)}`;
+}
+/** `text` with every occurrence of each raw id replaced by its label, longest id first. */
+export function scrubSandboxIds(text, ids, label = sandboxIdLabel) {
+    const unique = [...new Set(ids)].filter((id) => id.length > 0);
+    unique.sort((left, right) => right.length - left.length);
+    return unique.reduce((current, id) => current.split(id).join(label(id)), text);
+}
+/**
+ * `value` as it may be written or returned: ids at the sandbox-id keys become the marker and a
+ * digest, and any raw id left in free text or a URL becomes its label.
+ */
+export function publicSandboxView(value, ids) {
+    const redacted = redactSandboxIds(value);
+    const known = [...ids];
+    if (known.length === 0)
+        return redacted;
+    const text = JSON.stringify(redacted);
+    if (text === undefined)
+        return redacted;
+    const scrubbed = scrubSandboxIds(text, known);
+    return (scrubbed === text ? redacted : JSON.parse(scrubbed));
+}
+/** The raw sandbox ids a receipts journal names. */
+function receiptSandboxIds(journal) {
+    return parseSandboxReceipts(journal.toString()).map((receipt) => receipt.sandboxId);
+}
+/**
+ * The raw ids at sandbox-id keys in `value`, such as a run.json recorded before 0.110. A value
+ * shorter than an E2B id is left to the key rule, so the text scrub never rewrites a common word.
+ */
+export function keyedSandboxIds(value) {
+    return [...collectSandboxIds(value)].filter((id) => id.length >= 8);
+}
+/** The JSON records in one file's text: one document, or one per NDJSON line. */
+function jsonRecords(file, text) {
+    // Most run files name no sandbox key, and parsing each one would slow verify on large runs. A
+    // key spelled with an escape only shows once parsed.
+    if (!/"(?:sandboxId|subjectSandboxId|providerResources|resources)"|\\u/.test(text))
+        return [];
+    const parse = (part) => {
+        try {
+            return [JSON.parse(part)];
+        }
+        catch {
+            return [];
+        }
+    };
+    if (/\.json$/i.test(file))
+        return parse(text);
+    if (/\.(?:ndjson|jsonl)$/i.test(file))
+        return text.split("\n").flatMap(parse);
+    return [];
+}
+/**
+ * Every raw sandbox id a run's files name: the receipts', and any at a sandbox-id key in its
+ * JSON, which is where a run from before 0.110 that has no receipts still records them.
+ */
+export function inventorySandboxIds(files) {
+    const ids = new Set();
+    for (const file of files) {
+        if (file.path === SANDBOX_RECEIPTS_ARTIFACT) {
+            for (const id of receiptSandboxIds(file.bytes))
+                ids.add(id);
+            continue;
+        }
+        for (const record of jsonRecords(file.path, file.bytes.toString("utf8")))
+            for (const id of keyedSandboxIds(record))
+                ids.add(id);
+    }
+    return [...ids];
+}
+/** Whether a run file's JSON holds a raw id at a sandbox-id key, which no receipt may name. */
+export function holdsKeyedSandboxId(file, text) {
+    return jsonRecords(file, text).some((record) => collectSandboxIds(record).size > 0);
+}
+/**
+ * The raw sandbox ids a run's receipts journal, with any this process receipted whose append
+ * failed; empty when there are none or the journal cannot be read.
+ */
+export async function readRunSandboxIds(root) {
+    let journaled = [];
+    try {
+        const bytes = await readContainedRegularFile(root, SANDBOX_RECEIPTS_ARTIFACT);
+        if (bytes)
+            journaled = receiptSandboxIds(bytes);
+    }
+    catch {
+        // The ids this process receipted still apply.
+    }
+    return [...new Set([...journaled, ...appendedSandboxIds(root)])];
+}
+/**
+ * `value` as a run writes it: raw sandbox ids stay in the run's sandbox-receipts.ndjson, and the
+ * file names each by marker and digest.
+ */
+export async function withPublicSandboxIds(root, value) {
+    return publicSandboxView(value, await readRunSandboxIds(root));
+}
+/**
+ * The bytes of `file` with each raw id replaced by its label: the same buffer when none occurs, or
+ * when the bytes are not the plain text verify and export read as text.
+ */
+export function scrubSandboxIdBytes(file, bytes, ids) {
+    if (!ids.some((id) => id.length > 0 && bytes.includes(id)))
+        return bytes;
+    const decoded = readPlainText(bytes);
+    if (!decoded.ok)
+        return bytes;
+    const label = /\.ya?ml$/i.test(file) ? yamlSandboxIdLabel : sandboxIdLabel;
+    return Buffer.from(scrubSandboxIds(decoded.text, ids, label));
+}
+/** The run files the sweep rewrites: the text formats export copies, and the Observer page. */
+const TEXT_FILE = /\.(?:json|ndjson|jsonl|md|txt|log|yaml|yml|csv|html)$/i;
+/** Enough for any run directory; a sweep stops there rather than hold up the run's finish. */
+const MAX_SWEPT_ENTRIES = 10_000;
+/**
+ * Rewrite each file of a finished run that names one of its raw sandbox ids, apart from the
+ * receipts, with the label in place of the id. Writers such as a participant's actor.json can
+ * quote an SDK error that names the sandbox. Run.finish calls it before analysis reads the run.
+ * Best effort: verify grades a file this misses.
+ */
+export async function scrubRunSandboxIds(paths) {
+    const ids = await readRunSandboxIds(paths);
+    if (ids.length === 0)
+        return;
+    const valid = await validatePreparedRunRootIdentity(paths).then(() => true, () => false);
+    if (!valid)
+        return;
+    const scrub = async (file) => {
+        const bytes = await readContainedRegularFile(paths, file);
+        if (bytes === null)
+            return;
+        const scrubbed = scrubSandboxIdBytes(file, bytes, ids);
+        if (scrubbed !== bytes)
+            await writeContainedOutputFile(paths, file, scrubbed);
+    };
+    let seen = 0;
+    const walk = async (relative) => {
+        const directory = path.join(paths.physicalRunRoot, relative);
+        // A directory replaced by a link after it was listed resolves elsewhere and is not walked.
+        if ((await realpath(directory).catch(() => null)) !== directory)
+            return;
+        const listing = await opendir(directory).catch(() => null);
+        if (listing === null)
+            return;
+        for await (const entry of listing) {
+            // Returning from the loop closes the listing.
+            if (++seen > MAX_SWEPT_ENTRIES)
+                return;
+            const file = relative ? `${relative}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+                await walk(file);
+            else if (entry.isFile() && file !== SANDBOX_RECEIPTS_ARTIFACT && TEXT_FILE.test(file))
+                // A file that cannot be scrubbed stays as written; verify names it.
+                await scrub(file).catch(() => { });
+        }
+    };
+    await walk("").catch(() => {
+        // A directory that changed while it was listed ends the sweep; verify names what it missed.
+    });
+}
+/**
+ * A run's result as it may be returned or printed: the same object when it names no sandbox,
+ * otherwise its public view, scrubbed of the ids the run's receipts journal.
+ */
+export async function publicRunResult(result, cwd) {
+    let ids = [];
+    if (typeof result.runId === "string" && isSafeRunIdSegment(result.runId)) {
+        try {
+            ids = await readRunSandboxIds(await bindExistingRunArtifactPaths(cwd, result.runId));
+        }
+        catch {
+            // A run that never created its directory has no receipts; the keys are still redacted.
+        }
+    }
+    return publicSandboxView(result, ids);
+}

package/dist/run/sandbox-receipts.d.ts

@@ -20,6 +20,8 @@ export interface SandboxReceipt {
 export interface ParsedSandboxReceipt extends Omit<SandboxReceipt, "provider"> {
     provider: string;
 }
+/** The ids this process has receipted for `root`, whether or not the journal write landed. */
+export declare function appendedSandboxIds(root: PreparedOutputRoot): string[];
 /**
  * Append one receipt. Best-effort by design: the receipt exists to protect the run, so a failed
  * receipt write must never fail the participant. The only cost of a miss is that `reclaim` cannot see
@@ -27,5 +29,19 @@ export interface ParsedSandboxReceipt extends Omit<SandboxReceipt, "provider"> {
  * artifact write uses; append (not atomic-replace) keeps racing participants' receipts intact.
  */
 export declare function appendSandboxReceipt(root: PreparedOutputRoot, receipt: SandboxReceipt): Promise<void>;
+/** Append one owner line; false when the write failed, which never fails the create. */
+export declare function appendSandboxOwner(root: PreparedOutputRoot, owner: SandboxOwnerTags): Promise<boolean>;
+/** The owner tags every sandbox carries; sandboxOwnerTags in src/run/sandbox-creates.ts. */
+export type SandboxOwnerTags = {
+    tool: "humanish";
+    runId: string;
+    runKey: string;
+};
+/**
+ * The owner tag sets a journal's owner lines record for the run named `runId`. Only a complete
+ * tuple counts: provider e2b, `tool: humanish`, this run's id and a well-formed key, and nothing
+ * else. A partial or foreign line would widen reclaim's search past this run, so it is skipped.
+ */
+export declare function parseSandboxOwners(text: string, runId: string): SandboxOwnerTags[];
 /** Parse a receipts file leniently: a torn final line (crash mid-append) drops, valid lines keep. */
 export declare function parseSandboxReceipts(text: string): ParsedSandboxReceipt[];

package/dist/run/sandbox-receipts.js

@@ -4,6 +4,23 @@
 import { appendFile } from "node:fs/promises";
 import { prepareContainedOutputFile } from "./contained-output.js";
 export const SANDBOX_RECEIPTS_ARTIFACT = "sandbox-receipts.ndjson";
+/**
+ * The ids this process has receipted for each run directory, kept even when the append fails, so
+ * the run's other records can still be scrubbed of them. Keyed by the directory's identity, so a
+ * run created later at a deleted run's path starts empty, and only the latest runs are kept.
+ */
+const appended = new Map();
+const MAX_REMEMBERED_RUNS = 64;
+function rootKey(root) {
+    const [where, { dev, ino, birthtimeNs }] = "physicalRunRoot" in root
+        ? [root.physicalRunRoot, root.runRootIdentity]
+        : [root.physicalPath, root.identity];
+    return `${where}\0${dev}:${ino}:${birthtimeNs}`;
+}
+/** The ids this process has receipted for `root`, whether or not the journal write landed. */
+export function appendedSandboxIds(root) {
+    return [...(appended.get(rootKey(root)) ?? [])];
+}
 /**
  * Append one receipt. Best-effort by design: the receipt exists to protect the run, so a failed
  * receipt write must never fail the participant. The only cost of a miss is that `reclaim` cannot see
@@ -11,6 +28,15 @@ export const SANDBOX_RECEIPTS_ARTIFACT = "sandbox-receipts.ndjson";
  * artifact write uses; append (not atomic-replace) keeps racing participants' receipts intact.
  */
 export async function appendSandboxReceipt(root, receipt) {
+    const key = rootKey(root);
+    const ids = appended.get(key) ?? new Set();
+    appended.delete(key);
+    appended.set(key, ids.add(receipt.sandboxId));
+    for (const oldest of appended.keys()) {
+        if (appended.size <= MAX_REMEMBERED_RUNS)
+            break;
+        appended.delete(oldest);
+    }
     try {
         const filePath = await prepareContainedOutputFile(root, SANDBOX_RECEIPTS_ARTIFACT);
         await appendFile(filePath, `${JSON.stringify(receipt)}\n`, "utf8");
@@ -19,6 +45,50 @@ export async function appendSandboxReceipt(root, receipt) {
         // Swallowed on purpose; see the contract above.
     }
 }
+/** Append one owner line; false when the write failed, which never fails the create. */
+export async function appendSandboxOwner(root, owner) {
+    try {
+        const line = { at: new Date().toISOString(), provider: "e2b", owner };
+        const filePath = await prepareContainedOutputFile(root, SANDBOX_RECEIPTS_ARTIFACT);
+        // The leading newline ends a line an earlier append left torn, so this record parses.
+        await appendFile(filePath, `\n${JSON.stringify(line)}\n`, "utf8");
+        return true;
+    }
+    catch {
+        // Never fails the create. Without the line, reclaim reports the run's sandboxes as unknown,
+        // never clean, so the next create tries again.
+        return false;
+    }
+}
+const RUN_KEY = /^[0-9a-f]{16}$/;
+/**
+ * The owner tag sets a journal's owner lines record for the run named `runId`. Only a complete
+ * tuple counts: provider e2b, `tool: humanish`, this run's id and a well-formed key, and nothing
+ * else. A partial or foreign line would widen reclaim's search past this run, so it is skipped.
+ */
+export function parseSandboxOwners(text, runId) {
+    const owners = new Map();
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const owner = parsed.owner;
+            if (parsed.provider !== "e2b" || owner === null || typeof owner !== "object")
+                continue;
+            if (Object.keys(owner).length !== 3 || owner.tool !== "humanish" || owner.runId !== runId)
+                continue;
+            if (typeof owner.runKey !== "string" || !RUN_KEY.test(owner.runKey))
+                continue;
+            owners.set(owner.runKey, { tool: "humanish", runId, runKey: owner.runKey });
+        }
+        catch {
+            // A torn line: skip it.
+        }
+    }
+    return [...owners.values()];
+}
 /** Parse a receipts file leniently: a torn final line (crash mid-append) drops, valid lines keep. */
 export function parseSandboxReceipts(text) {
     const receipts = [];

package/dist/run/stats.d.ts

@@ -1,3 +1,4 @@
+import { type RunDisplayState } from "./display.js";
 import { type CostTotals, type CostRow } from "./costs.js";
 declare const STATS_SCHEMA = "humanish.stats.v2";
 interface StatsParticipants {
@@ -13,6 +14,7 @@ interface StatsStudyRow {
     dryRun: number;
     /** Runs whose bundle carries a verdict; the denominator for passRate. */
     judged: number;
+    /** Runs that show as passed (runDisplay in src/run/display.ts): a pass verdict and an ok run. */
     passed: number;
     /** passed / judged, absent when judged is 0. */
     passRate?: number;
@@ -52,7 +54,10 @@ export interface StatsResult {
         estimatedSpendUsd: number;
         unpricedRuns: number;
         participants: StatsParticipants;
+        /** The participants' verdicts. `outcomes` says how many runs passed. */
         verdicts: Record<string, number>;
+        /** Runs by the state every surface shows them in (runDisplay in src/run/display.ts). */
+        outcomes: Partial<Record<RunDisplayState, number>>;
         costs: CostTotals;
     };
     studies: StatsStudyRow[];

package/dist/run/stats.js

@@ -2,6 +2,7 @@
 // numbers under the per-run rules: an estimate is labelled an estimate, a run whose cost is unknown
 // counts as unknown and never as zero, and every rate has a denominator next to it.
 import path from "node:path";
+import { runDisplay, runDisplayLabel } from "./display.js";
 import { readRunIndex } from "./run-index.js";
 import { addCostTotals, emptyCostTotals, readCostTotals, } from "./costs.js";
 import { round6 } from "./pricing.js";
@@ -68,7 +69,7 @@ function addToStudyRow(studies, entry, runUsd, costs) {
         row.dryRun += 1;
     if (entry.verdict !== undefined) {
         row.judged += 1;
-        if (entry.verdict === "pass")
+        if (runDisplay(entry).state === "passed")
             row.passed += 1;
     }
     if (entry.mode === "live" && entry.durationMs !== undefined)
@@ -157,6 +158,7 @@ export async function computeStats(cwdInput, options = {}) {
         unpricedRuns: 0,
         participants: emptyParticipants(),
         verdicts: {},
+        outcomes: {},
         costs: emptyCostTotals(),
     };
     const studies = new Map();
@@ -181,6 +183,8 @@ export async function computeStats(cwdInput, options = {}) {
         addParticipants(totals.participants, entry);
         if (entry.verdict !== undefined)
             totals.verdicts[entry.verdict] = (totals.verdicts[entry.verdict] ?? 0) + 1;
+        const { state } = runDisplay(entry);
+        totals.outcomes[state] = (totals.outcomes[state] ?? 0) + 1;
         addToStudyRow(studies, entry, runUsd, accounting.costs);
         addToDayRow(days, entry, runUsd, accounting.costs);
     }
@@ -239,7 +243,7 @@ function runCountLines(t) {
     const running = t.running > 0 ? ` (${t.running} still running)` : "";
     return [`live runs: ${t.live}${running}`, ...(t.dryRun > 0 ? [`dry runs: ${t.dryRun}`] : [])];
 }
-/** Spend, analysis, participants and verdicts across the selected live runs. */
+/** Spend, analysis, participants and outcomes across the selected live runs. */
 function totalsLines(t) {
     const c = t.costs;
     const incomplete = c.incompleteRunEstimates > 0
@@ -248,7 +252,7 @@ function totalsLines(t) {
     const unpriced = c.analysisUnpricedAttempts > 0 || c.analysisUnresolvedAttempts > 0
         ? `; ${c.analysisUnpricedAttempts} unpriced, ${c.analysisUnresolvedAttempts} unresolved`
         : "";
-    const verdicts = Object.entries(t.verdicts).map(([verdict, count]) => `${verdict} ${count}`);
+    const outcomes = Object.entries(t.outcomes).map(([state, count]) => `${runDisplayLabel(state)} ${count}`);
     return [
         `known estimated spend: ${knownMoney(c.estimatedTotalUsd)}`,
         `participants and desktops: ${knownMoney(c.runEstimatedUsd)}${incomplete}`,
@@ -265,7 +269,7 @@ function totalsLines(t) {
                 `participants: ${t.participants.reachedGoal} of ${t.participants.total} reached the goal, ${t.participants.reportedFriction} reported friction`,
             ]
             : []),
-        ...(verdicts.length > 0 ? [`verdicts: ${verdicts.join(", ")}`] : []),
+        ...(outcomes.length > 0 ? [`outcomes: ${outcomes.join(", ")}`] : []),
     ];
 }
 function dayLine(row) {

package/dist/run/status.d.ts

@@ -20,9 +20,9 @@ export type RunInterruptSignal = "SIGINT" | "SIGTERM" | "SIGHUP";
 interface RunStatusOutcome {
     /** `review.verdict` verbatim. */
     verdict?: string;
-    /** True when the run's own envelope reported success: the result's ok, recorded after finish. */
+    /** run.json's `outcome.ok`: the route result's ok. */
     ok?: boolean;
-    /** Whether the run worked as an execution, apart from its verdict; recorded after finish. */
+    /** run.json's `outcome.execution`: whether the run worked as an execution, apart from its verdict. */
     execution?: ExecutionOutcome;
     /** `review.participants` counts, when the run recorded any. */
     participants?: {
@@ -72,14 +72,11 @@ export interface RunStatusHandle {
     /** Finalize: state `finished`, `completedAt`, and the derived outcome. Stops the cadence.
      *  Idempotent: a second call is a no-op, so a route with several exit paths is safe. */
     finish(outcome?: RunStatusOutcome): Promise<void>;
-    /** After finish, add the result's ok and execution outcome to the finished record, so status.json
-     *  and the result agree. Before finish it does nothing. */
-    settle(result: {
-        ok: boolean;
-        execution: ExecutionOutcome;
-    }): Promise<void>;
+    /** After finish, replace the finished record's outcome with one read from a rewritten run.json,
+     *  so the two agree. Before finish, and after an interrupt, it does nothing. */
+    restate(outcome: RunStatusOutcome): Promise<void>;
     /** The process is being stopped by `signal`: state `interrupted`, `completedAt` and the signal.
-     *  It stops the cadence and makes a later finish or settle a no-op, so the route cannot write
+     *  It stops the cadence and makes a later finish or restate a no-op, so the route cannot write
      *  `running` or `finished` over it. When the run had finished it writes nothing, waits for the
      *  writes already queued and resolves false. */
     interrupt(signal: RunInterruptSignal): Promise<boolean>;

package/dist/run/status.js

@@ -4,14 +4,14 @@
 //
 // run.json remains the evidence of record. This file is a derived index and liveness record:
 // `verify` never gates on it, nothing here is a claim about what a participant did, and when the
-// two disagree run.json wins and this file can be rebuilt from it.
+// two disagree run.json wins. A finished record copies run.json's outcome, so it can be rebuilt
+// from it; a record written before run.json carried an outcome holds the only copy of the run's ok.
 //
 // Public safety: it holds only the run id, the study id/path/origin (the strings `humanish study list`
 // prints), the mode, a local pid and timestamps. It holds no hostname or user/path identity: an
 // operator may share the run directory, so a share-safety gate must have nothing to strip here.
 import { isProvenanceField, studyFields } from "./study-provenance.js";
 import { writeContainedOutputFile } from "./contained-output.js";
-import { redactText } from "../evidence/redaction.js";
 export const RUN_STATUS_SCHEMA = "humanish.run-status.v1";
 /** The file, relative to the run directory. */
 export const RUN_STATUS_FILE = "status.json";
@@ -45,6 +45,9 @@ export function runStatusOutcome(bundle) {
         ...(typeof bundle.cost?.fullyEstimated === "boolean"
             ? { estimatedCostComplete: bundle.cost.fullyEstimated }
             : {}),
+        ...(bundle.outcome?.state === "finished"
+            ? { ok: bundle.outcome.ok, execution: bundle.outcome.execution }
+            : {}),
     };
 }
 /**
@@ -102,26 +105,10 @@ export function beginRunStatus(runPaths, options) {
             };
             await write(finishedRecord);
         },
-        async settle(result) {
+        async restate(outcome) {
             if (finishedRecord === undefined)
                 return;
-            // The record is public-safe by construction, so each message passes the shape redaction
-            // again even though the routes scrubbed it.
-            const redacted = (failure) => ({
-                kind: failure.kind,
-                message: redactText(failure.message),
-            });
-            const execution = {
-                succeeded: result.execution.succeeded,
-                failures: result.execution.failures.map(redacted),
-                ...(result.execution.warnings === undefined
-                    ? {}
-                    : { warnings: result.execution.warnings.map(redacted) }),
-            };
-            finishedRecord = {
-                ...finishedRecord,
-                outcome: { ...finishedRecord.outcome, ok: result.ok, execution },
-            };
+            finishedRecord = { ...finishedRecord, outcome };
             await write(finishedRecord);
         },
         async interrupt(signal) {

package/dist/run/stored-runs.d.ts

@@ -1,18 +1,7 @@
-import type { E2BDesktopModule } from "../substrates/e2b/sdk.js";
-import { type ReviewSummary, type RunBundle } from "./bundle.js";
-import { type CleanupAdapterResult, type CleanupResult } from "./results.js";
+import { type ReviewSummary } from "./bundle.js";
+import { type RunDisplay } from "./display.js";
 import { type VerifyResult } from "../verify/verify.js";
 declare const RUNS_SCHEMA = "humanish.runs-result.v1";
-export interface RunCleanupHooks {
-    /** @deprecated Ignored. Stored provider ids are not authority to load or mutate a provider. */
-    loadDesktopModule?: () => Promise<E2BDesktopModule>;
-    cleanupAdapterResources?: (ctx: {
-        cwd: string;
-        runDir: string;
-        bundle: RunBundle;
-    }) => Promise<CleanupAdapterResult[]>;
-    now?: () => Date;
-}
 export interface RunsResult {
     schema: typeof RUNS_SCHEMA;
     ok: boolean;
@@ -22,6 +11,8 @@ export interface RunsResult {
         createdAt: string | null;
         mode: string | null;
         path: string;
+        /** How the run reads (runDisplay in src/run/display.ts); absent when it has no readable run.json. */
+        display?: RunDisplay;
     }>;
     latest: string | null;
     error?: {
@@ -29,10 +20,10 @@ export interface RunsResult {
         message: string;
     };
 }
-export declare function cleanupRun(cwdInput: string, runInput: string, hooks?: RunCleanupHooks): Promise<CleanupResult>;
 export declare function listRuns(cwdInput: string): Promise<RunsResult>;
 export declare function readReview(cwdInput: string, runInput: string): Promise<VerifyResult | (ReviewSummary & {
     path: string;
     runId: string;
+    display?: RunDisplay;
 })>;
 export {};