humanish 0.110.0 → 0.110.2

package/dist/routes/terminal/bundle.js

@@ -2,9 +2,11 @@ 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";
+import { DEFAULT_RUNTIME_AUTH } from "./runtime-auth.js";
 import { describeMeasuredSpend, noSpendLineMeasured, noSpendNotEstablished } from "./ledger.js";
 /**
  * Project the terminal-product run into a humanish.run-bundle.v1 (no schema change: a new
@@ -58,7 +60,7 @@ export function buildTerminalProductBundle(args) {
             type: "terminal-lab.credentials.declared",
             // Names-only evidence: the runtime-auth channel is declared; no value is ever
             // recorded. The deny-by-default policies are recorded so the credential posture is auditable.
-            message: `Runtime auth channel: ${args.runtimeAuth ?? "none declared"} (names only; values never persist; the live engine applies the selected key placement, while this dry-run performs no injection). Credential policies (deny-by-default): allowPrivateRepoAccess=${args.policies.allowPrivateRepoAccess}, allowProviderCredentials=${args.policies.allowProviderCredentials}, allowPaymentCredentials=${args.policies.allowPaymentCredentials}, allowGitHubMutation=${args.policies.allowGitHubMutation}.`,
+            message: `Runtime auth channel: ${args.runtimeAuth ?? `${DEFAULT_RUNTIME_AUTH}, the default`} (names only; values never persist; the live engine applies the selected key placement, while this dry-run performs no injection). Credential policies (deny-by-default): allowPrivateRepoAccess=${args.policies.allowPrivateRepoAccess}, allowProviderCredentials=${args.policies.allowProviderCredentials}, allowPaymentCredentials=${args.policies.allowPaymentCredentials}, allowGitHubMutation=${args.policies.allowGitHubMutation}.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-003-caps",
@@ -72,7 +74,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 +174,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 +285,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.d.ts

@@ -1,12 +1,12 @@
 import type { StudyRuntimeAuth } from "../../study/types.js";
 /**
- * Resolve the runtime key on the host. Legacy openai-env passes it command-scoped; openai-egress
- * returns an inert command env while retaining the actual value for the external transform and
- * literal redaction. Only CODEX_API_KEY/OPENAI_API_KEY are accepted as sources. No other operator
- * credential is forwarded. The real value must never be logged or persisted in either mode.
+ * Resolve the runtime key on the host. openai-egress, the default, returns an inert command env
+ * while retaining the actual value for the external transform and literal redaction; openai-env
+ * passes it command-scoped. Only CODEX_API_KEY/OPENAI_API_KEY are accepted as sources. No other
+ * operator credential is forwarded. The real value must never be logged or persisted in either mode.
  */
 export declare function buildRuntimeAuth(args: {
-    /** Undefined retains the historical openai-env default. */
+    /** Undefined selects openai-egress, so the raw key stays out of the sandbox unless a study opts in. */
     runtimeAuth: StudyRuntimeAuth | undefined;
     /** The operator environment the key value is read from (process.env or a test fake). */
     env: Record<string, string | undefined>;

package/dist/routes/terminal/credentials.js

@@ -1,10 +1,10 @@
-import { E2B_SYSTEM_CA_BUNDLE, OPENAI_EGRESS_PLACEHOLDER } from "./runtime-auth.js";
+import { DEFAULT_RUNTIME_AUTH, E2B_SYSTEM_CA_BUNDLE, OPENAI_EGRESS_PLACEHOLDER, } from "./runtime-auth.js";
 import { TERMINAL_PRODUCT_STUDY_PROVIDER_METADATA } from "./types.js";
 /**
- * Resolve the runtime key on the host. Legacy openai-env passes it command-scoped; openai-egress
- * returns an inert command env while retaining the actual value for the external transform and
- * literal redaction. Only CODEX_API_KEY/OPENAI_API_KEY are accepted as sources. No other operator
- * credential is forwarded. The real value must never be logged or persisted in either mode.
+ * Resolve the runtime key on the host. openai-egress, the default, returns an inert command env
+ * while retaining the actual value for the external transform and literal redaction; openai-env
+ * passes it command-scoped. Only CODEX_API_KEY/OPENAI_API_KEY are accepted as sources. No other
+ * operator credential is forwarded. The real value must never be logged or persisted in either mode.
  */
 export function buildRuntimeAuth(args) {
     // The "openai-env" channel accepts CODEX_API_KEY or OPENAI_API_KEY as the runtime key source
@@ -46,7 +46,15 @@ export function buildRuntimeAuth(args) {
     // GITHUB_TOKEN/GH_TOKEN, no payment/deploy/db/media key, excluded by construction. When the
     // source was OPENAI_API_KEY, the same value is also injected as CODEX_API_KEY so codex exec's
     // documented single-invocation auth channel is populated either way (see the comment above).
-    const mode = args.runtimeAuth ?? "openai-env";
+    const mode = args.runtimeAuth ?? DEFAULT_RUNTIME_AUTH;
+    // Only the exact openai-env value places the raw key in the command, so a misspelled mode from a
+    // config that skipped the planner is refused, never read as openai-env.
+    if (mode !== "openai-egress" && mode !== "openai-env")
+        return {
+            ok: false,
+            code: "HUMANISH_TERMINAL_CREDENTIAL_DENIED",
+            message: "Runtime auth must be openai-egress or openai-env; no key was placed.",
+        };
     const envs = mode === "openai-egress"
         ? // Codex documents this verified-TLS trust channel. The stock image's default OpenSSL CA
             // file can be absent even though E2B has installed its proxy CA in the system bundle.

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

@@ -9,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";
@@ -60,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)
@@ -171,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,
@@ -199,13 +204,10 @@ 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) {

package/dist/routes/terminal/plan.js

@@ -6,6 +6,7 @@ import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
 import { isReasoningEffort } from "../../actors/reasoning-effort.js";
 import { actorRegistry, isTerminalActorDescriptor } from "../../actors/registry.js";
 import { isNonEmpty, planBase } from "../../study/plan-base.js";
+import { studyUrlCredentialReason } from "../../study/url-credentials.js";
 import { desktopMediaValidationReason, taskProtocolValidationReason, } from "../../study/validation.js";
 import { MAX_SANDBOX_MS } from "../../substrates/e2b/lifetime.js";
 import { NODE_BOOTSTRAP_TIMEOUT_MS } from "../../subject/node-bootstrap.js";
@@ -26,6 +27,13 @@ export function planTerminalStudy(config, input) {
     const mediaReason = desktopMediaValidationReason(config);
     if (mediaReason)
         return refuse("HUMANISH_TERMINAL_SUBJECT_INVALID", mediaReason);
+    // A library caller's config skips the parser, which refuses these first.
+    const credential = studyUrlCredentialReason(config);
+    if (credential)
+        return refuse("HUMANISH_TERMINAL_SUBJECT_INVALID", credential);
+    const runtimeAuth = config.execution?.runtimeAuth;
+    if (runtimeAuth !== undefined && runtimeAuth !== "openai-egress" && runtimeAuth !== "openai-env")
+        return refuse("HUMANISH_TERMINAL_CREDENTIAL_DENIED", "`execution.runtimeAuth` must be openai-egress or openai-env. Leave it out for openai-egress, which keeps the OpenAI key outside the sandbox.");
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
     if (!analysis.ok)
         return refuse("HUMANISH_STUDY_ANALYSIS_INVALID", analysis.message);
@@ -35,7 +43,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 +95,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 +110,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/route.js

@@ -11,10 +11,11 @@
 // The safety contract (`docs/history/goals/terminal-product-lane/goal.md`) is enforced by construction in
 // the files each item names, and checked by the verifier (verify/actor.ts
 // validateTerminalProductEvidence):
-//   1. Explicit key placement. openai-env (default) injects the raw runtime key command-scoped,
-//      never through Sandbox.create({envs}). Opt-in openai-egress sends it only in the host-side E2B
-//      header transform and passes an inert command placeholder. The proxy is spendable by every
-//      sandbox process from creation; this protects the raw key, not provider spending.
+//   1. Explicit key placement. openai-egress (default) sends the raw runtime key only in the
+//      host-side E2B header transform and passes an inert command placeholder. The proxy is
+//      spendable by every sandbox process from creation; this protects the raw key, not provider
+//      spending. Opt-in openai-env injects the raw key command-scoped, never through
+//      Sandbox.create({envs}).
 //      Enforced in credentials.ts and runtime-auth.ts.
 //   2. Fail-closed cap. The live key is never exercised without scenario.caps in force: maxUsd
 //      (default/require 0 = no-spend) + maxMinutes (wall-clock kill of the codex command).

package/dist/routes/terminal/runtime-auth.d.ts

@@ -1,4 +1,10 @@
+import type { StudyRuntimeAuth } from "../../study/types.js";
 import type { E2BNetworkOptions } from "../../substrates/e2b/sdk.js";
+/**
+ * The runtime auth a study gets when it declares none. A shell agent can read its own command env,
+ * so the raw key stays in the host-side E2B request unless a study declares openai-env.
+ */
+export declare const DEFAULT_RUNTIME_AUTH: StudyRuntimeAuth;
 /** E2B envd installs the sandbox-specific proxy CA into this system bundle before routing. */
 export declare const E2B_SYSTEM_CA_BUNDLE = "/etc/ssl/certs/ca-certificates.crt";
 /** An inert nonsecret value satisfies Codex exec's auth prerequisite. E2B replaces the header. */

package/dist/routes/terminal/runtime-auth.js

@@ -1,3 +1,8 @@
+/**
+ * The runtime auth a study gets when it declares none. A shell agent can read its own command env,
+ * so the raw key stays in the host-side E2B request unless a study declares openai-env.
+ */
+export const DEFAULT_RUNTIME_AUTH = "openai-egress";
 const OPENAI_EGRESS_HOST = "api.openai.com";
 /** E2B envd installs the sandbox-specific proxy CA into this system bundle before routing. */
 export const E2B_SYSTEM_CA_BUNDLE = "/etc/ssl/certs/ca-certificates.crt";

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/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) &&

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

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;