humanish 0.106.1 → 0.107.0

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

@@ -1,27 +1,27 @@
 import type { ActorTrace } from "../../actors/contract.js";
 import { type RunBundle, type RunScorerProvenance } from "../../run/bundle.js";
 import { type ScorerOutcome } from "../../lab/adapter-extension.js";
-import type { TerminalLedgers, TerminalProductLabHooks } from "./types.js";
+import type { TerminalLedgers, TerminalScorer } from "./types.js";
 /**
  * Run the layer-6 product-adapter extension seam (issue #154 acceptance #8) over the assembled
- * evidence and attach its results to the bundle IN PLACE — without core knowing any product noun.
+ * evidence and attach its results to the bundle in place, without core knowing any product noun.
  * The review is not touched here: the returned failures are folded into it by the caller.
  *
  *  - `score`: when present, the returned namespaced `RunAdapterScore` lands on `bundle.adapterScore`.
- *    For a LIBRARY caller (no `scorerProvenance`), the adapter score is additive and never a
- *    failure. For a CONFIG-DECLARED scorer (#316; `scorerProvenance` present), a status:"fail" is a
- *    failure (the keystone lane is the product's own definition of pass/fail), and so is a scorer
- *    that THROWS or returns a malformed value, so a crashed declared gate is never a silent green.
+ *    For a library caller (no `scorerProvenance`), the adapter score is additive and never a
+ *    failure. For a config-declared scorer (#316; `scorerProvenance` present), a status:"fail" is a
+ *    failure (the keystone route is the product's own definition of pass/fail), and so is a scorer
+ *    that throws or returns a malformed value, so a crashed declared gate is never a silent green.
  *  - `deriveFeedback`: when present, the returned candidates are appended to
  *    `bundle.feedbackCandidates`; each carries its own namespaced `adapter` product-noun block.
  *
  * Defense in depth: the adapter's namespaced payloads are re-serialized through the run's scrub +
- * redact, and any candidate / score that does not satisfy core's exported shape is DROPPED with a
+ * redact, and any candidate / score that does not satisfy core's exported shape is dropped with a
  * warning (a malformed adapter output never poisons a verifiable bundle). The bundle verifier
  * re-checks the surviving shapes downstream, so the seam stays fail-closed end to end.
  */
 export declare function applyAdapterExtensionSeam(args: {
-    hooks: TerminalProductLabHooks;
+    scorer: TerminalScorer | undefined;
     bundle: RunBundle;
     trace: ActorTrace;
     ledgers: TerminalLedgers;

package/dist/routes/terminal/adapter.js

@@ -1,28 +1,27 @@
-import path from "node:path";
 import {} from "../../run/bundle.js";
-import { isFeedbackIdempotencyKey } from "../../run/feedback-shape.js";
-import { adapterScoreFailureMessage, declaredScorerThrew, DECLARED_SCORER_MALFORMED, frozenBundleView, } from "../../lab/adapter-extension.js";
+import { isRunAdapterScore } from "../../run/bundle-shape.js";
+import { adapterScoreFailureMessage, declaredScorerThrew, DECLARED_SCORER_MALFORMED, frozenBundleView, isAdapterFeedbackCandidate, } from "../../lab/adapter-extension.js";
 /**
  * Run the layer-6 product-adapter extension seam (issue #154 acceptance #8) over the assembled
- * evidence and attach its results to the bundle IN PLACE — without core knowing any product noun.
+ * evidence and attach its results to the bundle in place, without core knowing any product noun.
  * The review is not touched here: the returned failures are folded into it by the caller.
  *
  *  - `score`: when present, the returned namespaced `RunAdapterScore` lands on `bundle.adapterScore`.
- *    For a LIBRARY caller (no `scorerProvenance`), the adapter score is additive and never a
- *    failure. For a CONFIG-DECLARED scorer (#316; `scorerProvenance` present), a status:"fail" is a
- *    failure (the keystone lane is the product's own definition of pass/fail), and so is a scorer
- *    that THROWS or returns a malformed value, so a crashed declared gate is never a silent green.
+ *    For a library caller (no `scorerProvenance`), the adapter score is additive and never a
+ *    failure. For a config-declared scorer (#316; `scorerProvenance` present), a status:"fail" is a
+ *    failure (the keystone route is the product's own definition of pass/fail), and so is a scorer
+ *    that throws or returns a malformed value, so a crashed declared gate is never a silent green.
  *  - `deriveFeedback`: when present, the returned candidates are appended to
  *    `bundle.feedbackCandidates`; each carries its own namespaced `adapter` product-noun block.
  *
  * Defense in depth: the adapter's namespaced payloads are re-serialized through the run's scrub +
- * redact, and any candidate / score that does not satisfy core's exported shape is DROPPED with a
+ * redact, and any candidate / score that does not satisfy core's exported shape is dropped with a
  * warning (a malformed adapter output never poisons a verifiable bundle). The bundle verifier
  * re-checks the surviving shapes downstream, so the seam stays fail-closed end to end.
  */
 export async function applyAdapterExtensionSeam(args) {
-    const { hooks, bundle, trace, ledgers, transcript, product, labId, runId, sanitize, warnings, scorerProvenance, } = args;
-    if (!hooks.score && !hooks.deriveFeedback)
+    const { scorer, bundle, trace, ledgers, transcript, product, labId, runId, sanitize, warnings, scorerProvenance, } = args;
+    if (!scorer?.score && !scorer?.deriveFeedback)
         return { failures: [] };
     const declared = scorerProvenance !== undefined;
     // Record the loaded scorer's identity regardless of hook outcome (a throwing/invalid scorer was
@@ -31,7 +30,7 @@ export async function applyAdapterExtensionSeam(args) {
         bundle.scorerProvenance = scorerProvenance;
     // The scorer sees a READ-ONLY view of the bundle so it cannot mutate noSpend/cost/review in place to
     // launder a verdict (a tamper attempt throws and is caught as a hook failure below). The seam stamps
-    // the REAL bundle. The transcript is the SAME normalized, source-scrubbed text the run persists as
+    // the real bundle. The transcript is the same normalized, source-scrubbed text the run persists as
     // terminal-transcript.txt — no new exposure beyond what disk already holds (#341).
     const ctx = {
         bundle: frozenBundleView(bundle),
@@ -43,21 +42,22 @@ export async function applyAdapterExtensionSeam(args) {
         runId,
     };
     // Best-effort re-scrub of the adapter payload: round-trip the whole JSON through the run's denylist
-    // sanitizer. This is NOT containment — it catches recognizable secret shapes and known local paths,
-    // but not encoded/split/custom secrets, DB passwords, PII, or abs paths outside the denylist. A
+    // sanitizer. It is a scrub with no containment: it catches recognizable secret shapes and known
+    // local paths, and misses encoded/split/custom secrets, DB passwords, PII, or abs paths outside
+    // the denylist. A
     // payload from config-declared code is acceptable only because the trust boundary (the party who
     // declares the scorer runs the lab) already permits direct exfiltration; the re-scrub is
     // defense-in-depth, not a wall.
     const scrubValue = (value) => JSON.parse(sanitize(JSON.stringify(value)));
-    // Set for a DECLARED scorer that fails to render a PASS verdict (status:"fail", malformed, or throw).
-    // The caller folds it into the review and fails the run RESULT on it — a declared gate that cannot
+    // Set for a declared scorer that fails to render a pass verdict (status:"fail", malformed, or throw).
+    // The caller folds it into the review and fails the run result on it: a declared gate that cannot
     // pass is a fail, never a silent green. Empty for a library caller and for a passing scorer.
     const failures = [];
-    if (hooks.score) {
+    if (scorer?.score) {
         try {
-            const score = await hooks.score(ctx);
+            const score = await scorer.score(ctx);
             const cleaned = scrubValue(score);
-            if (isAdapterScoreShape(cleaned)) {
+            if (isRunAdapterScore(cleaned)) {
                 bundle.adapterScore = cleaned;
                 // A CONFIG-DECLARED terminal scorer owns the product verdict: a status:"fail" fails the
                 // review and the run result. A library caller keeps the additive no-fail behavior.
@@ -66,136 +66,39 @@ export async function applyAdapterExtensionSeam(args) {
                     failures.push(message);
             }
             else {
-                warnings.push("terminalHooks.score returned a value that is not a well-formed humanish.adapter-score.v1 (non-empty namespace + status + numeric score + summary); dropped so the bundle stays verifiable.");
-                // A declared gate that returned a MALFORMED value never rendered a verdict — fail closed.
+                warnings.push("scorer.score returned a value that is not a well-formed humanish.adapter-score.v1 (non-empty namespace + status + numeric score + summary); dropped so the bundle stays verifiable.");
+                // A declared gate that returned a malformed value never rendered a verdict, so it fails closed.
                 if (declared)
                     failures.push(DECLARED_SCORER_MALFORMED);
             }
         }
         catch (error) {
             const detail = sanitize(error instanceof Error ? error.message : String(error));
-            warnings.push(`terminalHooks.score threw (${detail}); dropped so the bundle stays verifiable.`);
-            // A crashed DECLARED gate must be visible, never a silent pass: it fails the review and the
+            warnings.push(`scorer.score threw (${detail}); dropped so the bundle stays verifiable.`);
+            // A crashed declared gate must be visible, never a silent pass: it fails the review and the
             // run result.
             if (declared)
                 failures.push(declaredScorerThrew(detail));
         }
     }
-    if (hooks.deriveFeedback) {
+    if (scorer?.deriveFeedback) {
         try {
-            const candidates = await hooks.deriveFeedback(ctx);
+            const candidates = await scorer.deriveFeedback(ctx);
             const accepted = [];
             for (const candidate of Array.isArray(candidates) ? candidates : []) {
                 const cleaned = scrubValue(candidate);
-                if (isAdapterFeedbackCandidateShape(cleaned))
+                if (isAdapterFeedbackCandidate(cleaned))
                     accepted.push(cleaned);
                 else
-                    warnings.push("terminalHooks.deriveFeedback returned a candidate that is not a well-formed humanish.feedback-candidate.v1 (or its adapter block lacked a non-empty namespace + data record); dropped so the bundle stays verifiable.");
+                    warnings.push("scorer.deriveFeedback returned a candidate that is not a well-formed humanish.feedback-candidate.v1 (or its adapter block lacked a non-empty namespace + data record); dropped so the bundle stays verifiable.");
             }
             if (accepted.length > 0) {
                 bundle.feedbackCandidates = [...bundle.feedbackCandidates, ...accepted];
             }
         }
         catch (error) {
-            warnings.push(`terminalHooks.deriveFeedback threw (${sanitize(error instanceof Error ? error.message : String(error))}); dropped so the bundle stays verifiable.`);
+            warnings.push(`scorer.deriveFeedback threw (${sanitize(error instanceof Error ? error.message : String(error))}); dropped so the bundle stays verifiable.`);
         }
     }
     return { failures };
 }
-/** Structural guard for an adapter-returned RunAdapterScore (mirrors run/bundle-shape.ts isRunAdapterScore, kept
- *  local so the lane fails closed at the seam BEFORE the bundle verifier re-checks it). */
-function isAdapterScoreShape(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        value.schema === "humanish.adapter-score.v1" &&
-        typeof value.namespace === "string" &&
-        value.namespace.trim().length > 0 &&
-        ["pass", "partial", "fail"].includes(value.status) &&
-        typeof value.score === "number" &&
-        Number.isFinite(value.score) &&
-        typeof value.summary === "string");
-}
-/** Structural guard for an adapter-returned feedback candidate. This mirrors run/feedback-shape.ts's full
- * isRunFeedbackCandidate predicate, including its local evidence-path contract, so a malformed
- * candidate is dropped at the extension seam instead of poisoning the persisted bundle. */
-function isAdapterFeedbackCandidateShape(value) {
-    return (isAdapterRecord(value) &&
-        value.schema === "humanish.feedback-candidate.v1" &&
-        typeof value.id === "string" &&
-        typeof value.run_id === "string" &&
-        (typeof value.stream_id === "string" || value.stream_id === undefined) &&
-        typeof value.adapter_id === "string" &&
-        typeof value.scenario_id === "string" &&
-        typeof value.persona_id === "string" &&
-        isAdapterFeedbackActor(value.actor) &&
-        isAdapterFeedbackSubstrate(value.substrate) &&
-        isAdapterFeedbackFailureOwner(value.failure_owner) &&
-        typeof value.summary === "string" &&
-        value.summary.trim().length > 0 &&
-        typeof value.expected === "string" &&
-        typeof value.actual === "string" &&
-        Array.isArray(value.evidence) &&
-        value.evidence.every(isAdapterFeedbackEvidence) &&
-        isAdapterRecord(value.redaction) &&
-        value.redaction.status === "passed" &&
-        typeof value.redaction.notes === "string" &&
-        isFeedbackIdempotencyKey(value.idempotency_key) &&
-        isAdapterFeedbackNextState(value.proposed_next_state) &&
-        Array.isArray(value.acceptance_proof) &&
-        value.acceptance_proof.every((item) => typeof item === "string") &&
-        (value.adapter === undefined ||
-            (isAdapterRecord(value.adapter) &&
-                typeof value.adapter.namespace === "string" &&
-                value.adapter.namespace.trim().length > 0 &&
-                isAdapterRecord(value.adapter.data))));
-}
-function isAdapterFeedbackEvidence(value) {
-    return (isAdapterRecord(value) &&
-        typeof value.path === "string" &&
-        value.path.length > 0 &&
-        !path.isAbsolute(value.path) &&
-        !value.path.includes("://") &&
-        !value.path.includes("..") &&
-        (value.kind === "review" ||
-            value.kind === "state" ||
-            value.kind === "log" ||
-            value.kind === "trace" ||
-            value.kind === "screenshot" ||
-            value.kind === "filesystem") &&
-        typeof value.note === "string");
-}
-function isAdapterFeedbackActor(value) {
-    return (value === "codex-tui" ||
-        value === "codex-exec" ||
-        value === "codex-app-server" ||
-        value === "computer-use" ||
-        value === "synthetic-dry-run" ||
-        value === "unknown");
-}
-function isAdapterFeedbackSubstrate(value) {
-    return (value === "e2b-desktop" ||
-        value === "local-desktop" ||
-        value === "e2b-terminal" ||
-        value === "local-filesystem" ||
-        value === "codex-app-server" ||
-        value === "unknown");
-}
-function isAdapterFeedbackFailureOwner(value) {
-    return (value === "harness" ||
-        value === "target-app" ||
-        value === "actor" ||
-        value === "environment" ||
-        value === "unknown");
-}
-function isAdapterFeedbackNextState(value) {
-    return (value === "watch" ||
-        value === "adapter-hardening" ||
-        value === "target-app-setup" ||
-        value === "actor-auth" ||
-        value === "setup-quality-review" ||
-        value === "study-quality-review");
-}
-function isAdapterRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

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

@@ -1,21 +1,19 @@
 import type { ActorPersonaRef, ActorTrace } from "../../actors/contract.js";
-import { type RunLabProvenance } from "../../run/status.js";
 import type { LabScenarioCaps, LabRuntimeAuth } from "../../lab/types.js";
-import { type RunBundle, type RunCostSummary } from "../../run/bundle.js";
+import { type RunBundle, type RunCostSummary, type BundleRun } from "../../run/bundle.js";
 import type { Verdict } from "../../run/judge.js";
 import type { TerminalLedgers } from "./types.js";
 /**
  * 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 declare function buildTerminalProductBundle(args: {
-    /** Lab provenance for the bundle\'s own `lab` field (#455). */
-    lab?: RunLabProvenance;
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    run: BundleRun;
     actorId: string;
-    createdAt: string;
     dryRun: boolean;
     labId: string;
     labTitle?: string;
@@ -32,23 +30,21 @@ export declare function buildTerminalProductBundle(args: {
         allowPaymentCredentials: boolean;
         allowGitHubMutation: boolean;
     };
-    runId: string;
     source: RunBundle["source"];
     /** The run's judgment verdict (judgeTerminal): a contract for a dry run. */
     verdict: Verdict;
 }): RunBundle;
 /**
- * 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
  * mode==="live") enforces the ledgers + proven cleanup + interventions-present over this bundle.
  */
 export declare function buildLiveTerminalProductBundle(args: {
-    /** Lab provenance for the bundle\'s own `lab` field (#455). */
-    lab?: RunLabProvenance;
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    run: BundleRun;
     actorId: string;
-    createdAt: string;
     labId: string;
     labTitle?: string;
     mission: string;
@@ -64,7 +60,6 @@ export declare function buildLiveTerminalProductBundle(args: {
         allowPaymentCredentials: boolean;
         allowGitHubMutation: boolean;
     };
-    runId: string;
     source: RunBundle["source"];
     trace: ActorTrace;
     ledgers: TerminalLedgers;

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;