humanish 0.110.2 → 0.110.4

package/dist/routes/terminal/types.d.ts

@@ -6,7 +6,6 @@ import type { RunScope } from "../../run/run.js";
 import type { buildRuntimeAuth } from "./credentials.js";
 import type { TerminalPlan } from "../../study/plan-types.js";
 import type { StudyDeps } from "../../study/study-deps.js";
-import type { StudyConfig } from "../../study/types.js";
 import type { ObserverResult } from "../../observer/render.js";
 import { type RunAdapterScore, type RunBundle, type RunFeedbackCandidate, type RunScorerProvenance } from "../../run/bundle.js";
 import { type StudyResultIdentity } from "../../run/study-result.js";
@@ -97,15 +96,13 @@ export interface TerminalScorer {
      */
     deriveFeedback?: (ctx: TerminalProductScoringContext) => RunFeedbackCandidate[] | Promise<RunFeedbackCandidate[]>;
 }
-export interface RunTerminalProductStudyOptions {
+/** What a terminal run takes besides its plan. The plan carries the config, dry run and study. */
+export interface TerminalRunInput {
     /** Cancels post-run analysis only. */
     analysisSignal?: AbortSignal;
     /** Reports the analysis window to onEvent; built by normalizeRunStudyOptions. */
     emit?: (event: StudyEvent) => void;
     cwd: string;
-    config: StudyConfig;
-    /** Resolved upstream (scenario.mode + CLI override); defaults safe (dry-run). */
-    dryRun: boolean;
     open?: boolean;
     runId?: string;
     /**
@@ -312,8 +309,6 @@ export interface TerminalLedgers {
     /** The no-spend proof derived from `cost`. Never an independent assertion. */
     noSpendProof: NoSpendProof;
 }
-/** What a terminal run takes besides its plan. The plan carries the config, dry run and study. */
-export type TerminalRunInput = Omit<RunTerminalProductStudyOptions, "config" | "dryRun">;
 /** A live terminal plan: its caps are the fail-closed ones planTerminalStudy required. */
 export type LiveTerminalPlan = Extract<TerminalPlan, {
     readonly dryRun: false;

package/dist/run/display.d.ts

@@ -57,3 +57,13 @@ export declare function bundleDisplayFacts(bundle: DisplayedBundle, status?: unk
  * execution failed never reads as a pass beside its participants' verdict.
  */
 export declare function reviewOutcome(bundle: DisplayedBundle): string;
+/**
+ * The summary and gaps a review shows beside its run's display. A run stopped while a participant
+ * was still running keeps the review its last live flush wrote, which describes that session as
+ * running. Once runDisplay reads the run as interrupted, the review says how many participants the
+ * stop cut off instead.
+ */
+export declare function displayedReview<T extends {
+    summary: string;
+    gaps: string[];
+}>(review: T, bundle: DisplayedBundle, display: RunDisplay): T;

package/dist/run/display.js

@@ -3,6 +3,7 @@
 // same facts, so a run whose own ok is false shows as a pass on none of them, and two surfaces
 // cannot disagree about one run.
 import { classifyRunStatus, isRunStatusRecord } from "./status.js";
+import { plural } from "./text.js";
 const LABELS = {
     running: "running",
     interrupted: "interrupted",
@@ -104,3 +105,24 @@ export function bundleDisplayFacts(bundle, status, nowMs = Date.now()) {
 export function reviewOutcome(bundle) {
     return runDisplayLine(runDisplay(bundleDisplayFacts(bundle)));
 }
+/**
+ * The summary and gaps a review shows beside its run's display. A run stopped while a participant
+ * was still running keeps the review its last live flush wrote, which describes that session as
+ * running. Once runDisplay reads the run as interrupted, the review says how many participants the
+ * stop cut off instead.
+ */
+export function displayedReview(review, bundle, display) {
+    const records = bundle.simulations ?? [];
+    const running = records.filter((record) => record?.status === "running").length;
+    if (display.state !== "interrupted" || running === 0)
+        return review;
+    const signal = bundle.outcome?.state === "interrupted" ? ` by ${bundle.outcome.signal}` : "";
+    const one = running === 1;
+    return {
+        ...review,
+        summary: `Interrupted${signal} while ${running} of ${plural(records.length, "participant")} ${one ? "was" : "were"} still running.`,
+        gaps: [
+            `${plural(running, "participant")} ${one ? "has" : "have"} no verdict: the run stopped before ${one ? "its session" : "their sessions"} ended.`,
+        ],
+    };
+}

package/dist/run/reclaim.d.ts

@@ -20,9 +20,10 @@ export interface ReclaimResult {
     createsInFlight: number;
     /**
      * Why there was nothing to look for: `dry-run` when run.json or status.json records the run as
-     * a dry run, which creates no sandboxes. Reclaim then contacts E2B for nothing.
+     * a dry run, which creates no sandboxes, and `no-sandbox` when status.json records that the
+     * route created none for this run. Reclaim then contacts E2B for nothing.
      */
-    reason?: "dry-run";
+    reason?: NoSandboxReason;
     warnings: string[];
     error?: {
         code: "HUMANISH_RECLAIM_RUN_NOT_FOUND" | "HUMANISH_RECLAIM_E2B_DEBUG" | "HUMANISH_RECLAIM_MODULE_UNAVAILABLE" | "HUMANISH_RECLAIM_RECEIPTS_UNREADABLE";
@@ -47,6 +48,7 @@ export declare function reclaimRunSandboxes(cwd: string, runInput: string, hooks
  * also an alias (a run named `latest`) cannot reach another run's receipts.
  */
 export declare function reclaimPinnedRunSandboxes(cwd: string, runPaths: PreparedRunArtifactPaths, hooks?: ReclaimHooks): Promise<ReclaimResult>;
+type NoSandboxReason = "dry-run" | "no-sandbox";
 /**
  * Kill the sandboxes left by interrupted `humanish study check` probes. A probe journals under
  * .humanish/preflight/<probe-id>/ and removes the journal after a confirmed kill, so what is left

package/dist/run/reclaim.js

@@ -15,6 +15,7 @@ import { readRunJsonIfExists, resolveRunPath } from "./locate.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
 import { RUN_STATUS_FILE } from "./status.js";
 import { isRecord } from "./type-guards.js";
+import { isRunOutcome } from "./bundle-shape.js";
 import { parseSandboxOwners, parseSandboxReceipts, SANDBOX_RECEIPTS_ARTIFACT, } from "./sandbox-receipts.js";
 import { sandboxOwnerTags, } from "./sandbox-creates.js";
 import { earlierOutcomes, GONE, RECLAIM_RECEIPT_ARTIFACT, RECLAIM_RESULT_SCHEMA, receiptWriter, rootState, searchTagSets, settledWithin, targetSet, } from "./reclaim-outcomes.js";
@@ -64,8 +65,9 @@ async function reclaimRun(cwd, runInput, locate, hooks) {
     }
     const runId = runIdOf(runPaths);
     // The signal handler passes the creates it stopped and decides from what they reported.
-    if (hooks.creates === undefined && (await recordedDryRun(runPaths)))
-        return { ...base, ok: true, state: "clean", runId, reason: "dry-run" };
+    const reason = hooks.creates === undefined ? await recordedNoSandbox(runPaths) : undefined;
+    if (reason !== undefined)
+        return { ...base, ok: true, state: "clean", runId, reason };
     const reclaimed = await reclaimRoot(runPaths, runId, hooks, warnings);
     if (reclaimed.kind === "module-unavailable")
         return {
@@ -93,29 +95,70 @@ async function reclaimRun(cwd, runInput, locate, hooks) {
     };
 }
 /**
- * Whether the run records that it was a dry run: run.json and status.json, each one present, say
- * `dry-run`. A run with neither record is not taken for one. A journal with any line in it, or an
- * earlier reclaim receipt that names a sandbox, means a create ran, so that run is reclaimed as a
- * live one whatever its records say.
+ * Why the run's own records say it created no sandbox. `dry-run`: run.json and status.json, each
+ * one present, say `dry-run`. `no-sandbox`: status.json, written at start, names this run and
+ * records `sandboxes: none`, which the route sets only when it has no way to create one (a
+ * scripted run against an app-url subject), and run.json agrees (scriptedAppUrlBundle). A status
+ * record alone can be stale or copied from another run, so it never decides on its own, and an
+ * empty journal alone never makes a run clean. A journal with any line in it, or an earlier
+ * reclaim receipt that names a sandbox, means a create ran, so that run is reclaimed as a live one
+ * whatever its records say.
  */
-async function recordedDryRun(runPaths) {
-    const modes = [];
-    for (const file of [RUN_BUNDLE_FILE, RUN_STATUS_FILE]) {
-        const record = await readRunJsonIfExists(runPaths, file);
-        if (isRecord(record))
-            modes.push(record.mode);
-    }
-    if (modes.length === 0 || modes.some((mode) => mode !== "dry-run"))
-        return false;
+async function recordedNoSandbox(runPaths) {
+    const bundle = await readRunJsonIfExists(runPaths, RUN_BUNDLE_FILE);
+    const status = await readRunJsonIfExists(runPaths, RUN_STATUS_FILE);
+    const records = [bundle, status].filter(isRecord);
+    const reason = records.length > 0 && records.every((record) => record.mode === "dry-run")
+        ? "dry-run"
+        : isRecord(status) &&
+            status.runId === runIdOf(runPaths) &&
+            status.sandboxes === "none" &&
+            scriptedAppUrlBundle(bundle, runIdOf(runPaths))
+            ? "no-sandbox"
+            : undefined;
+    if (reason === undefined)
+        return undefined;
     if (!(await containedPathAbsent(runPaths, RECLAIM_RECEIPT_ARTIFACT))) {
         const earlier = await readRunJsonIfExists(runPaths, RECLAIM_RECEIPT_ARTIFACT);
         if (!isRecord(earlier) || !Array.isArray(earlier.outcomes) || earlier.outcomes.length > 0)
-            return false;
+            return undefined;
     }
     if (await containedPathAbsent(runPaths, SANDBOX_RECEIPTS_ARTIFACT))
-        return true;
+        return reason;
     const journal = await readContainedRegularFile(runPaths, SANDBOX_RECEIPTS_ARTIFACT);
-    return journal !== null && journal.toString("utf8").trim() === "";
+    return journal !== null && journal.toString("utf8").trim() === "" ? reason : undefined;
+}
+/** The execution failure kinds that leave a sandbox or a provider's resources unconfirmed. */
+const CLEANUP_KINDS = new Set(["sandbox-cleanup", "provider-cleanup"]);
+/**
+ * run.json for `runId` agrees that its run could create no sandbox: the scripted route wrote it
+ * (each lifecycle event is a `scripted-lab.` one), its subject is not a provisioned clone (a clone
+ * records `subject`), it lists no provider resource and no desktop minutes, and its outcome marks
+ * no sandbox or provider cleanup unconfirmed. A run.json that is missing, unreadable or says
+ * otherwise does not agree.
+ */
+function scriptedAppUrlBundle(bundle, runId) {
+    if (!isRecord(bundle) || bundle.runId !== runId || bundle.subject !== undefined)
+        return false;
+    const { lifecycle, providerResources, cost, outcome } = bundle;
+    const scripted = Array.isArray(lifecycle) &&
+        lifecycle.length > 0 &&
+        lifecycle.every((entry) => isRecord(entry) &&
+            typeof entry.event === "string" &&
+            entry.event.startsWith("scripted-lab."));
+    if (!scripted)
+        return false;
+    if (providerResources !== undefined &&
+        !(Array.isArray(providerResources) && providerResources.length === 0))
+        return false;
+    if (cost !== undefined && !(isRecord(cost) && cost.desktopMinutes === null))
+        return false;
+    if (!isRunOutcome(outcome))
+        return false;
+    if (outcome.state !== "finished")
+        return true;
+    const { failures, warnings = [] } = outcome.execution;
+    return ![...failures, ...warnings].some((failure) => CLEANUP_KINDS.has(failure.kind));
 }
 /**
  * Kill the sandboxes left by interrupted `humanish study check` probes. A probe journals under

package/dist/run/route-shell.d.ts

@@ -0,0 +1,60 @@
+import { type AnalysisInput } from "../analysis/automatic-completion.js";
+import type { AutomaticAnalysisDeps } from "../analysis/automatic.js";
+import type { AdmittedPlan, StudyResult } from "../run-study.js";
+import type { PlannedAnalysis } from "../study/plan-types.js";
+import type { LateScorer } from "../study/route-inputs.js";
+import type { StudyRoute } from "../study/routing.js";
+import type { StudyConfig } from "../study/types.js";
+import { type RunScope } from "./run.js";
+type ShellRoute = Exclude<StudyRoute, "preview">;
+/** A route's local checks: the refused result, or what its run continues from. */
+export type RouteAdmission<R extends ShellRoute, A> = {
+    readonly ok: false;
+    readonly result: StudyResult<R>;
+} | {
+    readonly ok: true;
+    readonly admitted: A;
+};
+/** A route's own parts of its run. Everything around them is admitRoute's. */
+export interface RouteShell<R extends ShellRoute, I extends AnalysisInput, A> {
+    readonly route: R;
+    /** The plan's automatic analysis, which both the refused result and the run complete. */
+    readonly analysis: PlannedAnalysis | undefined;
+    /** The route's input as the checks admitted it. */
+    readonly input: I;
+    /** The checks that need no scorer, made before any run scope opens. */
+    admit(): Promise<RouteAdmission<R, A>> | RouteAdmission<R, A>;
+    /** The run inside its run scope, with the input a late scorer joined. */
+    runInScope(admitted: A, input: I, scope: RunScope): Promise<StudyResult<R>>;
+    /** Layers a scorer the CLI loaded after the checks over the input. Scripted takes no scorer. */
+    readonly withScorer?: (input: I, scorer: LateScorer | undefined) => I;
+    /** Computer use's reason to skip analysis: a local VM study whose cleanup is unconfirmed. */
+    readonly analysisRefusal?: AutomaticAnalysisDeps["refusal"];
+    /**
+     * Computer use and shared world receive email. The run and its analysis share one scope for the
+     * secrets it registers. The other routes run outside any scope, where scrubbing changes nothing.
+     */
+    readonly commsSecrets?: boolean;
+}
+/**
+ * Runs a route's checks and returns the refusal they made or the route's run. A refusal carries the
+ * analysis record of a run that never started. The run opens its own run scope, so whichever exit
+ * it takes closes the run it started, and only a run that published its final bundle is analyzed.
+ */
+export declare function admitRoute<R extends ShellRoute, I extends AnalysisInput, A>(shell: RouteShell<R, I, A>): Promise<AdmittedPlan<R>>;
+/**
+ * A refused study's result with the analysis record a refusal gets: it starts no run, so a declared
+ * or default analysis is recorded as skipped.
+ */
+export declare function completeRefusalAnalysis<T extends {
+    cwd: string;
+    runId: string;
+    dryRun: boolean;
+}>(refused: T, config: StudyConfig, input: AnalysisInput): Promise<T>;
+/** What a refused study's envelope reads besides the route's input. */
+export interface RefusedStudy {
+    readonly config: StudyConfig;
+    /** The run's resolved dry run. */
+    readonly dryRun: boolean;
+}
+export {};

package/dist/run/route-shell.js

@@ -0,0 +1,51 @@
+// The shell the computer-use, scripted, terminal and shared-world routes share. A route supplies
+// its local checks and the body it runs inside the run scope. admitRoute completes the automatic
+// analysis of a refusal and of a run, and wraps the result as the route's outcome, so a change to
+// either is made here once. The preview route records no run and has no shell.
+import { completeAutomaticAnalysis } from "../analysis/automatic-completion.js";
+import { resolveAutomaticAnalysis } from "../analysis/automatic-config.js";
+import { runScope } from "./run.js";
+import { withTransientCommsSecrets } from "./transient-comms-secrets.js";
+/**
+ * Runs a route's checks and returns the refusal they made or the route's run. A refusal carries the
+ * analysis record of a run that never started. The run opens its own run scope, so whichever exit
+ * it takes closes the run it started, and only a run that published its final bundle is analyzed.
+ */
+export async function admitRoute(shell) {
+    const complete = (input, result, finished) => completeAutomaticAnalysis(result, finished, shell.analysis?.config, input, {
+        ...(shell.analysis === undefined ? {} : { trigger: shell.analysis.trigger }),
+        preferLargerOutput: shell.analysis?.preferLargerOutput === true,
+        ...(shell.analysisRefusal === undefined ? {} : { refusal: shell.analysisRefusal }),
+    });
+    const admission = await shell.admit();
+    if (!admission.ok)
+        return {
+            ok: false,
+            outcome: routeOutcome(shell.route, await complete(shell.input, admission.result, undefined)),
+        };
+    const { admitted } = admission;
+    return {
+        ok: true,
+        run: async (scorer) => {
+            // The scorer joins the input only; whatever the checks admitted stays what the run uses.
+            const input = shell.withScorer?.(shell.input, scorer) ?? shell.input;
+            const run = async () => {
+                const { result, finished } = await runScope((scope) => shell.runInScope(admitted, input, scope));
+                return complete(input, result, finished);
+            };
+            return routeOutcome(shell.route, await (shell.commsSecrets ? withTransientCommsSecrets(run) : run()));
+        },
+    };
+}
+/**
+ * A refused study's result with the analysis record a refusal gets: it starts no run, so a declared
+ * or default analysis is recorded as skipped.
+ */
+export function completeRefusalAnalysis(refused, config, input) {
+    const analysis = resolveAutomaticAnalysis(config.review?.analysis);
+    return completeAutomaticAnalysis(refused, undefined, analysis.ok ? analysis.config : undefined, input, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+}
+/** A result as its route's outcome. StudyOutcome pairs each route with its result type. */
+function routeOutcome(route, result) {
+    return { route, result };
+}

package/dist/run/run.d.ts

@@ -11,6 +11,8 @@ interface StartRunOptions {
     mintRunId: () => string;
     mode: "dry-run" | "live";
     study?: RunStudyProvenance | undefined;
+    /** `none` when the route creates no sandbox for this run; status.json records it for reclaim. */
+    sandboxes?: "none" | undefined;
     /** review.md for the published bundle. */
     renderReview: (bundle: RunBundle) => string;
     /** Used by `FinishedRun.renderObserver`; `render` is the `StudyDeps.renderObserver` seam. */
@@ -52,6 +54,12 @@ interface Run {
      * can never overwrite the final bundle. Routes that throttle snapshots own their timers.
      */
     writeSnapshot(bundle: RunBundle): Promise<void>;
+    /**
+     * A participant's session started: its actor began to act on the subject. FinishedRun's
+     * participantsRan reads this, so a session that throws before it returns a trace still counts,
+     * and a run that failed before any session (a refused E2B key) does not.
+     */
+    participantStarted(): void;
     /**
      * The one final publication: run.json with `outcome` set from `outcome`, then the status
      * outcome copied from it, then review.json, review.md, events.ndjson,
@@ -92,7 +100,14 @@ export declare class FinishedRun {
     readonly runId: string;
     /** The paths created by startRun and validated at the start of `finish`. */
     readonly paths: PreparedRunArtifactPaths;
-    constructor(key: typeof issueKey, runId: string, paths: PreparedRunArtifactPaths, observer: ObserverTarget | undefined, outcome: RecordedOutcome, recordFailure: (failure: ExecutionFailure) => Promise<RecordedOutcome>);
+    constructor(key: typeof issueKey, runId: string, paths: PreparedRunArtifactPaths, observer: ObserverTarget | undefined, outcome: RecordedOutcome, recordFailure: (failure: ExecutionFailure) => Promise<RecordedOutcome>, interrupted: () => boolean, participantsRan: () => boolean);
+    /**
+     * A signal stopped this run's process: status.json and run.json record it `interrupted`. Read
+     * when asked, since the signal can arrive after the bundle was published.
+     */
+    get interrupted(): boolean;
+    /** The route reported a participant's session started (Run.participantStarted). */
+    get participantsRan(): boolean;
     static isIssued(value: unknown): value is FinishedRun;
     /**
      * The run's ok and execution outcome as run.json records them: what the route passed to

package/dist/run/run.js

@@ -27,18 +27,33 @@ const issueKey = Symbol("FinishedRun");
 export class FinishedRun {
     #observer;
     #recordFailure;
+    #interrupted;
     #outcome;
     runId;
     /** The paths created by startRun and validated at the start of `finish`. */
     paths;
-    constructor(key, runId, paths, observer, outcome, recordFailure) {
+    #participantsRan;
+    constructor(key, runId, paths, observer, outcome, recordFailure, interrupted, participantsRan) {
         if (key !== issueKey)
             throw new Error("Only Run.finish issues a FinishedRun.");
         this.runId = runId;
         this.paths = paths;
+        this.#participantsRan = participantsRan;
         this.#observer = observer;
         this.#outcome = outcome;
         this.#recordFailure = recordFailure;
+        this.#interrupted = interrupted;
+    }
+    /**
+     * A signal stopped this run's process: status.json and run.json record it `interrupted`. Read
+     * when asked, since the signal can arrive after the bundle was published.
+     */
+    get interrupted() {
+        return this.#interrupted();
+    }
+    /** The route reported a participant's session started (Run.participantStarted). */
+    get participantsRan() {
+        return this.#participantsRan();
     }
     static isIssued(value) {
         return typeof value === "object" && value !== null && #observer in value;
@@ -97,7 +112,7 @@ function observerTarget(options) {
         };
 }
 function runPublisher(args) {
-    const { options, runId, paths, runStatus, now, admit } = args;
+    const { options, runId, paths, runStatus, now, admit, participantsRan } = args;
     const observer = observerTarget(options);
     let pointerWritten = false;
     // The bundle of the last write asked for, and the outcome every later write carries once a
@@ -167,7 +182,7 @@ function runPublisher(args) {
             await writeBundleFiles(bundle, finishedOutcome(current), (publicBundle) => runStatus.restate(runStatusOutcome(publicBundle))).catch(() => undefined);
             return current;
         }));
-        return new FinishedRun(issueKey, runId, paths, observer, current, recordFailure);
+        return new FinishedRun(issueKey, runId, paths, observer, current, recordFailure, () => runStatus.interrupted, participantsRan);
     };
     const interrupt = async (signal) => {
         interrupted = { state: "interrupted", ok: false, signal, at: new Date(now()).toISOString() };
@@ -222,7 +237,8 @@ export async function runScope(fn) {
             const created = await createRunArtifactPaths(options.cwd, runId);
             if (!created.ok)
                 return created;
-            // beginRunStatus reads only the mode and the study provenance from the run's options.
+            // beginRunStatus reads only the mode, the study provenance and the sandboxes field from
+            // the run's options.
             const runStatus = beginRunStatus(created.paths, { ...options, runId });
             status = runStatus;
             let interruptBundle;
@@ -251,7 +267,16 @@ export async function runScope(fn) {
     const openRun = (options, runId, paths, runStatus) => {
         const now = options.now ?? Date.now;
         const createdAt = new Date(now()).toISOString();
-        const publisher = runPublisher({ options, runId, paths, runStatus, now, admit });
+        let participantsRan = false;
+        const publisher = runPublisher({
+            options,
+            runId,
+            paths,
+            runStatus,
+            now,
+            admit,
+            participantsRan: () => participantsRan,
+        });
         let finishCalled = false;
         const checkIdentity = (bundle) => bundle.runId !== runId || bundle.mode !== options.mode
             ? "The bundle names another run or mode than this run."
@@ -262,6 +287,9 @@ export async function runScope(fn) {
             mode: options.mode,
             ...(options.study === undefined ? {} : { study: options.study }),
             paths,
+            participantStarted() {
+                participantsRan = true;
+            },
             writeSnapshot(bundle) {
                 if (closed)
                     return refuse("The run scope has closed.");

package/dist/run/status.d.ts

@@ -53,6 +53,11 @@ export interface RunStatusRecord {
      * Read either through studyProvenanceOf.
      */
     lab?: RunStudyProvenance;
+    /**
+     * `none` when the route recorded at start that this run creates no sandbox, as a scripted run
+     * against an app-url subject does. Absent when the run may create one. Reclaim reads it.
+     */
+    sandboxes?: "none";
     /** The pid that owns the run, for local liveness checks. */
     pid: number;
     startedAt: string;
@@ -80,11 +85,14 @@ export interface RunStatusHandle {
      *  `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>;
+    /** True from the moment `interrupt` accepts a signal, before its write lands. */
+    readonly interrupted: boolean;
 }
 export interface BeginRunStatusOptions {
     runId: string;
     mode: "dry-run" | "live";
     study?: RunStudyProvenance | undefined;
+    sandboxes?: "none" | undefined;
 }
 /**
  * Start a run's status record and keep it fresh. Fire-and-forget by design: a status write that

package/dist/run/status.js

@@ -64,11 +64,13 @@ export function beginRunStatus(runPaths, options) {
         state: "running",
         mode: options.mode,
         ...studyFields(options.study),
+        ...(options.sandboxes === undefined ? {} : { sandboxes: options.sandboxes }),
         pid: process.pid,
         startedAt,
         updatedAt: startedAt,
     };
     let finished = false;
+    let interrupted = false;
     let finishedRecord;
     let writing = Promise.resolve();
     const write = (record) => {
@@ -119,11 +121,15 @@ export function beginRunStatus(runPaths, options) {
                 return false;
             }
             finished = true;
+            interrupted = true;
             clearInterval(timer);
             const completedAt = iso();
             await write({ ...base, state: "interrupted", updatedAt: completedAt, completedAt, signal });
             return true;
         },
+        get interrupted() {
+            return interrupted;
+        },
     };
     return handle;
 }

package/dist/run/stored-runs.js

@@ -5,7 +5,7 @@ import { bindExistingRunArtifactPaths, RUNS_RELATIVE_ROOT, isSafeRunIdSegment, r
 import { assertPreparedSelectedOutputDirectory, bindExistingManagedHumanishOutputDirectory, } from "./contained-output.js";
 import { RUN_BUNDLE_FILE } from "./bundle.js";
 import { isReviewSummary, isRunOutcome } from "./bundle-shape.js";
-import { bundleDisplayFacts, runDisplay } from "./display.js";
+import { bundleDisplayFacts, displayedReview, runDisplay, } from "./display.js";
 import { RUN_STATUS_FILE } from "./status.js";
 import { readLatest, readRunJsonIfExists, resolveRunPath } from "./locate.js";
 import { withCuaReviewProvenance } from "./outcomes.js";
@@ -101,22 +101,33 @@ export async function listRuns(cwdInput) {
  * that is not an object naming a run gets none.
  */
 async function listedRunDisplay(runPaths, bundle) {
-    if (!isRecord(bundle) || typeof bundle.runId !== "string")
+    const displayed = displayedBundle(bundle);
+    if (displayed === undefined)
         return {};
-    const outcome = isRunOutcome(bundle.outcome) ? bundle.outcome : undefined;
-    const status = outcome === undefined ? await readRunJsonIfExists(runPaths, RUN_STATUS_FILE) : undefined;
-    const facts = bundleDisplayFacts({
+    const status = displayed.outcome === undefined
+        ? await readRunJsonIfExists(runPaths, RUN_STATUS_FILE)
+        : undefined;
+    return { display: runDisplay(bundleDisplayFacts(displayed, status)) };
+}
+/** The fields runDisplay reads from an unchecked run.json; none when it does not name a run. */
+function displayedBundle(bundle) {
+    if (!isRecord(bundle) || typeof bundle.runId !== "string")
+        return undefined;
+    return {
         runId: bundle.runId,
         ...(typeof bundle.mode === "string" ? { mode: bundle.mode } : {}),
         ...(isRecord(bundle.review) && typeof bundle.review.verdict === "string"
             ? { review: { verdict: bundle.review.verdict } }
             : {}),
         ...(Array.isArray(bundle.simulations)
-            ? { simulations: bundle.simulations.filter(isRecord) }
+            ? {
+                simulations: bundle.simulations
+                    .filter(isRecord)
+                    .map((record) => (typeof record.status === "string" ? { status: record.status } : {})),
+            }
             : {}),
-        ...(outcome === undefined ? {} : { outcome }),
-    }, status);
-    return { display: runDisplay(facts) };
+        ...(isRunOutcome(bundle.outcome) ? { outcome: bundle.outcome } : {}),
+    };
 }
 function runsUnavailableResult(cwd, error) {
     return {
@@ -159,10 +170,14 @@ export async function readReview(cwdInput, runInput) {
     const projected = isRecord(bundle) && Array.isArray(bundle.streams)
         ? withCuaReviewProvenance(review, bundle.streams.filter(isRecord))
         : review;
+    const displayed = displayedBundle(bundle);
+    const { display } = runPaths ? await listedRunDisplay(runPaths, bundle) : {};
     return {
-        ...projected,
+        ...(displayed === undefined || display === undefined
+            ? projected
+            : displayedReview(projected, displayed, display)),
         path: path.relative(cwd, path.join(runPaths.absoluteRunRoot, "review.json")),
         runId: path.basename(runPaths.absoluteRunRoot),
-        ...(runPaths ? await listedRunDisplay(runPaths, bundle) : {}),
+        ...(display === undefined ? {} : { display }),
     };
 }