humanish 0.107.0 → 0.108.0

package/dist/routes/terminal/adapter.js

@@ -2,13 +2,13 @@ import {} from "../../run/bundle.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
+ * Run the product-adapter extension seam over the assembled
  * 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. For a config-declared scorer (`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
@@ -28,10 +28,10 @@ export async function applyAdapterExtensionSeam(args) {
     // still loaded and attempted).
     if (scorerProvenance)
         bundle.scorerProvenance = scorerProvenance;
-    // The scorer sees a READ-ONLY view of the bundle so it cannot mutate noSpend/cost/review in place to
+    // 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
-    // terminal-transcript.txt — no new exposure beyond what disk already holds (#341).
+    // terminal-transcript.txt, so the scorer sees nothing beyond what disk already holds.
     const ctx = {
         bundle: frozenBundleView(bundle),
         trace,
@@ -59,7 +59,7 @@ export async function applyAdapterExtensionSeam(args) {
             const cleaned = scrubValue(score);
             if (isRunAdapterScore(cleaned)) {
                 bundle.adapterScore = cleaned;
-                // A CONFIG-DECLARED terminal scorer owns the product verdict: a status:"fail" fails the
+                // 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.
                 const message = declared ? adapterScoreFailureMessage(bundle) : undefined;
                 if (message !== undefined)

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

@@ -1,11 +1,11 @@
 import type { ActorPersonaRef, ActorTrace } from "../../actors/contract.js";
 import type { LabScenarioCaps, LabRuntimeAuth } from "../../lab/types.js";
 import { type RunBundle, type RunCostSummary, type BundleRun } from "../../run/bundle.js";
-import type { Verdict } from "../../run/judge.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
+ * 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, 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.

package/dist/routes/terminal/bundle.js

@@ -1,27 +1,28 @@
 import { redactText } from "../../evidence/redaction.js";
 import { participantAssignment } from "../../lab/participant-assignment.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
+import { verdictText } from "../../run/judge.js";
 import {} from "../../run/streams.js";
 import { participantEvent, participantIds, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { TERMINAL_EVENTS_ARTIFACT, TERMINAL_LEDGERS_ARTIFACT, TERMINAL_TRANSCRIPT_ARTIFACT, } from "../../run/terminal-contract.js";
 import { describeMeasuredSpend, noSpendLineMeasured, noSpendNotEstablished } from "./ledger.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
+ * 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, 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.";
+    const reason = "Dry run: the terminal-product study was declared 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", 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.
+    // (captured non-interactive exec output is never an interactive PTY). 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.`,
+        summary: `Dry-run participant for the terminal agent (${args.actorId}) studying ${args.productName} from public surfaces.`,
         updatedAt: args.run.createdAt,
         stdin: args.stdin,
         tail: "",
@@ -45,17 +46,17 @@ export function buildTerminalProductBundle(args) {
             at: args.run.createdAt,
             level: "info",
             type: "terminal-lab.subject.declared",
-            // Invariant 5: provenance recorded or its absence declared. The agent drives public surfaces
+            // Provenance is 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}.`,
+            message: `Subject product declared: ${args.productName}; public surfaces: ${args.publicSurfaces.join(", ")}. humanish did not provision or clone the product, so its provenance is unpinned: a study of public pages has no commit to pin. The evidence is tied to the prompt digest ${args.persona.promptDigest}.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-002-credentials",
             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: 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}.`,
         }),
