humanish 0.106.1 → 0.108.0

package/dist/routes/terminal/credentials.js

@@ -7,29 +7,29 @@ import { TERMINAL_PRODUCT_LAB_PROVIDER_METADATA } from "./types.js";
  * 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
+    // The "openai-env" channel accepts CODEX_API_KEY or OPENAI_API_KEY as the runtime key source
     // name, read in this preference order. CODEX_API_KEY is preferred: the official Codex docs
-    // (developers.openai.com/codex/noninteractive) document it as the channel for a SINGLE codex exec
-    // invocation, which is exactly this lane's shape (no persisted auth.json/CODEX_HOME, per-command
+    // (developers.openai.com/codex/noninteractive) document it as the channel for a single codex exec
+    // invocation, which is exactly this route's shape (no persisted auth.json/CODEX_HOME, per-command
     // envs only). A dated in-repo receipt
-    // (docs/goals/humanish-recursive-proof-critical-point/receipts/actor-required-attempt.md) shows a
+    // (docs/history/goals/humanish-recursive-proof-critical-point/receipts/actor-required-attempt.md) shows a
     // job-wide OPENAI_API_KEY alone failing bearer auth for this same pinned-exec pattern. When the
-    // operator only exported OPENAI_API_KEY, its value is ALSO injected under CODEX_API_KEY below, so
+    // operator only exported OPENAI_API_KEY, its value is also injected under CODEX_API_KEY below, so
     // the documented exec auth channel is always populated regardless of which name the operator
-    // used. The ALLOWLIST is exactly these two names; everything else is denied by construction.
+    // used. The allowlist is exactly these two names; everything else is denied by construction.
     const ALLOWED_RUNTIME_KEY_NAMES = ["CODEX_API_KEY", "OPENAI_API_KEY"];
-    // Tripwire (safety contract item 4): if a FUTURE widening of ALLOWED_RUNTIME_KEY_NAMES ever
+    // Tripwire (deny-by-default credentials): if a future widening of ALLOWED_RUNTIME_KEY_NAMES ever
     // added a clearly-non-runtime credential (a GitHub/payment/deploy/db secret), fail closed. The
-    // generic `*_KEY` shape is deliberately NOT a tripwire here, since a runtime key legitimately
+    // generic `*_KEY` shape is deliberately left out of the tripwire, since a runtime key legitimately
     // ends in _KEY (CODEX_API_KEY/OPENAI_API_KEY), so testing it against the generic shape would
-    // false-positive on the very key this lane exists to inject. The positive allowlist itself is
+    // false-positive on the very key this route exists to inject. The positive allowlist itself is
     // the real boundary: the command env is built from exactly these names and nothing else (so
     // GITHUB_TOKEN/payment/db keys present in the operator env are never forwarded, proven by the
     // deterministic test).
     if (ALLOWED_RUNTIME_KEY_NAMES.some((name) => isNonRuntimeCredentialName(name))) {
         return {
             ok: false,
-            code: "HUMANISH_TERMINAL_LAB_CREDENTIAL_DENIED",
+            code: "HUMANISH_TERMINAL_CREDENTIAL_DENIED",
             message: "Internal invariant violated: a runtime-key allowlist entry is a non-runtime credential (GitHub/payment/deploy/db).",
         };
     }
@@ -37,14 +37,14 @@ export function buildRuntimeAuth(args) {
     if (!keyName) {
         return {
             ok: false,
-            code: "HUMANISH_TERMINAL_LAB_RUNTIME_AUTH_MISSING",
+            code: "HUMANISH_TERMINAL_RUNTIME_AUTH_MISSING",
             message: `Live terminal-product labs 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).`,
         };
     }
     const keyValue = args.env[keyName];
-    // The command-scoped env is the ALLOWLIST: exactly the runtime key name(s), nothing else. No
+    // The command-scoped env is the allowlist: exactly the runtime key name(s). No
     // 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
+    // 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 envs = mode === "openai-egress"
@@ -62,11 +62,11 @@ export function buildRuntimeAuth(args) {
         keyValue,
     };
 }
