humanish 0.109.1 → 0.110.1

package/dist/routes/shared-world/types.d.ts

@@ -95,6 +95,7 @@ export interface ConcurrentSharedWorldParticipantResult {
     /** The actor sandbox lifecycle proof (the getHost/key value is never surfaced here). */
     sandbox?: {
         sandboxId: string;
+        sandboxIdDigest?: string;
         killed: boolean;
     };
     error?: {
@@ -119,6 +120,7 @@ export interface ConcurrentSharedWorldStudyResult extends AutomaticAnalysisResul
     /** The one subject sandbox lifecycle proof. */
     subjectSandbox?: {
         sandboxId: string;
+        sandboxIdDigest?: string;
         killed: boolean;
     };
     /** Whether ≥2 actor windows overlapped in time (proven concurrency; live only). */

package/dist/routes/terminal/bundle.js

@@ -2,6 +2,7 @@ import { redactText } from "../../evidence/redaction.js";
 import { participantAssignment } from "../../study/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import { verdictText } from "../../run/judge.js";
+import { reviewOutcome } from "../../run/display.js";
 import {} from "../../run/streams.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGERS_ARTIFACT, TERMINAL_TRANSCRIPT_ARTIFACT, } from "../../run/terminal-contract.js";
@@ -72,7 +73,7 @@ export function buildTerminalProductBundle(args) {
             at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.contract.ready",
-            message: "Dry-run bundle ready. Switch scenario.mode to live with the required runtime auth and caps to exercise the in-sandbox agent route, captured exec stream, and declared runtime-auth placement.",
+            message: "Dry-run bundle ready. Switch mode to live with the required runtime auth and caps to exercise the in-sandbox agent route, captured exec stream, and declared runtime-auth placement.",
         }),
     ];
     const review = {
@@ -172,7 +173,7 @@ export function buildLiveTerminalProductBundle(args) {
             // so a green run never silently over-claims a fully-proven $0.
             ...(noSpend.unmeasuredLines.length > 0
                 ? [
-                    `${noSpendLineMeasured(noSpend) ? noSpendNotEstablished(noSpend.maxUsd ?? 0) : "No-spend proof is partial."} ${describeMeasuredSpend(args.ledgers.cost, args.trace.tokenUsage)} An adapter may supply the missing signals through costProbe.`,
+                    `${noSpendLineMeasured(noSpend) ? noSpendNotEstablished(noSpend.maxUsd ?? 0) : "No-spend proof is partial."} ${describeMeasuredSpend(args.ledgers.cost, args.trace.tokenUsage)} humanish has no source for the missing lines, and a study cannot supply one.`,
                 ]
                 : []),
         ],
@@ -283,6 +284,7 @@ export function renderTerminalReviewMarkdown(bundle) {
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
         `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
+        `- outcome: ${reviewOutcome(bundle)}`,
         `- summary: ${bundle.review.summary}`,
         `- mission: ${bundle.scenario.goal}`,
         ...(subject ? [`- subject: ${subject.message}`] : []),

package/dist/routes/terminal/credentials.js

@@ -38,7 +38,7 @@ export function buildRuntimeAuth(args) {
         return {
             ok: false,
             code: "HUMANISH_TERMINAL_RUNTIME_AUTH_MISSING",
-            message: `Live terminal-product studies declare runtimeAuth "${String(args.runtimeAuth)}" and need ${ALLOWED_RUNTIME_KEY_NAMES.join(" or ")} in the environment (pass via --env-file; the selected auth mode places the value in command-scoped env or an external E2B header transform; the value is never persisted).`,
+            message: `Live terminal-product studies declare runtimeAuth "${String(args.runtimeAuth)}" and need ${ALLOWED_RUNTIME_KEY_NAMES.join(" or ")} in the environment (pass via --dotenv; the selected auth mode places the value in command-scoped env or an external E2B header transform; the value is never persisted).`,
         };
     }
     const keyValue = args.env[keyName];

package/dist/routes/terminal/dry-run.js

@@ -68,20 +68,16 @@ export async function runDryTerminalStudy(args) {
         verdict: judgment.verdict,
     });
     bundle.events.push(runtimeDeclaredEvent(plan.runtime, createdAt));
-    const finished = await run.finish(bundle);
+    const policy = OUTCOME_POLICIES.terminal;
+    const execution = judgeExecution([], policy);
+    const finished = await run.finish(bundle, {
+        ok: resultOk({ judgment, execution, scorerFailures: [], policy }),
+        execution,
+        policy,
+    });
     const observer = await finished.renderObserver();
     await validatePreparedRunArtifactPaths(finished.paths);
-    const policy = OUTCOME_POLICIES.terminal;
-    const execution = judgeExecution(observer.ok
-        ? []
-        : [
-            {
-                kind: "evidence",
-                message: observer.error?.message ?? "Observer failed for the terminal-product run.",
-            },
-        ], policy);
-    const ok = resultOk({ judgment, execution, scorerFailures: [], policy });
-    await finished.recordOutcome({ ok, execution });
+    const { ok } = finished.outcome;
     return {
         ...studyResultIdentity("terminal", plan.studyId),
         ok,

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

@@ -7,9 +7,9 @@ import type { CostLine, NoSpendProof, TerminalCostLedger } from "./types.js";
  *   - The `provider` line is populated from the actor trace's tokenUsage.costUsd when the trace
  *     carries it (a measured value, incl. a measured 0). When the trace carries no costUsd, the
  *     provider line is `null` = not measured (never guessed to 0 just because no-spend was intended).
- *   - product/media/payment are `null` by default: core has no signal for those categories; an
- *     adapter may provide one through the shipped costProbe seam.
- * `injectedLines` lets a test or adapter supply known spend for a category,
+ *   - product/media/payment are `null` by default: core has no signal for those categories, and
+ *     only a test can supply one, through `StudyDeps.costProbe`.
+ * `injectedLines` lets a test supply known spend for a category,
  * exercising the fail-closed cap enforcement deterministically without a real billable run.
  */
 export declare function buildCostLedger(args: {

package/dist/routes/terminal/ledger.js

@@ -6,9 +6,9 @@ import { COST_CATEGORIES } from "../../run/terminal-contract.js";
  *   - The `provider` line is populated from the actor trace's tokenUsage.costUsd when the trace
  *     carries it (a measured value, incl. a measured 0). When the trace carries no costUsd, the
  *     provider line is `null` = not measured (never guessed to 0 just because no-spend was intended).
- *   - product/media/payment are `null` by default: core has no signal for those categories; an
- *     adapter may provide one through the shipped costProbe seam.
- * `injectedLines` lets a test or adapter supply known spend for a category,
+ *   - product/media/payment are `null` by default: core has no signal for those categories, and
+ *     only a test can supply one, through `StudyDeps.costProbe`.
+ * `injectedLines` lets a test supply known spend for a category,
  * exercising the fail-closed cap enforcement deterministically without a real billable run.
  */
 export function buildCostLedger(args) {
@@ -39,7 +39,7 @@ export function buildCostLedger(args) {
         usd: null,
         count: null,
         source: "unmeasured",
-        note: `${category} spend not measured: humanish has no ${category} spend signal for this run, and an adapter may supply one through costProbe. Recorded as null, never guessed as 0.`,
+        note: `${category} spend not measured: humanish has no ${category} spend signal, and a study cannot supply one. Recorded as null, never guessed as 0.`,
     });
     const lines = {
         product: args.injectedLines?.product ?? unmeasured("product"),
@@ -149,7 +149,7 @@ export function evaluateCapsAgainstLedger(ledger, caps) {
         const overLines = COST_CATEGORIES.filter((c) => ledger.lines[c].usd !== null && ledger.lines[c].usd > 0);
         return {
             ok: false,
-            message: `Stopped: measured spend ${ledger.knownTotalUsd} USD passed scenario.caps.maxUsd=${caps.maxUsd}${overLines.length > 0 ? ` (non-zero lines: ${overLines.join(", ")})` : ""}. The cap stops the run; it is not a warning.`,
+            message: `Stopped: measured spend ${ledger.knownTotalUsd} USD passed caps.maxUsd=${caps.maxUsd}${overLines.length > 0 ? ` (non-zero lines: ${overLines.join(", ")})` : ""}. The cap stops the run; it is not a warning.`,
         };
     }
     if (caps.maxJobs !== undefined) {
@@ -162,7 +162,7 @@ export function evaluateCapsAgainstLedger(ledger, caps) {
         if (knownJobs > caps.maxJobs) {
             return {
                 ok: false,
-                message: `Stopped: ${knownJobs} measured billable jobs passed scenario.caps.maxJobs=${caps.maxJobs}.`,
+                message: `Stopped: ${knownJobs} measured billable jobs passed caps.maxJobs=${caps.maxJobs}.`,
             };
         }
     }

package/dist/routes/terminal/live-finish.js

@@ -1,5 +1,6 @@
 // Finishing a live terminal session: the actor trace from the captured stream, the spend ledger
 // and its caps check, the evidence files, the bundle, and the study result.
+import { publicSandboxView, readRunSandboxIds, scrubSandboxIds } from "../../run/sandbox-ids.js";
 import { buildRunCostSummary } from "../../run/cost-summary.js";
 import { writeContainedOutputFile } from "../../run/contained-output.js";
 import { validatePreparedRunArtifactPaths, } from "../../run/paths.js";
@@ -8,7 +9,7 @@ import { normalizeLocalActorTranscript, TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGE
 import { applyAdapterExtensionSeam } from "./adapter.js";
 import { buildLiveTerminalProductBundle } from "./bundle.js";
 import { buildCostLedger, buildNoSpendProof, describeMeasuredSpend, evaluateCapsAgainstLedger, noSpendLineMeasured, noSpendNotEstablished, } from "./ledger.js";
-import { foldScorerFailures, judgeExecution, judgeTerminal, OUTCOME_POLICIES, } from "../../run/judge.js";
+import { foldScorerFailures, judgeExecution, judgeTerminal, OUTCOME_POLICIES, resultOk, } from "../../run/judge.js";
 import { terminalExecutionFailures, terminalStudyResult, terminalParticipantFacts, } from "./result.js";
 import { parseTerminalTokenUsage } from "./token-usage.js";
 import { buildTerminalActorTrace, scrubSplitKnownValues, tailOf } from "./trace.js";
@@ -59,7 +60,7 @@ async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
     // --- Spend ledger + no-spend proof + full caps enforcement (fail-closed). ---
     // The cost ledger is derived, with the null discipline: provider spend from the trace's
     // tokenUsage.costUsd when present (else null = not measured), product/media/payment null by
-    // default (core has no signal). The costProbe hook lets tests or adapters inject known
+    // default (core has no signal). The costProbe hook lets tests inject known
     // spend to exercise the fail-closed cap without a real billable run.
     const injectedLines = costProbe?.(trace.tokenUsage?.costUsd === undefined ? {} : { tokenCostUsd: trace.tokenUsage.costUsd });
     if (costProbe)
@@ -170,19 +171,24 @@ export async function finishLiveTerminalSession(inputs) {
     // The one final verdict fold: scoring can only make the judged verdict stricter.
     bundle.review = foldScorerFailures(bundle.review, scorer.failures);
     await validatePreparedRunArtifactPaths(runPaths);
-    const finished = await run.finish(bundle);
-    const observer = await finished.renderObserver();
-    await validatePreparedRunArtifactPaths(runPaths);
     // A failing agent is captured evidence on this route: only the execution and a declared scorer
-    // fail ok.
+    // fail ok. A declared scorer that did not render a pass (status:"fail", malformed or thrown) is a
+    // gate, so it fails ok as well as the persisted verdict.
+    const policy = OUTCOME_POLICIES.terminal;
     const execution = judgeExecution(terminalExecutionFailures({
         participant,
         capFailure,
         sessionReason: sanitize(session.reason),
         cleanup: session.cleanup,
-        observer,
-    }), OUTCOME_POLICIES.terminal);
-    const result = terminalStudyResult({
+    }), policy);
+    const finished = await run.finish(bundle, {
+        ok: resultOk({ judgment, execution, scorerFailures: scorer.failures, policy }),
+        execution,
+        policy,
+    });
+    const observer = await finished.renderObserver();
+    await validatePreparedRunArtifactPaths(runPaths);
+    return terminalStudyResult({
         cwd,
         studyId: plan.studyId,
         actorId: plan.actor,
@@ -198,19 +204,19 @@ export async function finishLiveTerminalSession(inputs) {
         noSpendProof,
         capFailure,
         declaredScorerFailure: scorer.failures[0],
-        judgment,
-        execution,
+        ok: finished.outcome.ok,
         observer,
         warnings,
     });
-    await finished.recordOutcome({ ok: result.ok, execution });
-    return result;
 }
 /** Persist the terminal evidence: redacted events, normalized transcript, ledgers, actor trace. */
 async function writeTerminalEvidence(runPaths, evidence) {
     const { terminalEvents, normalizedTranscript, ledgers, trace } = evidence;
-    await writeContainedOutputFile(runPaths, TERMINAL_EVENTS_ARTIFACT, `${terminalEvents.map((e) => JSON.stringify(e)).join("\n")}${terminalEvents.length > 0 ? "\n" : ""}`, "utf8");
-    await writeContainedOutputFile(runPaths, TERMINAL_TRANSCRIPT_ARTIFACT, `${normalizedTranscript}\n`, "utf8");
-    await writeContainedOutputFile(runPaths, TERMINAL_LEDGERS_ARTIFACT, `${JSON.stringify(ledgers, null, 2)}\n`, "utf8");
-    await writeContainedOutputFile(runPaths, "actor.json", `${JSON.stringify(trace, null, 2)}\n`, "utf8");
+    // The sandbox's raw id stays in sandbox-receipts.ndjson; these files name it by digest.
+    const ids = await readRunSandboxIds(runPaths);
+    const scrub = (text) => scrubSandboxIds(text, ids);
+    await writeContainedOutputFile(runPaths, TERMINAL_EVENTS_ARTIFACT, scrub(`${terminalEvents.map((e) => JSON.stringify(e)).join("\n")}${terminalEvents.length > 0 ? "\n" : ""}`), "utf8");
+    await writeContainedOutputFile(runPaths, TERMINAL_TRANSCRIPT_ARTIFACT, scrub(`${normalizedTranscript}\n`), "utf8");
+    await writeContainedOutputFile(runPaths, TERMINAL_LEDGERS_ARTIFACT, `${JSON.stringify(publicSandboxView(ledgers, ids), null, 2)}\n`, "utf8");
+    await writeContainedOutputFile(runPaths, "actor.json", scrub(`${JSON.stringify(trace, null, 2)}\n`), "utf8");
 }

package/dist/routes/terminal/plan.js

@@ -35,7 +35,7 @@ export function planTerminalStudy(config, input) {
     const actorType = config.actors[0]?.type ?? "";
     const descriptor = actorRegistry[actorType];
     if (!descriptor || !isTerminalActorDescriptor(descriptor))
-        return refuse("HUMANISH_TERMINAL_ACTOR_UNSUPPORTED", `actors[0].type "${actorType}" is not a registered terminal actor.`);
+        return refuse("HUMANISH_TERMINAL_ACTOR_UNSUPPORTED", `actor.type "${actorType}" is not a registered terminal actor.`);
     const runtimeVersion = config.execution?.runtime?.version;
     const actor = config.actors[0];
     if ((config.execution?.runtime !== undefined && !isExactRuntimeVersion(runtimeVersion)) ||
@@ -87,14 +87,14 @@ export function planTerminalStudy(config, input) {
     const maxUsd = caps?.maxUsd;
     const maxMinutes = caps?.maxMinutes;
     if (caps === undefined || maxUsd === undefined || maxMinutes === undefined || maxMinutes <= 0)
-        return refuse("HUMANISH_TERMINAL_CAPS_MISSING", "A live terminal-product run gives the agent in the sandbox access to a model provider, so it needs a cap: set scenario.caps with maxUsd (0 means no spend) and a positive maxMinutes (the time limit for the codex command). The key is used only while the cap is in force.", descriptor.id);
+        return refuse("HUMANISH_TERMINAL_CAPS_MISSING", "A live terminal-product run gives the agent in the sandbox access to a model provider, so it needs a cap: set caps with maxUsd (0 means no spend) and a positive maxMinutes (the time limit for the codex command). The key is used only while the cap is in force.", descriptor.id);
     // maxUsd is checked against the cost ledger after the session, and only known lines can trip it.
     // The ledger's provider line takes only provider-reported cost, which Codex does not report (the
     // token estimate in run.json is not a measurement), and core has no product, media or payment
     // signal, so without a costProbe every line is null and a positive maxUsd could never trip. That
     // cap would promise a bound nothing enforces, so it is refused; maxMinutes bounds a live run.
     if (maxUsd > 0 && input.hasCostProbe !== true)
-        return refuse("HUMANISH_TERMINAL_UNPRICED_CAP", `scenario.caps.maxUsd=${maxUsd} cannot be enforced: Codex reports no provider cost for the participant (its token cost is only estimated after the run) and no product, media or payment spend is measured, so a positive dollar cap can never trip. Set scenario.caps.maxUsd to 0 and bound the run with scenario.caps.maxMinutes, the codex command's wall-clock kill. No sandbox was created and the runtime key was not used.`, descriptor.id);
+        return refuse("HUMANISH_TERMINAL_UNPRICED_CAP", `caps.maxUsd=${maxUsd} cannot be enforced: Codex reports no provider cost for the participant (its token cost is only estimated after the run) and no product, media or payment spend is measured, so a positive dollar cap can never trip. Set caps.maxUsd to 0 and bound the run with caps.maxMinutes, the codex command's wall-clock kill. No sandbox was created and the runtime key was not used.`, descriptor.id);
     // The sandbox's timeout covers the steps before the codex command, maxMinutes and the teardown
     // buffer, and E2B refuses a sandbox over an hour. Refuse here, with the arithmetic, rather than
     // after the plan prints, from a provider 400 that names neither knob.
@@ -102,7 +102,7 @@ export function planTerminalStudy(config, input) {
     const sandboxTimeoutMs = terminalSandboxTimeoutMs({ maxMinutes, productInstall });
     if (sandboxTimeoutMs > MAX_SANDBOX_MS) {
         const headroomMinutes = (sandboxTimeoutMs - maxMinutes * 60_000) / 60_000;
-        return refuse("HUMANISH_TERMINAL_CAPS_INVALID", `scenario.caps.maxMinutes ${maxMinutes} derives a ${sandboxTimeoutMs / 60_000}m sandbox deadline, and a sandbox may not live longer than ${MAX_SANDBOX_MS / 60_000}m. The deadline is maxMinutes plus ${headroomMinutes}m: the Node bootstrap (${NODE_BOOTSTRAP_TIMEOUT_MS / 60_000}m), the runtime version check (${TERMINAL_RUNTIME_VERSION_TIMEOUT_MS / 60_000}m)${productInstall ? `, the product setup (${PRODUCT_SETUP_TIMEOUT_MS / 60_000}m)` : ""} and the teardown buffer (${TERMINAL_SANDBOX_TIMEOUT_BUFFER_MS / 60_000}m). Lower scenario.caps.maxMinutes to at most ${MAX_SANDBOX_MS / 60_000 - headroomMinutes}. No sandbox was created and the runtime key was not used.`, descriptor.id);
+        return refuse("HUMANISH_TERMINAL_CAPS_INVALID", `caps.maxMinutes ${maxMinutes} derives a ${sandboxTimeoutMs / 60_000}m sandbox deadline, and a sandbox may not live longer than ${MAX_SANDBOX_MS / 60_000}m. The deadline is maxMinutes plus ${headroomMinutes}m: the Node bootstrap (${NODE_BOOTSTRAP_TIMEOUT_MS / 60_000}m), the runtime version check (${TERMINAL_RUNTIME_VERSION_TIMEOUT_MS / 60_000}m)${productInstall ? `, the product setup (${PRODUCT_SETUP_TIMEOUT_MS / 60_000}m)` : ""} and the teardown buffer (${TERMINAL_SANDBOX_TIMEOUT_BUFFER_MS / 60_000}m). Lower caps.maxMinutes to at most ${MAX_SANDBOX_MS / 60_000 - headroomMinutes}. No sandbox was created and the runtime key was not used.`, descriptor.id);
     }
     return {
         ok: true,

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

@@ -1,6 +1,6 @@
 import type { ObserverResult } from "../../observer/render.js";
 import type { ActorCompletionReason, ActorStatus, ActorTrace } from "../../actors/contract.js";
-import { type ExecutionFailure, type ExecutionOutcome, type Judgment, type ParticipantFacts } from "../../run/judge.js";
+import { type ExecutionFailure, type ParticipantFacts } from "../../run/judge.js";
 import { type NoSpendProof, type TerminalCostLedger, type TerminalLedgers, type TerminalProductStudyResult } from "./types.js";
 /**
  * What judge.ts reads from a finished terminal session, after a blown cap has overridden it. It has
@@ -8,8 +8,9 @@ import { type NoSpendProof, type TerminalCostLedger, type TerminalLedgers, type
  */
 export declare function terminalParticipantFacts(trace: ActorTrace, sessionError: string | undefined): ParticipantFacts;
 /**
- * The live run's execution failures: a harness error, a blown spend cap, an unproven sandbox
- * teardown, and an Observer that failed.
+ * The live run's execution failures before the Observer renders: a harness error, a blown spend
+ * cap and an unproven sandbox teardown. FinishedRun.renderObserver adds an Observer that did not
+ * render.
  */
 export declare function terminalExecutionFailures(args: {
     participant: ParticipantFacts;
@@ -18,7 +19,6 @@ export declare function terminalExecutionFailures(args: {
     /** Already scrubbed and redacted. */
     sessionReason: string;
     cleanup: TerminalLedgers["cleanup"];
-    observer: Pick<ObserverResult, "ok" | "error">;
 }): ExecutionFailure[];
 /** The terminal-product study result for a live run, from its session, cleanup and cost ledger. */
 export declare function terminalStudyResult(args: {
@@ -39,9 +39,8 @@ export declare function terminalStudyResult(args: {
     /** The cap check's message when known spend or jobs exceeded the caps. */
     capFailure: string | undefined;
     declaredScorerFailure: string | undefined;
-    /** The run's judgment. On this evidence route ok does not read whether the agent passed. */
-    judgment: Judgment;
-    execution: ExecutionOutcome;
+    /** run.json's outcome.ok (FinishedRun.outcome). On this evidence route it does not read whether the agent passed. */
+    ok: boolean;
     observer: ObserverResult;
     warnings: string[];
 }): TerminalProductStudyResult;

package/dist/routes/terminal/result.js

@@ -1,4 +1,4 @@
-import { OUTCOME_POLICIES, participantHarnessFailed, resultOk, } from "../../run/judge.js";
+import { participantHarnessFailed, } from "../../run/judge.js";
 import {} from "./types.js";
 import { studyResultIdentity } from "../../run/study-result.js";
 /**
@@ -16,11 +16,12 @@ export function terminalParticipantFacts(trace, sessionError) {
     };
 }
 /**
- * The live run's execution failures: a harness error, a blown spend cap, an unproven sandbox
- * teardown, and an Observer that failed.
+ * The live run's execution failures before the Observer renders: a harness error, a blown spend
+ * cap and an unproven sandbox teardown. FinishedRun.renderObserver adds an Observer that did not
+ * render.
  */
 export function terminalExecutionFailures(args) {
-    const { participant, cleanup, observer } = args;
+    const { participant, cleanup } = args;
     return [
         ...(participantHarnessFailed(participant)
             ? [{ kind: "harness", message: participant.sessionError ?? args.sessionReason }]
@@ -34,34 +35,17 @@ export function terminalExecutionFailures(args) {
                     message: `Sandbox teardown unproven (killed=${cleanup.killed}, remaining=${cleanup.remaining}): ${cleanup.reason}`,
                 },
             ]),
-        ...(observer.ok
-            ? []
-            : [
-                {
-                    kind: "evidence",
-                    message: observer.error?.message ?? "Observer failed for the terminal-product run.",
-                },
-            ]),
     ];
 }
 /** The terminal-product study result for a live run, from its session, cleanup and cost ledger. */
 export function terminalStudyResult(args) {
-    const { cwd, studyId, actorId, productName, runId, sessionStatus, completionReason, sessionReason, sessionError, sandboxId, cleanup, cost, noSpendProof, capFailure, declaredScorerFailure, judgment, execution, observer, warnings, } = args;
+    const { cwd, studyId, actorId, productName, runId, sessionStatus, completionReason, sessionReason, sessionError, sandboxId, cleanup, cost, noSpendProof, capFailure, declaredScorerFailure, ok, observer, warnings, } = args;
     // The run's exit code: verified evidence, no harness error and proven cleanup. A blocked/
     // timed-out agent run is still ok-as-evidence at the bundle level (the failure is the evidence),
     // but the study result surfaces ok:false on a harness error or unproven teardown (fail-closed).
     // remaining===0 is the by-id-confirmed-reclaimed state; remaining===1 (still present) and
     // remaining===-1 (kill(id) itself failed) are both unproven by design.
     const cleanupProven = cleanup.killed && cleanup.remaining === 0;
-    // A config-declared scorer that failed to render a pass (status:"fail" / malformed / throw) fails the
-    // run result as well as the persisted verdict: the keystone route's declared rubric is a gate, so
-    // its fail must drive exit code. Library callers never set this (additive, back-compat).
-    const ok = resultOk({
-        judgment,
-        execution,
-        scorerFailures: declaredScorerFailure === undefined ? [] : [declaredScorerFailure],
-        policy: OUTCOME_POLICIES.terminal,
-    });
     return {
         ...studyResultIdentity("terminal", studyId),
         ok,

package/dist/routes/terminal/session.js

@@ -20,7 +20,7 @@ export function checkLiveTerminalMachine(plan, input, warnings) {
     const { maxUsd } = plan.caps;
     // planTerminalStudy refuses a positive maxUsd without a costProbe, so one is present here.
     if (maxUsd > 0) {
-        warnings.push(`scenario.caps.maxUsd=${maxUsd} is checked after the session against the lines the costProbe measures; lines it leaves null (unmeasured) never trip it. scenario.caps.maxMinutes bounds the run while it runs.`);
+        warnings.push(`caps.maxUsd=${maxUsd} is checked after the session against the measured cost lines; a line left null (unmeasured) never trips it. caps.maxMinutes bounds the run while it runs.`);
     }
     // --- Deny-by-default credentials: build the command-scoped allowlist. ---
     const runtimeEnv = buildRuntimeAuth({ runtimeAuth: plan.runtime.auth, env });

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

@@ -147,7 +147,10 @@ export interface TerminalProductStudyResult extends AutomaticAnalysisResult, Stu
     };
     /** Live-only: the sandbox lifecycle proof (the key/auth value is never surfaced here). */
     sandbox?: {
+        /** "[redacted-sandbox-id]"; the raw id is only in the run's sandbox-receipts.ndjson. */
         sandboxId: string;
+        /** The id's digest, which matches its receipt. */
+        sandboxIdDigest?: string;
         killed: boolean;
         /** By-id proof (never a re-list): 0 = confirmed reclaimed, 1 = still present (unconfirmed),
          *  -1 = kill(id) itself failed or was unavailable. See TerminalLedgers["cleanup"]. */

package/dist/run/bundle-shape.d.ts

@@ -1,6 +1,8 @@
-import { type ReviewSummary, type RunAdapterScore, type RunBundle } from "./bundle.js";
+import { type ReviewSummary, type RunAdapterScore, type RunBundle, type RunOutcome } from "./bundle.js";
 import { type StoredCleanupResult, type RunPointer } from "./results.js";
 export declare function isRunBundle(value: unknown): value is RunBundle;
+/** run.json's `outcome`: a finished run's ok and execution outcome, or the signal that stopped it. */
+export declare function isRunOutcome(value: unknown): value is RunOutcome;
 export declare function isCleanupResult(value: unknown): value is StoredCleanupResult;
 export declare function isRunAdapterScore(value: unknown): value is RunAdapterScore;
 export declare const ARCHIVE_SHA256_PATTERN: RegExp;

package/dist/run/bundle-shape.js

@@ -5,6 +5,7 @@ import { CLEANUP_SCHEMA, } from "./results.js";
 import { isRunSimulationStatus, isRunStream, isRunStreamKind } from "./stream-shape.js";
 import { isLocalEvidenceArtifactPath } from "./paths.js";
 import { isRunFeedbackCandidate } from "./feedback-shape.js";
+import { EXECUTION_FAILURE_KINDS } from "./judge.js";
 import { isSharedWorldEvidence } from "./shared-world-shape.js";
 import { isNonNegativeSafeInteger, isPositiveSafeInteger, isRecord } from "./type-guards.js";
 export function isRunBundle(value) {
@@ -64,7 +65,30 @@ export function isRunBundle(value) {
                 value.adapterArtifacts.every(isRunAdapterArtifact))) &&
         (value.providerResources === undefined ||
             (Array.isArray(value.providerResources) &&
-                value.providerResources.every(isRunProviderResource))));
+                value.providerResources.every(isRunProviderResource))) &&
+        (value.outcome === undefined || isRunOutcome(value.outcome)));
+}
+function isExecutionFailureList(value) {
+    return (Array.isArray(value) &&
+        value.every((failure) => isRecord(failure) &&
+            typeof failure.kind === "string" &&
+            EXECUTION_FAILURE_KINDS.includes(failure.kind) &&
+            typeof failure.message === "string"));
+}
+/** run.json's `outcome`: a finished run's ok and execution outcome, or the signal that stopped it. */
+export function isRunOutcome(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.state === "interrupted")
+        return (value.ok === false &&
+            (value.signal === "SIGINT" || value.signal === "SIGTERM" || value.signal === "SIGHUP") &&
+            typeof value.at === "string");
+    return (value.state === "finished" &&
+        typeof value.ok === "boolean" &&
+        isRecord(value.execution) &&
+        typeof value.execution.succeeded === "boolean" &&
+        isExecutionFailureList(value.execution.failures) &&
+        (value.execution.warnings === undefined || isExecutionFailureList(value.execution.warnings)));
 }
 function isRunProviderResource(value) {
     return (isRecord(value) &&
@@ -73,6 +97,7 @@ function isRunProviderResource(value) {
         value.kind === "sandbox" &&
         typeof value.id === "string" &&
         value.id.trim().length > 0 &&
+        (value.idDigest === undefined || typeof value.idDigest === "string") &&
         value.owner === "humanish" &&
         (value.status === "running" || value.status === "killed" || value.status === "unknown") &&
         (value.simId === undefined || typeof value.simId === "string") &&

package/dist/run/bundle.d.ts

@@ -1,7 +1,9 @@
 import type { CommsReceivingEvidence } from "../comms/receiving-types.js";
 import { type CapturedGitState } from "./git-state.js";
+import type { ExecutionOutcome } from "./judge.js";
 import type { SharedWorldEvidence } from "./shared-world-evidence.js";
 import { type RunStudyProvenance } from "./study-provenance.js";
+import type { RunInterruptSignal } from "./status.js";
 import type { RunSimulationStatus, RunStream, RunStreamKind } from "./streams.js";
 export declare const RUN_BUNDLE_SCHEMA = "humanish.run-bundle.v1";
 /** The run bundle file, relative to the run directory. */
@@ -252,6 +254,13 @@ export interface RunBundle {
         events: string;
     };
     review: ReviewSummary;
+    /**
+     * How the run ended as an execution. `review.verdict` is what the participants experienced;
+     * this is whether the run worked, which no surface may show as a pass when `ok` is false. Absent
+     * while the run is in progress, when its process died without writing it, and on runs recorded
+     * before this field, whose status.json holds the outcome instead.
+     */
+    outcome?: RunOutcome;
     feedbackCandidates: RunFeedbackCandidate[];
     /** Structured subject provenance. Optional and additive: emitted by the
      * computer-use and shared-world backends and the clone scripted-browser route; tolerated absent
@@ -347,6 +356,21 @@ export interface RunBundle {
      */
     cost?: RunCostSummary;
 }
+/**
+ * How a run ended. `finished`: Run.finish published the final bundle with the route result's `ok`
+ * and its execution outcome (`judgeExecution` in src/run/judge.ts). `interrupted`: the CLI's signal
+ * handler stopped the run before it finished; run.json is then the last live flush.
+ */
+export type RunOutcome = {
+    state: "finished";
+    ok: boolean;
+    execution: ExecutionOutcome;
+} | {
+    state: "interrupted";
+    ok: false;
+    signal: RunInterruptSignal;
+    at: string;
+};
 /**
  * One contributing cost line of a RunCostSummary. A line is present even when it cannot be priced
  * (it records that we tried and could not): an unpriceable line carries estimatedCostUsd: null + a
@@ -413,7 +437,13 @@ export interface RunProviderResource {
     schema: "humanish.provider-resource.v1";
     provider: "e2b-desktop";
     kind: "sandbox";
+    /**
+     * "[redacted-sandbox-id]" in runs from 0.110 on; earlier runs recorded the raw id here. The raw id
+     * is in the run's sandbox-receipts.ndjson.
+     */
     id: string;
+    /** The id's digest, which matches its receipt. Absent on runs recorded before 0.110. */
+    idDigest?: string;
     owner: "humanish";
     status: "running" | "killed" | "unknown";
     simId?: string;

package/dist/run/display.d.ts

@@ -0,0 +1,59 @@
+import type { RunOutcome } from "./bundle.js";
+import type { ExecutionFailure } from "./judge.js";
+import { type RunLiveness } from "./status.js";
+/** The states a run is shown in. */
+export type RunDisplayState = "running" | "interrupted" | "passed" | "failed" | "blocked" | "timed_out" | "no_verdict" | "dry_run" | "unknown";
+/** A run as a surface shows it. */
+export interface RunDisplay {
+    state: RunDisplayState;
+    /** The state in words: "passed", "timed out", "no verdict". */
+    label: string;
+    /** How a surface colors it: `pass` only for `passed`, `fail` only for `failed`. */
+    tone: "pass" | "fail" | "warn" | "live" | "neutral";
+    /** The first execution failure that failed the run, as `kind: message`. */
+    reason?: string;
+}
+/** What runDisplay reads: whether the run is alive, what its participants experienced, and its ok. */
+export interface RunDisplayFacts {
+    liveness: RunLiveness;
+    mode?: string | null | undefined;
+    /** `review.verdict`. */
+    verdict?: string | undefined;
+    /** The run's own ok from run.json's outcome; absent when the run recorded none. */
+    ok?: boolean | undefined;
+    /** The first execution failure that failed the run. */
+    failure?: ExecutionFailure | undefined;
+}
+/**
+ * A run's state. A live or interrupted run is that, whatever its last flush said. A finished run
+ * shows its participants' blocked, timed-out or failed verdict; otherwise a run whose ok is false
+ * is failed, even with a pass verdict, because its execution failed. Only then does a pass verdict
+ * show as passed.
+ */
+export declare function runDisplay(facts: RunDisplayFacts): RunDisplay;
+/** A state in words: "passed", "timed out", "no verdict". */
+export declare function runDisplayLabel(state: RunDisplayState): string;
+/** What bundleDisplayFacts reads from run.json; a listing reads it from an unchecked file. */
+export interface DisplayedBundle {
+    runId: string;
+    mode?: string | undefined;
+    review?: {
+        verdict?: string | undefined;
+    } | undefined;
+    simulations?: ReadonlyArray<{
+        status?: string | undefined;
+    } | undefined> | undefined;
+    outcome?: RunOutcome | undefined;
+}
+/**
+ * The facts for a run from its bundle. run.json's `outcome` decides when it has one. A bundle
+ * without one is in progress, or was recorded before the field existed: its status record, when
+ * given and naming the run, then says whether the run is alive and, for the older run, holds its ok.
+ * With no record, a bundle whose simulations are still running is live.
+ */
+export declare function bundleDisplayFacts(bundle: DisplayedBundle, status?: unknown, nowMs?: number): RunDisplayFacts;
+/**
+ * How review.md says the run ended: the display of the bundle it is rendered from, so a run whose
+ * execution failed never reads as a pass beside its participants' verdict.
+ */
+export declare function reviewOutcome(bundle: DisplayedBundle): string;