@@ -64,14 +65,14 @@ export function buildTerminalProductBundle(args) {
             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.`,
+            message: `Spend, job and time caps: ${capsText}. A live run uses the runtime key only while a cap is in force, and derives its no-spend proof from the recorded cost ledger. This dry run spends $0: it makes no model request.`,
         }),
         participantEvent(TERMINAL_IDS, {
             id: "event-004-contract",
             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.",
+            message: "Dry-run bundle ready. Switch scenario.mode to live with the required runtime auth and caps to exercise the in-sandbox agent route, captured exec stream, and declared runtime-auth placement.",
         }),
     ];
     const review = {
@@ -79,7 +80,7 @@ export function buildTerminalProductBundle(args) {
         verdict: args.verdict,
         summary: reason,
         gaps: [
-            "This dry-run did not execute the live in-sandbox agent route; it proves contract shape only, not live behavior, scale, or adoption.",
+            "This dry run did not execute the live in-sandbox agent route; it checks the evidence shape only, not live behavior, scale, or adoption.",
             "No exec-stream, transcript, substrate, cost, or cleanup artifacts were produced because no live session ran; live verification requires those artifacts.",
         ],
     };
@@ -94,7 +95,7 @@ export function buildTerminalProductBundle(args) {
         simulation,
         stream,
         events,
-        redactionNotes: "Dry-run contract bundle: no sandbox ran, no key was injected, no exec output was captured. The author mission is public-safe committed lab text (redacted defensively); the composed prompt is bound by digest. The shipped live path applies scrubKnownValues then redactText at the capture source before persistence.",
+        redactionNotes: "Dry-run bundle: no sandbox ran, no key was injected, no exec output was captured. The author mission is public-safe committed lab text (redacted defensively); the composed prompt is bound by digest. The shipped live path applies scrubKnownValues then redactText at the capture source before persistence.",
         review,
     });
 }
@@ -167,8 +168,8 @@ 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
-            // green run never silently over-claims a fully-proven $0.
+            // Measurement 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
                 ? [
                     `${noSpendLineMeasured(noSpend) ? noSpendNotEstablished(noSpend.maxUsd ?? 0) : "No-spend proof is partial."} ${describeMeasuredSpend(args.ledgers.cost, args.trace.tokenUsage)} An adapter may supply the missing signals through costProbe.`,
@@ -185,7 +186,7 @@ export function buildLiveTerminalProductBundle(args) {
         simulation,
         stream,
         events: lifecycleEvents,
-        redactionNotes: `Live terminal-product run: the in-sandbox agent's output was captured via commands.run onStdout/onStderr and scrubbed (literal known values incl. the runtime key) THEN redacted (shape patterns) AT THE SOURCE before persisting. ${args.runtimeAuth === "openai-egress" ? `Runtime auth openai-egress: the raw key from ${args.runtimeAuthKeyName} is reserved for E2B's external api.openai.com HTTPS header transform. ${args.ledgers.commandLog.some((command) => command.label === "codex-exec") ? "Codex received an inert CODEX_API_KEY placeholder." : "Codex was not launched."} Any created sandbox retains a spendable OpenAI proxy capability until teardown; additional provider calls may not appear in the Codex usage ledger.` : `Runtime auth openai-env: the runtime key (${args.runtimeAuthKeyName}) was injected ONLY into the command-scoped codex invocation, never sandbox-global env or metadata; only its NAME appears in evidence.`} Subject provenance is UNPINNED (public-surface study).`,
+        redactionNotes: `Live terminal-product run: the in-sandbox agent's output was captured via commands.run onStdout/onStderr and had known values (including the runtime key) scrubbed, then shape patterns redacted, before anything was stored. ${args.runtimeAuth === "openai-egress" ? `Runtime auth openai-egress: the raw key from ${args.runtimeAuthKeyName} is reserved for E2B's external api.openai.com HTTPS header transform. ${args.ledgers.commandLog.some((command) => command.label === "codex-exec") ? "Codex received an inert CODEX_API_KEY placeholder." : "Codex was not launched."} Any created sandbox retains a spendable OpenAI proxy capability until teardown; additional provider calls may not appear in the Codex usage ledger.` : `Runtime auth openai-env: the runtime key (${args.runtimeAuthKeyName}) was passed only to the codex command, never to sandbox-wide environment variables or metadata; only its name appears in evidence.`} Subject provenance is unpinned (a study of public pages).`,
         review,
         ...(args.cost === undefined ? {} : { cost: args.cost }),
     });