-// Clearly-non-runtime credential NAME shapes. Used as the runtime-key allowlist tripwire (a
-// runtime key must never be one of these). Deliberately EXCLUDES the generic `*_KEY` shape: the
-// runtime key this lane injects (CODEX_API_KEY/OPENAI_API_KEY) legitimately ends in _KEY, so the
+// Clearly-non-runtime credential name shapes. Used as the runtime-key allowlist tripwire (a
+// runtime key must never be one of these). Deliberately excludes the generic `*_KEY` shape: the
+// runtime key this route injects (CODEX_API_KEY/OPENAI_API_KEY) legitimately ends in _KEY, so the
 // generic shape would false-positive on it. The positive allowlist, not a denylist, is what
-// keeps every OTHER operator-env credential (GitHub/payment/deploy/db/media keys) out of the
+// keeps every other operator-env credential (GitHub/payment/deploy/db/media keys) out of the
 // sandbox: the command env is built from exactly the allowlisted runtime key and nothing else.
 const NON_RUNTIME_CREDENTIAL_NAME_PATTERNS = [
     /^GITHUB_TOKEN$/i,
@@ -84,8 +84,8 @@ function isNonRuntimeCredentialName(name) {
     return NON_RUNTIME_CREDENTIAL_NAME_PATTERNS.some((pattern) => pattern.test(name));
 }
 /**
- * Build the sandbox metadata from a POSITIVE ALLOWLIST (safety contract item 6). This is the ONLY
- * way metadata is set on the terminal lane — it carries solely non-secret labels and rejects any
+ * Build the sandbox metadata from a positive allowlist. This is the only
+ * way metadata is set on the terminal route. It carries solely non-secret labels and rejects any
  * value that is not a plain short label. A verifier check asserts the persisted metadata has no
  * prompt/token/secret shapes; this builder makes that true by construction.
  */
@@ -95,7 +95,7 @@ export function buildSandboxMetadata(allowlist) {
         tool: TERMINAL_PRODUCT_LAB_PROVIDER_METADATA.tool,
         provider: "codex",
         labId: allowlist.labId,
-        simId: allowlist.simId,
+        recordId: allowlist.recordId,
         // The run id is a harness-minted token (terminal-<ts>-<hex>), not user data.
         runId: allowlist.runId,
     };

package/dist/routes/terminal/dry-run.d.ts

@@ -15,7 +15,7 @@ export declare function runDryTerminalLab(args: {
     failed: RunLiveTerminalSessionArgs["failed"];
     scope: RunScope;
 }): Promise<TerminalProductLabResult>;
-/** Compose the full prompt the agent would run. Bound to evidence by DIGEST only. */
+/** Compose the full prompt the agent would run. Bound to evidence by digest only. */
 export declare function composePrompt(args: {
     mission: string;
     personaLine: string;

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

@@ -9,7 +9,8 @@ import { buildTerminalProductBundle, renderTerminalReviewMarkdown } from "./bund
 import { resolveTerminalPersona, terminalPersonaRef } from "./persona.js";
 import { declaredRuntimeProvenance } from "./runtime.js";
 import { defaultMission, makeTerminalRunId } from "./session.js";
-import { TERMINAL_PRODUCT_LAB_SCHEMA, } from "./types.js";
+import {} from "./types.js";
+import { studyResultIdentity } from "../../run/study-result.js";
 /**
  * The dry-run path: a contract bundle with the persona and prompt digest bound, published through
  * the run scope with no sandbox, key or spend.
@@ -17,11 +18,10 @@ import { TERMINAL_PRODUCT_LAB_SCHEMA, } from "./types.js";
 export async function runDryTerminalLab(args) {
     const { plan, input, cwd, warnings, failed, scope } = args;
     const { product } = plan;
-    const hooks = input.hooks ?? {};
     const { evidenceMission, physicalCwd, persona } = await prepareDryPersona({
         plan,
         cwd,
-        env: hooks.env ?? process.env,
+        env: input.env ?? process.env,
         warnings,
     });
     const started = await scope.startRun({
@@ -31,7 +31,7 @@ export async function runDryTerminalLab(args) {
         mode: "dry-run",
         lab: plan.lab,
         renderReview: renderTerminalReviewMarkdown,
-        observer: { open: input.open === true, render: hooks.renderObserverFn },
+        observer: { open: input.open === true, render: input.deps?.renderObserver },
     });
     if (!started.ok)
         return failed(started.code, started.message);
@@ -46,9 +46,8 @@ export async function runDryTerminalLab(args) {
     const policies = plan.residual.policies;
     const judgment = judgeTerminal({ dryRun: true, participant: undefined });
     const bundle = buildTerminalProductBundle({
-        ...(plan.lab === undefined ? {} : { lab: plan.lab }),
+        run,
         actorId: plan.actor,
-        createdAt,
         dryRun: true,
         labId: plan.labId,
         ...(plan.title ? { labTitle: plan.title } : {}),
@@ -65,7 +64,6 @@ export async function runDryTerminalLab(args) {
             allowPaymentCredentials: policies?.allowPaymentCredentials ?? false,
             allowGitHubMutation: policies?.allowGitHubMutation ?? false,
         },
-        runId,
         source,
         verdict: judgment.verdict,
     });
@@ -85,10 +83,9 @@ export async function runDryTerminalLab(args) {
     const ok = resultOk({ judgment, execution, scorerFailures: [], policy });
     await finished.recordOutcome({ ok, execution });
     return {
-        schema: TERMINAL_PRODUCT_LAB_SCHEMA,
+        ...studyResultIdentity("terminal", plan.labId),
         ok,
         cwd,
-        labId: plan.labId,
         actor: plan.actor,
         product: product.name,
         dryRun: true,
@@ -99,7 +96,7 @@ export async function runDryTerminalLab(args) {
             ? {}
             : {
                 error: {
-                    code: "HUMANISH_TERMINAL_LAB_FAILED",
+                    code: "HUMANISH_TERMINAL_FAILED",
                     message: observer.error?.message ?? "Observer failed for the terminal-product lab run.",
                 },
             }),
@@ -118,9 +115,9 @@ async function prepareDryPersona(args) {
         .filter((value) => value.length >= 4);
     const evidenceMission = participantAssignment({ mission }, scrubLiterals(knownSecretValues)).mission;
     const terminalPersona = await resolveTerminalPersona({ plan, cwd, warnings });
-    // The composed prompt = mission + persona + public-surface manifest. Only the AUTHOR mission
+    // The composed prompt = mission + persona + public-surface manifest. Only the author mission
     // goes plaintext into evidence (it is public-safe committed lab text); the full composed prompt
-    // is recorded as a DIGEST (the safety contract's mission ruling).
+    // is recorded as a digest (the safety contract's mission ruling).
     const composedPrompt = composePrompt({
         mission,
         personaLine: terminalPersona.personaLine,
@@ -133,7 +130,7 @@ async function prepareDryPersona(args) {
 }
 /** The declared runtime provenance as a dry-run event; nothing is observed without a sandbox. */
 function runtimeDeclaredEvent(runtime, createdAt) {
-    const { version, model, reasoningEffort } = runtime;
+    const { version, model, modelSource, reasoningEffort } = runtime;
     return {
         id: "event-terminal-runtime-declared",
         at: createdAt,
@@ -141,12 +138,13 @@ function runtimeDeclaredEvent(runtime, createdAt) {
         type: "terminal-lab.runtime.declared",
         message: redactText(JSON.stringify(declaredRuntimeProvenance({
             ...(version === undefined ? {} : { version }),
-            ...(model === undefined ? {} : { model }),
+            model,
+            modelSource,
             ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
         }))),
     };
 }
-/** Compose the full prompt the agent would run. Bound to evidence by DIGEST only. */
+/** Compose the full prompt the agent would run. Bound to evidence by digest only. */
 export function composePrompt(args) {
     return [
         args.personaLine,

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

@@ -1,6 +1,6 @@
 /**
  * Does this environment declare a UTF-8 locale? The POSIX variables are checked in the order the C
- * library resolves them (LC_ALL overrides LC_CTYPE overrides LANG).
+ * library resolves them (`LC_ALL` overrides `LC_CTYPE` overrides `LANG`).
  *
  * Windows terminals declare none of these and are handled as UTF-8: modern Windows Terminal and
  * PowerShell render it, and the failure this guards against is a Unix locale that says C/POSIX.

package/dist/routes/terminal/encoding.js

@@ -1,18 +1,18 @@
 // Whether this terminal can render the characters we write to it.
 //
-// FOUND BY A PARTICIPANT, not by us (labs/tui-self-study.yaml): a computer-use participant sitting
+// A participant found this (labs/tui-self-study.yaml): a computer-use participant sitting
 // at a stock desktop ran `humanish` and read back `humanish ��� run realistic synthetic personas`.
 // The em dash is three bytes of UTF-8, and a terminal whose locale is not UTF-8 renders each byte
 // as a replacement glyph. Every ASCII character on the same screen was fine, which is exactly the
 // signature.
 //
-// The honest fix is not "stop using em dashes" — it is to ask what the terminal can render and mean
+// The fix is not "stop using em dashes". It is to ask what the terminal can render and mean
 // it. A surface that emits characters its own terminal cannot decode is not being expressive, it is
 // producing garbage that reads as a bug in the tool.
 const UTF8 = /utf-?8/i;
 /**
  * Does this environment declare a UTF-8 locale? The POSIX variables are checked in the order the C
- * library resolves them (LC_ALL overrides LC_CTYPE overrides LANG).
+ * library resolves them (`LC_ALL` overrides `LC_CTYPE` overrides `LANG`).
  *
  * Windows terminals declare none of these and are handled as UTF-8: modern Windows Terminal and
  * PowerShell render it, and the failure this guards against is a Unix locale that says C/POSIX.
@@ -23,7 +23,7 @@ export function terminalRendersUnicode(env = process.env) {
     const declared = env.LC_ALL ?? env.LC_CTYPE ?? env.LANG;
     if (declared === undefined || declared.trim().length === 0) {
         // Nothing declared at all. A bare login shell on a stock image lands here, and that is the
-        // case the participant hit — assume it cannot, because the failure is silent and ugly while
+        // case the participant hit. Assume it cannot, because the failure is silent and ugly while
         // the fallback is merely plainer.
         return false;
     }

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

@@ -3,10 +3,10 @@ import type { LabScenarioCaps } from "../../lab/types.js";
 import { type CostCategory } from "../../run/terminal-contract.js";
 import type { CostLine, NoSpendProof, TerminalCostLedger } from "./types.js";
 /**
- * Build the spend ledger from the captured session. THE NULL DISCIPLINE (issue #154):
+ * Build the spend ledger from the captured session. The null discipline:
  *   - 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).
+ *     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,
@@ -14,7 +14,7 @@ import type { CostLine, NoSpendProof, TerminalCostLedger } from "./types.js";
  */
 export declare function buildCostLedger(args: {
     tokenCostUsd?: number;
-    /** Measured token counts, when the run produced them but no rate could price them (#531). */
+    /** Measured token counts, when the run produced them but no rate could price them. */
     tokenUsage?: ActorTokenUsage;
     injectedLines?: Partial<Record<CostCategory, CostLine>>;
 }): TerminalCostLedger;
@@ -31,13 +31,13 @@ export declare function noSpendNotEstablished(maxUsd: number): string;
  * an all-null ledger for a proven $0.
  */
 export declare function describeMeasuredSpend(ledger: TerminalCostLedger, tokenUsage?: ActorTokenUsage): string;
-/** Derive the no-spend proof from the ledger. It is HONEST: it vouches for known-zero lines and
- *  explicitly lists the unmeasured (null) lines it cannot vouch for — never claiming zero on null. */
+/** Derive the no-spend proof from the ledger. It vouches for known-zero lines and
+ *  explicitly lists the unmeasured (null) lines it cannot vouch for. It never claims zero on null. */
 export declare function buildNoSpendProof(ledger: TerminalCostLedger, maxUsd: number | null, tokenUsage?: ActorTokenUsage): NoSpendProof;
 /**
- * Full caps enforcement (fail-closed, not advisory). Returns a structured violation when a KNOWN
+ * Fail-closed caps enforcement. Returns a structured violation when a known
  * (measured) spend line exceeds maxUsd, or a known billable-job count exceeds maxJobs. Unknowns
- * (`null`) NEVER trip the cap (we cannot claim a violation we did not measure) — but they also never
+ * (`null`) never trip the cap (we cannot claim a violation we did not measure), and they also never
  * grant a green pass: the no-spend proof reports them as unmeasured. maxMinutes is wall-clock and is
  * enforced separately (runWithWallClock); it is not a ledger-derived cap.
  */

package/dist/routes/terminal/ledger.js

@@ -2,10 +2,10 @@ import { describeTokenUsage } from "./token-usage.js";
 import { round6 } from "../../run/pricing.js";
 import { COST_CATEGORIES } from "../../run/terminal-contract.js";
 /**
- * Build the spend ledger from the captured session. THE NULL DISCIPLINE (issue #154):
+ * Build the spend ledger from the captured session. The null discipline:
  *   - 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).
+ *     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,
@@ -22,24 +22,24 @@ export function buildCostLedger(args) {
             ? {
                 // Tokens counted, no rate to price them. This stays `usd: null` because a guessed
                 // dollar figure would be worse than none, but the note carries the measured fact so a
-                // reader never mistakes "no charge recorded" for "nothing was consumed" (#531).
+                // reader never mistakes "no charge recorded" for "nothing was consumed".
                 usd: null,
                 source: "unpriced-token-usage",
-                note: `Provider spend UNPRICED: the run consumed ${describeTokenUsage(args.tokenUsage)}, ` +
-                    "but the terminal participant records the model as `codex` and src/run/pricing.ts carries no " +
-                    "rate for it, so no dollar figure is claimed. Tokens are a MEASURED fact here; the " +
-                    "price is the unknown. Recorded null (never guessed to 0).",
+                note: `Provider spend unpriced: the run consumed ${describeTokenUsage(args.tokenUsage)}, ` +
+                    "but the terminal participant records the model as `codex` and humanish has no rate " +
+                    "for it, so no dollar figure is given. The token count is measured; the price is " +
+                    "not known. Recorded as null, never guessed as 0.",
             }
             : {
                 usd: null,
                 source: "unmeasured",
-                note: "Provider spend NOT MEASURED: the actor trace carried no tokenUsage.costUsd this run. Recorded null (not guessed to 0).",
+                note: "Provider spend not measured: the actor trace carried no tokenUsage.costUsd in this run, so it is recorded as null and not guessed as 0.",
             };
     const unmeasured = (category) => ({
         usd: null,
         count: null,
         source: "unmeasured",
-        note: `${category} spend NOT MEASURED: core has no ${category}-spend signal for this run; an adapter may supply one through costProbe. Recorded null (never guessed to 0).`,
+        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.`,
     });
     const lines = {
         product: args.injectedLines?.product ?? unmeasured("product"),
@@ -47,7 +47,7 @@ export function buildCostLedger(args) {
         payment: args.injectedLines?.payment ?? unmeasured("payment"),
         provider: args.injectedLines?.provider ?? providerLine,
     };
-    // knownTotalUsd sums ONLY the non-null lines. A null line contributes NOTHING — it is never
+    // knownTotalUsd sums only the non-null lines. A null line contributes nothing and is never
     // coerced to 0 (that would let an unmeasured category masquerade as a measured zero).
     let knownTotalUsd = 0;
     let fullyMeasured = true;
@@ -98,8 +98,8 @@ export function describeMeasuredSpend(ledger, tokenUsage) {
         .filter((part) => part.length > 0)
         .join(" ");
 }
-/** Derive the no-spend proof from the ledger. It is HONEST: it vouches for known-zero lines and
- *  explicitly lists the unmeasured (null) lines it cannot vouch for — never claiming zero on null. */
+/** Derive the no-spend proof from the ledger. It vouches for known-zero lines and
+ *  explicitly lists the unmeasured (null) lines it cannot vouch for. It never claims zero on null. */
 export function buildNoSpendProof(ledger, maxUsd, tokenUsage) {
     const knownZeroLines = [];
     const knownNonZeroLines = [];
@@ -113,16 +113,16 @@ export function buildNoSpendProof(ledger, maxUsd, tokenUsage) {
         else
             knownNonZeroLines.push(category);
     }
-    // satisfied only when every KNOWN line is within the cap (for a no-spend run, maxUsd 0 => every
-    // known line must be exactly 0). Unmeasured lines do NOT make it satisfied — they are reported
-    // separately as the proof's honest blind spot.
+    // satisfied only when every known line is within the cap (for a no-spend run, maxUsd 0 => every
+    // known line must be exactly 0). Unmeasured lines never make it satisfied; they are reported
+    // separately as the proof's blind spot.
     const cap = maxUsd ?? 0;
     const satisfied = knownNonZeroLines.length === 0 && ledger.knownTotalUsd <= cap;
     const verdict = !satisfied
-        ? `No-spend proof NOT satisfied for maxUsd=${cap}: known spend total ${ledger.knownTotalUsd} USD${knownNonZeroLines.length > 0 ? ` (non-zero: ${knownNonZeroLines.join(", ")})` : ""}.`
+        ? `No-spend proof not satisfied for maxUsd=${cap}: known spend total ${ledger.knownTotalUsd} USD${knownNonZeroLines.length > 0 ? ` (non-zero: ${knownNonZeroLines.join(", ")})` : ""}.`
         : noSpendLineMeasured({ knownZeroLines, knownNonZeroLines })
             ? noSpendNotEstablished(cap)
-            : `No-spend proof SATISFIED for maxUsd=${cap} on the measured lines (known total ${ledger.knownTotalUsd} USD).`;
+            : `No-spend proof satisfied for maxUsd=${cap} on the measured lines (known total ${ledger.knownTotalUsd} USD).`;
     const statement = [verdict, describeMeasuredSpend(ledger, tokenUsage)]
         .filter((part) => part.length > 0)
         .join(" ");
@@ -138,9 +138,9 @@ export function buildNoSpendProof(ledger, maxUsd, tokenUsage) {
     };
 }
 /**
- * Full caps enforcement (fail-closed, not advisory). Returns a structured violation when a KNOWN
+ * Fail-closed caps enforcement. Returns a structured violation when a known
  * (measured) spend line exceeds maxUsd, or a known billable-job count exceeds maxJobs. Unknowns
- * (`null`) NEVER trip the cap (we cannot claim a violation we did not measure) — but they also never
+ * (`null`) never trip the cap (we cannot claim a violation we did not measure), and they also never
  * grant a green pass: the no-spend proof reports them as unmeasured. maxMinutes is wall-clock and is
  * enforced separately (runWithWallClock); it is not a ledger-derived cap.
  */
@@ -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: `Observed KNOWN spend ${ledger.knownTotalUsd} USD exceeds scenario.caps.maxUsd=${caps.maxUsd}${overLines.length > 0 ? ` (non-zero lines: ${overLines.join(", ")})` : ""}. The run fails closed: the cap is a fail-closed mechanism, not an advisory.`,
+            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.`,
         };
     }
     if (caps.maxJobs !== undefined) {
@@ -162,7 +162,7 @@ export function evaluateCapsAgainstLedger(ledger, caps) {
         if (knownJobs > caps.maxJobs) {
             return {
                 ok: false,
-                message: `Observed KNOWN billable-job count ${knownJobs} exceeds scenario.caps.maxJobs=${caps.maxJobs}. The run fails closed.`,
+                message: `Stopped: ${knownJobs} measured billable jobs passed scenario.caps.maxJobs=${caps.maxJobs}.`,
             };
         }
     }

package/dist/routes/terminal/live-finish.d.ts

@@ -2,7 +2,7 @@ import type { ActorPersonaRef } from "../../actors/contract.js";
 import type { RunBundle } from "../../run/bundle.js";
 import type { RunScope } from "../../run/run.js";
 import type { LiveSandboxInputs, LiveTerminalSandbox } from "./live-sandbox.js";
-import type { RunLiveTerminalSessionArgs, TerminalProductLabHooks, TerminalProductLabResult } from "./types.js";
+import type { RunLiveTerminalSessionArgs, TerminalProductLabResult } from "./types.js";
 type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
     ok: true;
 }>["run"];
@@ -11,7 +11,6 @@ export interface LiveFinishInputs {
     plan: RunLiveTerminalSessionArgs["plan"];
     input: RunLiveTerminalSessionArgs["input"];
     cwd: string;
-    hooks: TerminalProductLabHooks;
     sanitize: (text: string) => string;
     nowIso: () => string;
     knownSecretValues: string[];

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

@@ -3,7 +3,7 @@
 import { buildRunCostSummary } from "../../run/cost-summary.js";
 import { writeContainedOutputFile } from "../../run/contained-output.js";
 import { validatePreparedRunArtifactPaths, } from "../../run/paths.js";
-import { estimateActorCost } from "../../run/pricing.js";
+import { estimateAggregatedTurnCost } from "../../run/pricing.js";
 import { normalizeLocalActorTranscript, TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGERS_ARTIFACT, TERMINAL_TRANSCRIPT_ARTIFACT, } from "../../run/terminal-contract.js";
 import { applyAdapterExtensionSeam } from "./adapter.js";
 import { buildLiveTerminalProductBundle } from "./bundle.js";
@@ -22,10 +22,10 @@ function buildLiveTrace(inputs) {
     // chunks before any transcript/trace/event artifact is persisted. Check both each stream and
     // the combined event order that the transcript uses; either view can assemble a split value.
     scrubSplitKnownValues(terminalEvents, knownSecretValues, discardedPrefixes);
-    // Build the actor trace FIRST (the cost ledger reads its tokenUsage).
+    // Build the actor trace first (the cost ledger reads its tokenUsage).
     const normalizedTranscript = normalizeLocalActorTranscript(terminalEvents.map((e) => e.chunk).join(""));
-    // Parsed from the FULL stream, not the tail: usage records arrive once per turn and the tail
-    // would drop all but the last (#531).
+    // Parsed from the full stream: usage records arrive once per turn, and the tail
+    // would drop all but the last.
     const terminalTokenUsage = parseTerminalTokenUsage(normalizedTranscript);
     const trace = buildTerminalActorTrace({
         persona,
@@ -39,27 +39,30 @@ function buildLiveTrace(inputs) {
         terminalEvents,
         commandLog,
         transcriptTail: tailOf(normalizedTranscript),
+        participant: inputs.recorder.participantText.finish(),
         runtimeAuth: runtimeEnv.mode,
         runtime,
         ...(terminalTokenUsage === undefined ? {} : { tokenUsage: terminalTokenUsage }),
     });
-    // Codex tokens stay unpriced: the lane records its model as `codex`, which has no rate.
-    trace.estimatedCost = estimateActorCost(trace.tokenUsage, trace.provider);
+    // Priced from the model the route passed to Codex. turn.completed sums a turn's requests, so the
+    // estimate uses base rates and says so.
+    trace.estimatedCost = estimateAggregatedTurnCost(trace.tokenUsage, runtime.requestedModel);
     return { normalizedTranscript, trace };
 }
 async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
-    const { hooks, runtime, session } = inputs;
+    const { runtime, session } = inputs;
+    const costProbe = inputs.input.deps?.costProbe;
     const { caps } = inputs.plan;
     const { maxUsd } = caps;
     const runPaths = inputs.run.paths;
     const { recordLifecycle, lifecycle, commandLog, interventions, terminalEvents } = inputs.recorder;
     // --- 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
+    // 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
     // spend to exercise the fail-closed cap without a real billable run.
-    const injectedLines = hooks.costProbe?.(trace.tokenUsage?.costUsd === undefined ? {} : { tokenCostUsd: trace.tokenUsage.costUsd });
-    if (hooks.costProbe)
+    const injectedLines = costProbe?.(trace.tokenUsage?.costUsd === undefined ? {} : { tokenCostUsd: trace.tokenUsage.costUsd });
+    if (costProbe)
         await validatePreparedRunArtifactPaths(runPaths);
     const cost = buildCostLedger({
         ...(trace.tokenUsage?.costUsd === undefined ? {} : { tokenCostUsd: trace.tokenUsage.costUsd }),
@@ -68,15 +71,15 @@ async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
     });
     const noSpendProof = buildNoSpendProof(cost, maxUsd ?? null, trace.tokenUsage);
     const proofVerdict = !noSpendProof.satisfied
-        ? `No-spend proof NOT satisfied for maxUsd=${maxUsd ?? "null"}.`
+        ? `No-spend proof not satisfied for maxUsd=${maxUsd ?? "null"}.`
         : noSpendLineMeasured(noSpendProof)
             ? noSpendNotEstablished(maxUsd ?? 0)
             : `No-spend proof satisfied on the measured lines for maxUsd=${maxUsd ?? "null"}.`;
     const measuredSpend = describeMeasuredSpend(cost, trace.tokenUsage);
     recordLifecycle("terminal-lab.cost.measured", `Cost ledger: known total ${cost.knownTotalUsd} USD${cost.fullyMeasured ? " (fully measured)" : " (lower bound)"}.${measuredSpend.length > 0 ? ` ${measuredSpend}` : ""} ${proofVerdict}`);
-    // FULL caps enforcement (fail-closed, NOT advisory): if a KNOWN spend line exceeds maxUsd (or a
-    // known job count exceeds maxJobs), the run fails closed — never a green result. Unknowns (null)
-    // do NOT trip the cap (we cannot claim a violation we did not measure) but never grant a pass
+    // Fail-closed caps enforcement: if a known spend line exceeds maxUsd (or a
+    // known job count exceeds maxJobs), the run fails closed with no green result. Unknowns (null)
+    // never trip the cap (we cannot claim a violation we did not measure) but never grant a pass
     // either (the no-spend proof reports them as unmeasured). maxMinutes is already wall-clock-
     // enforced above. A blown cap is an execution failure: the agent's own status stays the
     // verdict, and the result's ok is false.
@@ -91,7 +94,7 @@ async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
         runtime,
         lifecycle,
         commandLog,
-        interventions, // ALWAYS present, ALWAYS empty while no assisted-input path ships.
+        interventions, // Always present, and always empty while no assisted-input path ships.
         cleanup: session.cleanup,
         cost,
         noSpendProof,
@@ -102,11 +105,11 @@ async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
 export async function finishLiveTerminalSession(inputs) {
     const { normalizedTranscript, trace } = buildLiveTrace(inputs);
     const { cost, noSpendProof, capFailure, ledgers } = await settleLiveLedgers(inputs, trace, normalizedTranscript);
-    const { plan, input, cwd, hooks, sanitize } = inputs;
+    const { plan, input, cwd, sanitize } = inputs;
     const { product, caps } = plan;
     const policies = plan.residual.policies;
     const { runtimeEnv, persona, mission, run, source, warnings, session } = inputs;
-    const { runId, createdAt, paths: runPaths } = run;
+    const { runId, paths: runPaths } = run;
     // One judgment, after a blown cap has overridden the session: the bundle's verdict (and so
     // status.json's outcome) and the result's ok both read it.
     const participant = terminalParticipantFacts(trace, session.error);
@@ -120,9 +123,8 @@ export async function finishLiveTerminalSession(inputs) {
         ...(desktops === undefined ? {} : { desktops }),
     });
     const bundle = buildLiveTerminalProductBundle({
-        ...(plan.lab === undefined ? {} : { lab: plan.lab }),
+        run,
         actorId: plan.actor,
-        createdAt,
         labId: plan.labId,
         ...(plan.title ? { labTitle: plan.title } : {}),
         mission: sanitize(mission),
@@ -138,7 +140,6 @@ export async function finishLiveTerminalSession(inputs) {
             allowPaymentCredentials: policies?.allowPaymentCredentials ?? false,
             allowGitHubMutation: policies?.allowGitHubMutation ?? false,
         },
-        runId,
         source,
         trace,
         ledgers,
@@ -154,7 +155,7 @@ export async function finishLiveTerminalSession(inputs) {
     // through foldScorerFailures below. Adapter payloads pass the same scrub and redaction as the
     // rest of the bundle, and the bundle verifier checks them downstream.
     const scorer = await applyAdapterExtensionSeam({
-        hooks,
+        scorer: input.scorer,
         bundle,
         trace,
         ledgers,

package/dist/routes/terminal/live-sandbox.d.ts

@@ -4,7 +4,8 @@ import type { RunScope } from "../../run/run.js";
 import type { buildRuntimeAuth, buildSandboxMetadata } from "./credentials.js";
 import type { createTerminalRecorder } from "./recorder.js";
 import { type declaredRuntimeProvenance } from "./runtime.js";
-import { type LiveTerminalPlan, type TerminalLedgers, type TerminalProductLabHooks } from "./types.js";
+import { type LiveTerminalPlan, type TerminalLedgers } from "./types.js";
+import type { LabDeps } from "../../lab/lab-deps.js";
 type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
     ok: true;
 }>["run"];
@@ -12,7 +13,7 @@ type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
 export interface LiveSandboxInputs {
     plan: LiveTerminalPlan;
     cwd: string;
-    hooks: TerminalProductLabHooks;
+    deps: LabDeps;
     now: () => number;
     nowIso: () => string;
     sanitize: (text: string) => string;