humanish 0.106.0 → 0.107.0

package/dist/routes/terminal/bundle.js

@@ -1,4 +1,3 @@
-import {} from "../../run/status.js";
 import { redactText } from "../../evidence/redaction.js";
 import { participantAssignment } from "../../lab/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
@@ -9,21 +8,21 @@ import { describeMeasuredSpend, noSpendLineMeasured, noSpendNotEstablished } fro
 /**
  * Project the terminal-product lab run into a humanish.run-bundle.v1 (no schema change — a new
  * producer only). DRY-RUN: a contract bundle. The terminal stream is a contract placeholder
- * (stdin disabled, no captured tail — honest: nothing ran), the subject is declared UNPINNED, and
+ * (stdin disabled, no captured tail, because nothing ran), the subject is declared unpinned, and
  * the caps/policies/runtime-auth declarations are recorded without pretending that live ledgers
  * exist. The shipped live builder fills the same evidence contract. Exported for tests.
  */
 export function buildTerminalProductBundle(args) {
     const reason = "Contract bundle only: dry-run declared the terminal-product study contract without creating an E2B sandbox, injecting any key, or spending. This run did not execute an agent or prove live behavior.";
-    // The terminal stream is a CONTRACT PLACEHOLDER on the dry-run path: stdin is disabled and no
-    // exec output was captured, so the tail is empty and transport stays "snapshot" — NOT "pty"
+    // The terminal stream is a contract placeholder on the dry-run path: stdin is disabled and no
+    // exec output was captured, so the tail is empty and transport stays "snapshot", never "pty"
     // (captured non-interactive exec output is never an interactive PTY; invariant 6 + the PTY
     // ruling). The shipped live builder fills terminal.tail from redacted exec-stream capture.
     const { simulation, stream } = terminalParticipant(args, {
         status: "contract_proof_only",
         reason,
         summary: `Contract participant for the terminal agent (${args.actorId}) studying ${args.productName} from public surfaces.`,
-        updatedAt: args.createdAt,
+        updatedAt: args.run.createdAt,
         stdin: args.stdin,
         tail: "",
         artifacts: [
@@ -36,40 +35,40 @@ export function buildTerminalProductBundle(args) {
     const events = [
         {
             id: "event-000-created",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.run.created",
             message: `Created terminal-product lab run for ${args.labId} (actor ${args.actorId}, product ${args.productName}).`,
         },
         participantEvent(TERMINAL_IDS, {
             id: "event-001-subject",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.subject.declared",
-            // Invariant 5: provenance recorded or its absence DECLARED. The agent drives PUBLIC surfaces,
-            // not a clone, so the subject provenance is explicitly UNPINNED; evidence binds to the
+            // Invariant 5: provenance recorded or its absence declared. The agent drives public surfaces
+            // and nothing is cloned, so the subject provenance is explicitly unpinned; evidence binds to the
             // composed-prompt digest. Public surfaces are recorded (they are public by declaration).
             message: `Subject product declared: ${args.productName}; public surfaces: ${args.publicSurfaces.join(", ")}. The lab did not provision/clone the product — subject provenance is UNPINNED (a public-surface study cannot be commit-pinned); evidence binds to the composed-prompt digest ${args.persona.promptDigest}.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-002-credentials",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.credentials.declared",
-            // Names-only evidence (invariant 1): the runtime-auth CHANNEL is declared; no value is ever
+            // Names-only evidence (invariant 1): 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}.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-003-caps",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.caps.declared",
             message: `Spend/job/time caps: ${capsText}. A live run never exercises the runtime key without a fail-closed cap; its no-spend proof is derived from the persisted cost ledger. This dry-run spends $0 by mechanism.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-004-contract",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.contract.ready",
             message: "Dry-run contract 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.",
@@ -85,10 +84,9 @@ export function buildTerminalProductBundle(args) {
         ],
     };
     return terminalRunBundle(args, {
-        mode: args.dryRun ? "dry-run" : "live",
         lifecycle: [
             {
-                at: args.createdAt,
+                at: args.run.createdAt,
                 event: "terminal-lab.run.created",
                 message: `Created terminal-product lab run with one in-sandbox agent participant (actor ${args.actorId}, product ${args.productName}).`,
             },
@@ -101,7 +99,7 @@ export function buildTerminalProductBundle(args) {
     });
 }
 /**
- * Build the LIVE terminal-product run bundle (mode "live") from the captured session: the actor
+ * Build the live terminal-product run bundle (mode "live") from the captured session: the actor
  * trace seam (stream.actor = trace), the substrate-lifecycle events, the terminal stream with the
  * redacted transcript tail, and references to the written evidence artifacts (terminal event
  * stream, transcript, ledgers, actor trace). verifyRun's terminal-product check (gated on
@@ -115,10 +113,10 @@ export function buildLiveTerminalProductBundle(args) {
             : args.trace.status === "timed_out"
                 ? "timed_out"
                 : "failed";
-    const messageItem = args.trace.items.find((item) => item.kind === "message");
-    const tail = (messageItem?.text ?? args.trace.reason).slice(0, 2000);
+    const commandItem = args.trace.items.find((item) => item.kind === "command");
+    const tail = (commandItem?.command?.outputTail || args.trace.reason).slice(0, 2000);
     // transport "snapshot": the persisted tail is a redacted snapshot of the captured exec output,
-    // NOT an interactive PTY (stdin disabled). The actor trace seam carries the structured evidence.
+    // never an interactive PTY (stdin disabled). The actor trace seam carries the structured evidence.
     const { simulation, stream } = terminalParticipant(args, {
         status: recordStatus,
         reason: args.sessionReason,
@@ -149,9 +147,9 @@ export function buildLiveTerminalProductBundle(args) {
         type: record.event,
         message: record.message,
     }));
-    // Surface the no-spend proof as a first-class bundle event so the Observer/review can SHOW it.
-    // It is DERIVED from the cost ledger (never asserted): it lists the known-zero lines it vouches
-    // for AND the unmeasured (null) lines it explicitly cannot vouch for.
+    // Surface the no-spend proof as a first-class bundle event so the Observer/review can show it.
+    // It is derived from the cost ledger (never asserted): it lists the known-zero lines it vouches
+    // for and the unmeasured (null) lines it explicitly cannot vouch for.
     const noSpend = args.ledgers.noSpendProof;
     lifecycleEvents.push(participantEvent(TERMINAL_IDS, {
         id: "event-cost-no-spend-proof",
@@ -169,7 +167,7 @@ export function buildLiveTerminalProductBundle(args) {
                 ? []
                 : [`Agent session ended ${args.trace.status}: ${args.sessionReason}`]),
             ...(args.capFailure === undefined ? [] : [args.capFailure]),
-            // Honesty gap: the no-spend proof always declares which spend lines it could NOT measure, so a
+            // Honesty gap: the no-spend proof always declares which spend lines it could not measure, so a
             // green run never silently over-claims a fully-proven $0.
             ...(noSpend.unmeasuredLines.length > 0
                 ? [
@@ -179,7 +177,6 @@ export function buildLiveTerminalProductBundle(args) {
         ],
     };
     return terminalRunBundle(args, {
-        mode: "live",
         lifecycle: args.ledgers.lifecycle.map((record) => ({
             at: record.at,
             event: record.event,
@@ -206,7 +203,7 @@ function terminalParticipant(args, session) {
         progress: 100,
         currentStep: session.reason,
         summary: session.summary,
-        startedAt: args.createdAt,
+        startedAt: args.run.createdAt,
         updatedAt: session.updatedAt,
     });
     const stream = participantStream(TERMINAL_IDS, {
@@ -232,17 +229,10 @@ function terminalParticipant(args, session) {
     });
     return { simulation, stream };
 }
-/** The run bundle around the lane: the fields both builders fill the same way. */
+/** The run bundle around the terminal session: the fields both builders fill the same way. */
 function terminalRunBundle(args, parts) {
     return {
-        ...bundleHead({
-            runId: args.runId,
-            mode: parts.mode,
-            participants: 1,
-            createdAt: args.createdAt,
-            ...(args.lab === undefined ? {} : { lab: args.lab }),
-            source: args.source,
-        }),
+        ...bundleHead(args.run, { participants: 1, source: args.source }),
         persona: {
             id: args.persona.id,
             name: `Autonomous terminal agent (${args.persona.id})`,

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

@@ -22,8 +22,8 @@ export declare function buildRuntimeAuth(args: {
     message: string;
 };
 /**
- * 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 (safety contract item 6). 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.
  */

package/dist/routes/terminal/credentials.js

@@ -7,22 +7,22 @@ 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
     // 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 (safety contract item 4): 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).
@@ -42,9 +42,9 @@ export function buildRuntimeAuth(args) {
         };
     }
     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 (safety contract item 6). 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.
  */

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

@@ -17,11 +17,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 +30,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 +45,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 +63,6 @@ export async function runDryTerminalLab(args) {
             allowPaymentCredentials: policies?.allowPaymentCredentials ?? false,
             allowGitHubMutation: policies?.allowGitHubMutation ?? false,
         },
-        runId,
         source,
         verdict: judgment.verdict,
     });
@@ -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,6 +1,6 @@
 // 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
@@ -12,7 +12,7 @@
 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.

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 (issue #154):
  *   - 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,
@@ -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
+/** 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 — never claiming 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 (issue #154):
  *   - 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,
@@ -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,7 +98,7 @@ 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
+/** 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 — never claiming zero on null. */
 export function buildNoSpendProof(ledger, maxUsd, tokenUsage) {
     const knownZeroLines = [];
@@ -113,8 +113,8 @@ 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
+    // 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 honest blind spot.
     const cap = maxUsd ?? 0;
     const satisfied = knownNonZeroLines.length === 0 && ledger.knownTotalUsd <= cap;
@@ -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.
  */

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,9 +22,9 @@ 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
+    // Parsed from the full stream: usage records arrive once per turn, and the tail
     // would drop all but the last (#531).
     const terminalTokenUsage = parseTerminalTokenUsage(normalizedTranscript);
     const trace = buildTerminalActorTrace({
@@ -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 }),
@@ -74,9 +77,9 @@ async function settleLiveLedgers(inputs, trace, normalizedTranscript) {
             : `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
+    // Fail-closed caps enforcement: 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
+    // 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;
@@ -47,6 +48,7 @@ export declare class LiveTerminalSandbox {
     private module;
     private allocation;
     private startupCleanup;
+    private startupCleanupDetail;
     private createdAtMs;
     private tornDownAtMs;
     private resources;