@@ -209,7 +210,7 @@ function terminalParticipant(args, session) {
     const stream = participantStream(TERMINAL_IDS, {
         assignment: participantAssignment({ mission: args.mission }),
         kind: "terminal",
-        label: `Terminal agent — ${args.labId}`,
+        label: `Terminal agent · ${args.labId}`,
         status: session.status,
         transport: "snapshot",
         updatedAt: session.updatedAt,
@@ -236,17 +237,17 @@ function terminalRunBundle(args, parts) {
         persona: {
             id: args.persona.id,
             name: `Autonomous terminal agent (${args.persona.id})`,
-            source: `lab:${args.labId}`,
+            source: `study:${args.labId}`,
             sourceDigest: args.persona.promptDigest,
         },
         scenario: {
             id: `terminal-${args.labId}`,
             title: args.labTitle ?? `Terminal-product lab: ${args.labId}`,
-            // The author mission is public-safe committed lab text — recorded plaintext as the goal,
+            // The author mission is public-safe committed lab text. It is recorded plaintext as the goal,
             // redacted defensively before persisting (it never carries a secret, but the harness never
             // trusts that). The full composed prompt is bound by digest, not text.
             goal: redactText(args.mission),
-            source: `lab:${args.labId}`,
+            source: `study:${args.labId}`,
             sourceDigest: args.persona.promptDigest,
         },
         lifecycle: parts.lifecycle,
@@ -281,7 +282,7 @@ export function renderTerminalReviewMarkdown(bundle) {
         "",
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
-        `- verdict: ${bundle.review.verdict}`,
+        `- verdict: ${verdictText(bundle.review.verdict, bundle.mode)}`,
         `- summary: ${bundle.review.summary}`,
         `- mission: ${bundle.scenario.goal}`,
         ...(subject ? [`- subject: ${subject.message}`] : []),

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

@@ -18,17 +18,17 @@ export declare function buildRuntimeAuth(args: {
     keyValue: string;
 } | {
     ok: false;
-    code: "HUMANISH_TERMINAL_LAB_RUNTIME_AUTH_MISSING" | "HUMANISH_TERMINAL_LAB_CREDENTIAL_DENIED";
+    code: "HUMANISH_TERMINAL_RUNTIME_AUTH_MISSING" | "HUMANISH_TERMINAL_CREDENTIAL_DENIED";
     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 route — 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.
  */
 export declare function buildSandboxMetadata(allowlist: {
     labId: string;
-    simId: string;
+    recordId: string;
     runId: string;
 }): Record<string, string>;

package/dist/routes/terminal/credentials.js

@@ -12,13 +12,13 @@ export function buildRuntimeAuth(args) {
     // (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
     // 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.
     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 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
@@ -29,7 +29,7 @@ export function buildRuntimeAuth(args) {
     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,7 +37,7 @@ 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).`,
         };
     }
@@ -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 route — 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.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.
@@ -82,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,
@@ -96,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.",
                 },
             }),

package/dist/routes/terminal/encoding.js

@@ -6,7 +6,7 @@
 // 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;
@@ -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,7 +3,7 @@ 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).
@@ -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;
@@ -32,7 +32,7 @@ export declare function noSpendNotEstablished(maxUsd: number): string;
  */
 export declare function describeMeasuredSpend(ledger: TerminalCostLedger, tokenUsage?: ActorTokenUsage): string;
 /** 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. */
+ *  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;
 /**
  * Fail-closed caps enforcement. Returns a structured violation when a known

package/dist/routes/terminal/ledger.js

@@ -2,7 +2,7 @@ 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).
@@ -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"),
@@ -99,7 +99,7 @@ export function describeMeasuredSpend(ledger, tokenUsage) {
         .join(" ");
 }
 /** 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. */
+ *  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 = [];
@@ -115,14 +115,14 @@ export function buildNoSpendProof(ledger, maxUsd, tokenUsage) {
     }
     // 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.
+    // 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(" ");
@@ -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.js

@@ -25,7 +25,7 @@ function buildLiveTrace(inputs) {
     // 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: usage records arrive once per turn, and the tail
-    // would drop all but the last (#531).
+    // would drop all but the last.
     const terminalTokenUsage = parseTerminalTokenUsage(normalizedTranscript);
     const trace = buildTerminalActorTrace({
         persona,
@@ -71,14 +71,14 @@ 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}`);
     // 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)
+    // 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

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

@@ -56,7 +56,7 @@ export class LiveTerminalSandbox {
         const { warnings } = this.inputs;
         const { recordLifecycle } = this.inputs.recorder;
         const { requestTimeoutMs, sandboxTimeoutMs } = this;
-        // Declared egress allowlist, or undefined for the historical unrestricted default (#538).
+        // Declared egress allowlist, or undefined for the historical unrestricted default.
         const egressAllow = plan.egressAllow;
         const sandboxModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
         this.module = sandboxModule;
@@ -99,7 +99,7 @@ export class LiveTerminalSandbox {
         this.sandboxId = sandboxId;
         this.createdAtMs = now();
         await validatePreparedRunArtifactPaths(runPaths);
-        recordLifecycle("terminal-lab.sandbox.created", `E2B shell sandbox ${sandboxId} created with positive-allowlist metadata and kill-on-timeout; NO sandbox-global env.`);
+        recordLifecycle("terminal-lab.sandbox.created", `E2B shell sandbox ${sandboxId} created with allowlisted metadata and kill-on-timeout, and with no sandbox-wide environment variables.`);
         const sandboxResources = await observeDesktopResources(sandbox);
         this.resources = sandboxResources;
         if ("reason" in sandboxResources) {
@@ -108,7 +108,7 @@ export class LiveTerminalSandbox {
         // The allowlist is evidence: a reader of the ledger can see exactly what the participant was
         // able to reach, without the ledger carrying any secret.
         recordLifecycle("terminal-lab.egress.policy", egressAllow === undefined
-            ? "Egress UNRESTRICTED (no execution.egressAllow declared)."
+            ? "Egress is unrestricted (no execution.egressAllow declared)."
             : `Egress routing allowlist: ${egressAllow.length} declared host(s): ${egressAllow.join(", ")}; deny-all fallback. Domain routing is not strict destination isolation on shared infrastructure.`);
         recordLifecycle("terminal-lab.runtime-auth", runtimeEnv.mode === "openai-egress"
             ? "Runtime auth openai-egress: raw key remains outside the sandbox in the api.openai.com HTTPS Authorization transform; Codex receives an inert CODEX_API_KEY placeholder and the default OpenAI endpoint. Every sandbox process, including bootstrap/setup, can spend via this proxy; no added routing restriction or provider spending limit."
@@ -131,7 +131,7 @@ export class LiveTerminalSandbox {
         const { requestTimeoutMs } = this;
         // --- Runtime bootstrap: no runtime env; openai-egress proxy capability is already available. ---
         // The stock desktop needs Node/npm on `PATH` before npx can run Codex. Reuse a working
-        // installation or install the pinned official binary after checksum verification (#674).
+        // installation or install the pinned official binary after checksum verification.
         // No raw runtime key touches this step; the egress proxy, when selected, is already available.
         const bootstrapStartedAt = now();
         let bootstrapError;
@@ -149,7 +149,7 @@ export class LiveTerminalSandbox {
         }
         const bootstrapDurationMs = Math.max(0, now() - bootstrapStartedAt);
         recordLifecycle("terminal-lab.runtime.bootstrapped", bootstrapError
-            ? `Runtime bootstrap FAILED after ${bootstrapDurationMs}ms: ${bootstrapError}. codex exec runs via npx and needs Node/npm present; the participant fails closed rather than attempting an exec with no runtime.`
+            ? `Runtime bootstrap failed after ${bootstrapDurationMs}ms: ${bootstrapError}. codex exec runs through npx and needs Node and npm, so the participant stops here instead of starting codex with no runtime.`
             : `Runtime bootstrap ensured Node/npm present in ${bootstrapDurationMs}ms (codex exec runs via npx).`);
         if (bootstrapError) {
             // Fail closed as a structured route status (never a raw throw): no codex exec is attempted
@@ -259,7 +259,7 @@ export class LiveTerminalSandbox {
             const setup = await this.sandbox.commands.run(`${uploadAssignment}cd ${SANDBOX_WORKDIR} && ${install}`, {
                 // The install step may run the product itself (release:dogfood's does: `humanish init
                 // --yes`); on the 0.67.0 dogfood that one command arrived unmarked while the participant's
-                // nine others carried the marker (#546).
+                // nine others carried the marker.
                 envs: { HUMANISH_STUDY_PARTICIPANT: "1" },
                 requestTimeoutMs,
                 timeoutMs: PRODUCT_SETUP_TIMEOUT_MS,
@@ -272,7 +272,7 @@ export class LiveTerminalSandbox {
             setupError = toErrorMessage(error);
         }
         recordLifecycle("terminal-lab.product.prepared", setupError
-            ? `Product setup FAILED after ${Math.max(0, now() - setupStartedAt)}ms: ${sanitize(setupError)}`
+            ? `Product setup failed after ${Math.max(0, now() - setupStartedAt)}ms: ${sanitize(setupError)}`
             : `Product setup completed in ${Math.max(0, now() - setupStartedAt)}ms (no runtime env; declared egress auth may already be available).`);
         if (setupError) {
             this.status = "failed";
@@ -292,8 +292,8 @@ export class LiveTerminalSandbox {
         const { requestTimeoutMs, wallClockMs } = this;
         // --- The keyed run: `codex exec --json` non-interactively (stdin disabled). ---
         // openai-env passes the real key here; openai-egress passes an inert placeholder. stdin is
-        // never wired (safety contract item 7) — commands.run takes no stdin channel. The command's
-        // wall-clock is bounded by maxMinutes (safety contract item 2): commands.run timeoutMs +
+        // never wired: commands.run takes no stdin channel. The command's
+        // wall-clock is bounded by maxMinutes: commands.run timeoutMs +
         // an injected-clock guard so a mock/real run that exceeds it is killed and fails closed.
         const codexCommand = buildCodexExecCommand({
             workdir: SANDBOX_WORKDIR,
@@ -312,8 +312,7 @@ export class LiveTerminalSandbox {
             const result = await runWithWallClock(this.sandbox.commands.run(codexCommand, {
                 // The selected command env (raw key or inert placeholder). The participant
                 // marker rides the same command: humanish telemetry from inside a study reads as a new
-                // adopter otherwise. #546 added the flag and nothing set it; the 0.66.0 dogfood
-                // participant's twelve commands arrived unmarked.
+                // adopter otherwise.
                 envs: { ...runtimeEnv.envs, HUMANISH_STUDY_PARTICIPANT: "1" },
                 requestTimeoutMs,
                 timeoutMs: wallClockMs,
@@ -404,7 +403,7 @@ export class LiveTerminalSandbox {
         const { now, sanitize, warnings } = this.inputs;
         const { recordLifecycle } = this.inputs.recorder;
         const { requestTimeoutMs } = this;
-        // --- Safety contract item 8: proven cleanup, by exact id, never Sandbox.list. ---
+        // --- Proven cleanup, by exact id, never Sandbox.list. ---
         this.cleanup = await teardownSandbox({
             allocation: this.allocation,
             sandboxModule: this.module,
@@ -439,7 +438,7 @@ function buildCodexExecCommand(args) {
     // the prompt rides as the final positional arg, shell-quoted. codex exec --json runs once and
     // exits (no interactive loop). --skip-git-repo-check: the workdir is a fresh scratch dir.
     // Pinned via npx (never an ambient/preinstalled `codex` binary, which the stock @e2b/desktop
-    // image does not ship, per issue #159); npm_config_update_notifier=false silences npx's own
+    // image does not ship); npm_config_update_notifier=false silences npx's own
     // update check so it cannot leak into the captured stdout the scorer/redactor parse.
     const quotedPrompt = shellQuote(args.prompt);
     // --dangerously-bypass-approvals-and-sandbox: codex's own inner sandbox is

package/dist/routes/terminal/persona.js

@@ -10,7 +10,7 @@ import { prepareSelectedOutputDirectory } from "../../run/contained-output.js";
 export async function resolveTerminalPersona(args) {
     const personaId = args.plan.personaId ?? "autonomous-terminal-agent";
     const physicalCwd = await realpath(args.cwd);
-    // Resolve the committed persona so its traits actually shape the agent prompt (#308); fail-safe to
+    // Resolve the committed persona so its traits actually shape the agent prompt; fail-safe to
     // the bare persona id (no traits applied) when no persona file is committed.
     const projectRoot = await prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd);
     const { persona, warnings } = await resolveCommittedPersona(projectRoot, personaId);