humanish 0.107.0 → 0.108.0

package/dist/actors/codex/restricted-policy.js

@@ -1,7 +1,7 @@
 /** Versioned, deliberately narrow profile qualified with an account-backed vision turn.
  * The CLI still advertises code-mode tools: disabling their host is the enforcement
- * boundary. Feature names alone are not proof that a tool has been removed. The admitted
- * CLI releases are per host, in qualified-versions.ts. */
+ * boundary. Feature names alone are not proof that a tool has been removed. Which CLI
+ * releases launch is decided in codex-admission.ts. */
 export const RESTRICTED_CODEX_ANALYSIS_IDENTITY = {
     provider: "codex",
     authMode: "chatgpt",

package/dist/actors/codex/restricted-session.d.ts

@@ -12,8 +12,8 @@ export interface RestrictedCodexSessionOptions {
     /** The release a caller already recorded (an analysis identity); any other release is refused. */
     cliVersion?: string;
     /**
-     * Bypasses qualification: replaces this host's admitted releases with any list. It exists only
-     * so scripts/codex-qualify.mjs can launch an unqualified candidate. No library export, lab
+     * Bypasses launch admission: admits exactly this list. It exists only so
+     * scripts/codex-qualify.mjs can launch a candidate admission would refuse. No library export, lab
      * manifest, CLI flag, RunLabOptions field or LabDeps seam reaches it
      * (tests/actors/codex/cli-versions-seam.test.ts).
      */

package/dist/actors/codex/restricted-session.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { chmod, lstat, mkdir, mkdtemp, readdir, realpath, rm, unlink, writeFile, } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import path from "node:path";
-import { admittedCodexCliVersions } from "./qualified-versions.js";
+import { admitsCodexCliVersion, supportsIsolatedCodex } from "./codex-admission.js";
 import { launchAdmittedAppServer, } from "./restricted-launch.js";
 import { CODEX_IMAGE, CODEX_MAX_OUTPUT_BYTES, CODEX_MAX_REQUEST_BYTES, RESTRICTED_CODEX_ANALYSIS_MODELS, codexRecord, restrictedCodexFailure, restrictedCodexRequestError, } from "./restricted-policy.js";
 import { RestrictedCodexDeadline, RestrictedCodexStop, hasUnclosedChildren, retainUnclosedChild, } from "./restricted-transport.js";
@@ -312,11 +312,16 @@ function refusedRun(settings, state, request, busy) {
         return restrictedCodexFailure("codex_busy");
     const supportedPlatform = operatorAuth
         ? restrictedCodexNpmTarget(platform, arch) !== undefined
-        : (platform === "linux" && arch === "x64") || (platform === "darwin" && arch === "arm64");
+        : supportsIsolatedCodex(platform, arch);
     if (!supportedPlatform)
         return restrictedCodexFailure("codex_unsupported_platform");
     return undefined;
 }
+/** Which releases a session starts: launch admission, or the qualifier's exact list. */
+function launchAdmission(options) {
+    const exact = options.cliVersions;
+    return exact === undefined ? admitsCodexCliVersion : (version) => exact.includes(version);
+}
 export function createRestrictedCodexSession(options = {}) {
     // Option reads keep their old order: platform, arch, env, participant, spawnFn, cliVersions.
     const platform = options.platform ?? process.platform, arch = options.arch ?? process.arch;
@@ -331,7 +336,7 @@ export function createRestrictedCodexSession(options = {}) {
         operatorAuth: participant?.authMode === "operator",
         reasoningEffort: participant?.reasoningEffort ?? "low",
         spawnFn: options.spawnFn ?? ((file, args, spawnOptions) => spawn(file, args, spawnOptions)),
-        admittedVersions: options.cliVersions ?? admittedCodexCliVersions(platform, arch),
+        admits: launchAdmission(options),
     };
     const state = {
         work: undefined,
@@ -434,7 +439,7 @@ export async function checkRestrictedCodexSessionReadiness(input = {}, options =
  * `--version` runs with a private temporary home, removed afterwards. */
 export async function detectRestrictedCodexCliVersion(input = {}, options = {}) {
     const platform = options.platform ?? process.platform, arch = options.arch ?? process.arch;
-    if (!((platform === "linux" && arch === "x64") || (platform === "darwin" && arch === "arm64")))
+    if (!supportsIsolatedCodex(platform, arch))
         return { cliVersion: null, errorCode: "codex_unsupported_platform" };
     const sourceEnv = options.env ?? process.env;
     const deadline = new RestrictedCodexDeadline(input.timeoutMs ?? 15_000, input.signal);
@@ -444,7 +449,7 @@ export async function detectRestrictedCodexCliVersion(input = {}, options = {})
         work = await realpath(await mkdtemp(path.join(options.tempRoot ?? tmpdir(), "humanish-codex-version-")));
         const home = path.join(work, "home");
         await mkdir(home, { mode: 0o700 });
-        const cliVersion = await checkVersion(file, childEnvironment(sourceEnv, home, work), work, options.spawnFn ?? ((command, args, settings) => spawn(command, args, settings)), deadline, options.cliVersions ?? admittedCodexCliVersions(platform, arch), options.cliVersion);
+        const cliVersion = await checkVersion(file, childEnvironment(sourceEnv, home, work), work, options.spawnFn ?? ((command, args, settings) => spawn(command, args, settings)), deadline, launchAdmission(options), options.cliVersion);
         return { cliVersion, errorCode: null };
     }
     catch (error) {

package/dist/actors/computer-use/actor.d.ts

@@ -10,7 +10,7 @@ export interface CuaActorSessionOptions {
     instructions: string;
     /** Provenance of the persona this actor embodies (id + applied traits + prompt digest). */
     persona: ActorPersonaRef;
-    /** Hard wall-clock runaway guard — the only count-free hard stop the loop honors. */
+    /** Hard wall-clock runaway guard: the only count-free hard stop the loop honors. */
     timeoutMs: number;
     signal?: AbortSignal;
     /** Live provider construction (used when `provider` is not injected). */
@@ -19,10 +19,10 @@ export interface CuaActorSessionOptions {
     desktop?: E2BDesktopLike;
     executorOptions?: E2BDesktopExecutorOptions;
     /**
-     * DI seams — inject to bypass live construction (CI uses these for zero-spend tests; library
-     * callers use them to drive a state-driven, non-vision flow). NOTE: a STATE executor (one
-     * whose observe() returns no screenshot — see CuaObservation.screenshot optional) MUST be
-     * paired with a NON-vision provider (requiresFrame falsey). The default OpenAI provider is
+     * DI seams: inject to bypass live construction (CI uses these for zero-spend tests; library
+     * callers use them to drive a state-driven, non-vision flow). NOTE: a state executor (one
+     * whose observe() returns no screenshot; see CuaObservation.screenshot optional) must be
+     * paired with a non-vision provider (requiresFrame falsey). The default OpenAI provider is
      * vision-based and would fail closed against a screenshot-less observation. See
      * docs/architecture/state-driven-executor.md.
      */
@@ -39,7 +39,7 @@ export interface CuaActorSessionOptions {
     idleSteps?: number;
     noProgressSteps?: number;
     /**
-     * Redact persisted screenshots (blur+downscale). Default FALSE — full fidelity for local use.
+     * Redact persisted screenshots (blur+downscale). Default `false`: full fidelity for local use.
      * Set true for unowned subjects or share-as-is bundles. The provider always sees raw frames.
      */
     redactScreenshots?: boolean;
@@ -49,29 +49,29 @@ export interface CuaActorSessionOptions {
     writeScreenshot?: (name: string, bytes: Buffer) => Promise<string>;
     /** Deterministic harness-owned stop guards evaluated between model turns. */
     stopWhen?: StopWhen;
-    /** A declared observation window (#510), forwarded to the loop. */
+    /** A declared observation window, forwarded to the loop. */
     dwell?: DwellWindow;
-    /** The lab's declared protocol; the loop records a corroborated task funnel on the trace (#414).
-     *  Only the `success` criteria are read here — the participant-facing goals are already composed
+    /** The lab's declared protocol; the loop records a corroborated task funnel on the trace.
+     *  Only the `success` criteria are read here; the participant-facing goals are already composed
      *  into `instructions` upstream, and the criteria never reach the prompt. */
     tasks?: readonly LabTask[];
-    /** FAIL-CLOSED spend cap (USD) threaded to the loop; absent = uncapped. See CuaLoopOptions.maxUsd. */
+    /** Fail-closed spend cap (USD) threaded to the loop; absent = uncapped. See CuaLoopOptions.maxUsd. */
     maxUsd?: number;
     /** Injected pure per-turn cost estimator paired with `maxUsd`. See CuaLoopOptions.estimateTurnCostUsd. */
     estimateTurnCostUsd?: (usage: ActorTokenUsage) => number | null;
-    /** RUN-LEVEL spend guard threaded to the loop (#299). See CuaLoopOptions.overRunBudget. */
+    /** Run-level spend guard threaded to the loop. See CuaLoopOptions.overRunBudget. */
     overRunBudget?: (usage: ActorTokenUsage) => string | null;
     /** Stricter unknown-usage policy for capped sessions (see CuaLoopOptions); it also makes the
      *  OpenAI provider send one HTTP dispatch per turn. Library-only. */
     requireReportedUsageForSpendCap?: boolean;
-    /** RUNTIME-ONLY observed-URL callback threaded to the loop; see CuaLoopOptions.onObservedUrl. Used by
-     *  the concurrent shared-world handoff barrier to latch a host seat's live /lobby/CODE URL. */
+    /** Runtime-only observed-URL callback threaded to the loop; see CuaLoopOptions.onObservedUrl. Used by
+     *  the concurrent shared-world handoff barrier to latch a host's live /lobby/CODE URL. */
     onObservedUrl?: (url: string | undefined) => void;
-    /** RUNTIME-ONLY per-turn narration callback threaded to the loop; see CuaLoopOptions.onMessage. */
+    /** Runtime-only per-turn narration callback threaded to the loop; see CuaLoopOptions.onMessage. */
     onMessage?: (text: string) => void;
-    /** RUNTIME-ONLY per-turn raw-frame callback threaded to the loop; see CuaLoopOptions.onScreenshot. */
+    /** Runtime-only per-turn raw-frame callback threaded to the loop; see CuaLoopOptions.onScreenshot. */
     onScreenshot?: (frame: Buffer) => void;
-    /** Per-turn trace snapshot callback threaded to the loop (#441); see CuaLoopOptions.onTrace. */
+    /** Per-turn trace snapshot callback threaded to the loop; see CuaLoopOptions.onTrace. */
     onTrace?: (items: readonly ActorTraceItem[], usage: ActorTokenUsage, metadata?: CuaLiveMetadata) => void;
 }
 export declare function runCuaActorSession(options: CuaActorSessionOptions): Promise<CuaLoopResult>;

package/dist/actors/computer-use/actor.js

@@ -1,12 +1,12 @@
 // The registry-facing wrapper for the OpenAI Computer Use (CUA) actor. runComputerUseLoop needs
 // fully-constructed provider/executor instances; exposing that raw through the actor registry
 // would leak adapter construction to every call site. So runCuaActorSession takes intent-level
-// fields and constructs the provider/executor internally — with DI seams (provider/executor/now)
+// fields and constructs the provider/executor internally, with DI seams (provider/executor/now)
 // so CI can drive the real loop with fakes and zero network/zero spend (mirrors how the Claude
 // adapter injects its queryFn).
 //
 // The loop already returns a fully-formed ActorTrace at result.trace, so there is no separate
-// toActorTrace mapper — runCuaActorSession returns the CuaLoopResult unchanged.
+// toActorTrace mapper: runCuaActorSession returns the CuaLoopResult unchanged.
 import { runComputerUseLoop, } from "./loop.js";
 import { createE2BDesktopExecutor, } from "../../substrates/e2b/desktop-executor.js";
 import { createOpenAiResponsesProvider, } from "./openai-provider.js";

package/dist/actors/computer-use/admission-limit.d.ts

@@ -1,5 +1,5 @@
 /**
- * A caller's adapter refused this request BEFORE provider dispatch because a configured
+ * A caller's adapter refused this request before provider dispatch because a configured
  * local control limit was reached. This is an adapter declaration, not a provider response
  * or independent transport/billing attestation. Never use it for a dispatched request whose
  * outcome or usage is unknown. Import this class from the same humanish installation as the

package/dist/actors/computer-use/admission-limit.js

@@ -1,6 +1,6 @@
 const admissionLimits = new WeakSet();
 /**
- * A caller's adapter refused this request BEFORE provider dispatch because a configured
+ * A caller's adapter refused this request before provider dispatch because a configured
  * local control limit was reached. This is an adapter declaration, not a provider response
  * or independent transport/billing attestation. Never use it for a dispatched request whose
  * outcome or usage is unknown. Import this class from the same humanish installation as the

package/dist/actors/computer-use/loop/actions.d.ts

@@ -3,10 +3,10 @@ import type { CuaAction, CuaTurnRequest } from "./types.js";
 /** A public-safe one-line action label. Never includes raw typed text. */
 export declare function describeCuaAction(action: CuaAction): string;
 /**
- * A public-safe fingerprint of ONE turn's actions, used only in memory to tell "trying the same
- * thing again" from "trying something new" (#383).
+ * A public-safe fingerprint of one turn's actions, used only in memory to tell "trying the same
+ * thing again" from "trying something new".
  *
- * Never includes typed text or key contents — a `type` contributes its LENGTH, exactly as
+ * Never includes typed text or key contents: a `type` contributes its length, exactly as
  * describeCuaAction does, so this can never become a keylogger. Coordinates are bucketed so that
  * re-clicking the same control counts as a repeat while moving to a different control does not.
  */

package/dist/actors/computer-use/loop/actions.js

@@ -47,10 +47,10 @@ function describeAction(action) {
     }
 }
 /**
- * A public-safe fingerprint of ONE turn's actions, used only in memory to tell "trying the same
- * thing again" from "trying something new" (#383).
+ * A public-safe fingerprint of one turn's actions, used only in memory to tell "trying the same
+ * thing again" from "trying something new".
  *
- * Never includes typed text or key contents — a `type` contributes its LENGTH, exactly as
+ * Never includes typed text or key contents: a `type` contributes its length, exactly as
  * describeCuaAction does, so this can never become a keylogger. Coordinates are bucketed so that
  * re-clicking the same control counts as a repeat while moving to a different control does not.
  */
@@ -121,8 +121,8 @@ export async function runActionBatch(session, actions) {
         if (actionHistory.recentActionTitles.length > RECENT_ACTION_TITLES)
             actionHistory.recentActionTitles.shift();
         trace.bump("actions");
-        // Classify BEFORE execute, mirroring counts.actions: the record is of what the actor
-        // CHOSE, so an action that then fails to actuate is still an honest record of the route
+        // Classify before execute, mirroring counts.actions: the record is of what the actor
+        // chose, so an action that then fails to actuate is still a record of the route
         // it reached for.
         actionHistory.affordances.push(classifyCuaAction(action));
         session.phase = `executing ${title}`;
@@ -153,7 +153,7 @@ export async function runActionBatch(session, actions) {
             if (isCuaExecutorError(error) || !isCommandExitError(error))
                 throw error;
             // A skipped action changes nothing on screen, so a persistently-failing run makes no
-            // progress and still terminates honestly via the idle/no-progress backstop (gave_up),
+            // progress and still terminates via the idle/no-progress backstop (gave_up),
             // never a silent actor_error and never an infinite loop.
             recordCommandFailure(session, title, error);
             continue;
@@ -164,8 +164,8 @@ export async function runActionBatch(session, actions) {
             lifecycle: "completed",
             title,
             ...(action.kind === "speak" ? { text: session.redactNarration(action.text) } : {}),
-            // Structured pin coordinates (#441), exactly the click classes the Observer
-            // pins render — recorded fact instead of a title re-parse downstream.
+            // Structured pin coordinates, exactly the click classes the Observer
+            // pins render: recorded fact instead of a title re-parse downstream.
             ...(action.kind === "click" || action.kind === "double_click"
                 ? { coord: { x: action.x, y: action.y } }
                 : {}),
@@ -180,9 +180,9 @@ function countAttempt(session, action, title, status) {
     session.trace.counts.materialActions += 1;
 }
 /**
- * Execute one action. Idle actions only look (#480): a `wait` that hangs inside the SDK has in
+ * Execute one action. Idle actions only look: a `wait` that hangs inside the SDK has in
  * effect waited, so a stalled one is skipped with a notice and loses nothing the participant
- * chose. An action is recorded as completed only after execute() resolves (#248).
+ * chose. An action is recorded as completed only after execute() resolves.
  */
 async function dispatchAction(session, action, title) {
     if (!isIdleAction(action)) {

package/dist/actors/computer-use/loop/backstop.d.ts

@@ -2,10 +2,10 @@ import type { CuaAction, CuaObservation } from "./types.js";
 /**
  * A deterministic, bounded, sorted-key projection of an appState object, used as the friction
  * loop's progress key. Two structurally-equal states (regardless of key insertion order) map
- * to the SAME string, so key reordering can never fabricate a progress delta; two different
+ * to the same string, so key reordering can never fabricate a progress delta; two different
  * states map to different strings (within the caps).
  *
- * Correctness-load-bearing: it MUST NOT throw on a cyclic or huge input. Cycles are detected
+ * Correctness depends on this: it must not throw on a cyclic or huge input. Cycles are detected
  * with a seen-set (a back-edge degrades to the marker "[Circular]"); depth, key count, array
  * length, string length, and total output length are all capped so an adversarial or merely
  * large appState degrades to a bounded value rather than crashing the loop. Pure: it never
@@ -14,7 +14,7 @@ import type { CuaAction, CuaObservation } from "./types.js";
 export declare function stableProgressKey(appState: Record<string, unknown>): string;
 export interface Backstop {
     readonly progressKey: string;
-    /** The last few turns' action fingerprints, in memory only, for the #383 corroboration rule. */
+    /** The last few turns' action fingerprints, in memory only, for the corroboration rule below. */
     readonly recentFingerprints: readonly string[];
     readonly consecutiveIdle: number;
     readonly consecutiveNoProgress: number;

package/dist/actors/computer-use/loop/backstop.js

@@ -4,9 +4,9 @@ import { actionFingerprint, isIdleTurn } from "./actions.js";
 // streak (turns that neither change the UI state nor try something new). It is a pure fold over
 // turns, never a turn budget.
 const IDLE_PROGRESS_FORGIVENESS_STEPS = 2;
-/** How many recent turns the repetition check looks back over (#383). */
+/** How many recent turns the repetition check looks back over. */
 const ACTION_REPEAT_WINDOW = 3;
-/** Pixels of vertical scroll per progress bucket (#393): a real scroll step (typically >=100px)
+/** Pixels of vertical scroll per progress bucket: a real scroll step (typically >=100px)
  *  crosses a bucket and counts as progress; sub-bucket jiggle does not, so an actor nudging the
  *  same dead panel cannot stay "progressing" forever. */
 const SCROLL_PROGRESS_BUCKET_PX = 200;
@@ -22,10 +22,10 @@ const STABLE_KEY_MAX_TOTAL = 8192;
 /**
  * A deterministic, bounded, sorted-key projection of an appState object, used as the friction
  * loop's progress key. Two structurally-equal states (regardless of key insertion order) map
- * to the SAME string, so key reordering can never fabricate a progress delta; two different
+ * to the same string, so key reordering can never fabricate a progress delta; two different
  * states map to different strings (within the caps).
  *
- * Correctness-load-bearing: it MUST NOT throw on a cyclic or huge input. Cycles are detected
+ * Correctness depends on this: it must not throw on a cyclic or huge input. Cycles are detected
  * with a seen-set (a back-edge degrades to the marker "[Circular]"); depth, key count, array
  * length, string length, and total output length are all capped so an adversarial or merely
  * large appState degrades to a bounded value rather than crashing the loop. Pure: it never
@@ -107,8 +107,8 @@ function progressKeyOf(observation) {
     const base = observation.appState !== undefined
         ? stableProgressKey(observation.appState)
         : observation.stateSignature;
-    // Scroll position is state (#393): a scroll-pinned section keeps the frame hash constant while
-    // the participant genuinely advances, so the offset rides the key — bucketed, never raw.
+    // Scroll position is state: a scroll-pinned section keeps the frame hash constant while
+    // the participant genuinely advances, so the offset rides the key, bucketed, never raw.
     return observation.scrollY === undefined
         ? base
         : `${base}#s${Math.round(observation.scrollY / SCROLL_PROGRESS_BUCKET_PX)}`;
@@ -127,23 +127,23 @@ export function advanceBackstop(previous, turn, limits) {
     const idle = isIdleTurn(turn.actions);
     const progressKey = progressKeyOf(turn.observation);
     const frameChanged = progressKey !== previous.progressKey;
-    // CORROBORATION (#383). A stale frame alone is NOT evidence of a stuck agent. The frame hash is
+    // Corroboration. A stale frame alone is not evidence of a stuck agent. The frame hash is
     // a coarse whole-screen measure, and on a light-themed web app it can miss a renamed row, a new
-    // list item, or an opened panel — a measured run had 9 visibly different consecutive frames hash
+    // list item, or an opened panel: a measured run had 9 visibly different consecutive frames hash
     // identically while the agent was a foreign key away from finishing. Ending a participant on that
     // signal alone recorded working sessions as `gave_up`, capping every browser run at roughly
     // noProgressSteps turns and writing harness artifacts into evidence as actor behavior.
     //
-    // So a no-progress turn now requires BOTH a stale frame AND the agent repeating something it
+    // So a no-progress turn now requires both a stale frame and the agent repeating something it
     // just tried. An agent doing varied work is never counted stuck, however blind the hash is;
-    // an agent re-clicking the same dead control trips it as fast as it did before — arguably
+    // an agent re-clicking the same dead control trips it as fast as it did before, arguably
     // faster, since that is the actual signature of being stuck.
     const fingerprint = actionFingerprint(turn.actions);
     const repeatingRecentAction = fingerprint.length > 0 && previous.recentFingerprints.includes(fingerprint);
     const recentFingerprints = [...previous.recentFingerprints, fingerprint].slice(-ACTION_REPEAT_WINDOW);
-    // Corroboration governs the FRAME-STALENESS backstop only. The idle backstop below is a direct
+    // Corroboration governs the frame-staleness backstop only. The idle backstop below is a direct
     // behavioral signal already (the agent took nothing but screenshots and waits), so it keeps
-    // reading the frame on its own — a repeated screenshot is exactly what an idle streak IS, and
+    // reading the frame on its own: a repeated screenshot is exactly what an idle streak is, and
     // feeding repetition into it would grant an extra forgiveness step for being idle.
     const observedProgress = frameChanged || turn.heardNewSpeech;
     const progressed = observedProgress || !repeatingRecentAction;
@@ -172,11 +172,13 @@ export function advanceBackstop(previous, turn, limits) {
     const hints = [];
     if (consecutiveNoProgress >= noProgressRecoverySteps &&
         consecutiveNoProgress < limits.noProgressSteps) {
+        // prose-check: model prompt (the participant model reads this hint, not a person)
         hints.push(`No visible progress for ${consecutiveNoProgress} step(s). ` +
             "If your task calls for waiting for another participant or a pending transition, you may continue waiting. " +
             "Choose whether to continue or stop based on your situation and what you observe.");
     }
     if (consecutiveIdle >= idleRecoverySteps && consecutiveIdle < limits.idleSteps) {
+        // prose-check: model prompt (the participant model reads this hint, not a person)
         hints.push(`You are only waiting or taking screenshots for ${consecutiveIdle} step(s). ` +
             "If your task calls for waiting, you may continue within the remaining session time. " +
             "When the relevant controls become actionable, continue your task; describe any blocker you actually encounter.");

package/dist/actors/computer-use/loop/ending.d.ts

@@ -18,12 +18,12 @@ export interface Stop {
     readonly debriefTrigger?: DebriefTrigger;
 }
 /**
- * Read the fixed closing line the prompt asks for (#570): the FIRST non-empty line of the
+ * Read the fixed closing line the prompt asks for: the first non-empty line of the
  * participant's last message, exactly one of three phrases, punctuation and case forgiven. Anything
  * else is absence, never a guess. Exported for tests.
  */
 export declare function declaredOutcomeFromClosingLine(message: string | undefined): ParticipantDeclaredOutcome | undefined;
-/** The participant's own word for how it ended: a schema field first, then the closing line (#570). */
+/** The participant's own word for how it ended: a schema field first, then the closing line. */
 export declare function declaredOutcomeOf(turn: CuaTurn): ParticipantDeclaredOutcome | undefined;
 /**
  * The participant reported a natural endpoint. "not_reached" is a participant who stopped without
@@ -35,8 +35,8 @@ export declare function participantEnded(turn: CuaTurn, declaredOutcome: Partici
 export declare const harnessAborted: Stop;
 /**
  * The wall-clock deadline. A session that took at least one material (non-idle) action before the
- * cap reached its BUDGET rather than stalling; a deadline hit with zero material actions is still
- * an honest failure (timed_out).
+ * cap reached its budget rather than stalling; a deadline hit with zero material actions is still
+ * recorded as a failure (timed_out).
  */
 export declare function timeLimit(session: LoopSession): Stop;
 /**
@@ -67,7 +67,7 @@ export declare function providerStalledTwice(turnNumber: number, afterMs: number
 export declare function providerInterrupted(interruption: NonNullable<CuaTurn["interruption"]>): Stop;
 /**
  * Safety-check categories are provider-defined enums (e.g. "malicious_instructions"), not free
- * text; the evidence records them (redacted for defense-in-depth) so it shows WHY the run paused.
+ * text; the evidence records them (redacted for defense-in-depth) so it shows why the run paused.
  */
 export declare function blockedOnSafetyChecks(checks: string): Stop;
 /**

package/dist/actors/computer-use/loop/ending.js

@@ -3,7 +3,7 @@ import { isCuaPromptRefusedError, isCuaProviderError } from "../provider-error.j
 import { CuaAbortError, CuaDeadlineError } from "./race.js";
 import { notice } from "./trace.js";
 /**
- * Read the fixed closing line the prompt asks for (#570): the FIRST non-empty line of the
+ * Read the fixed closing line the prompt asks for: the first non-empty line of the
  * participant's last message, exactly one of three phrases, punctuation and case forgiven. Anything
  * else is absence, never a guess. Exported for tests.
  */
@@ -25,7 +25,7 @@ export function declaredOutcomeFromClosingLine(message) {
         return "blocked";
     return undefined;
 }
-/** The participant's own word for how it ended: a schema field first, then the closing line (#570). */
+/** The participant's own word for how it ended: a schema field first, then the closing line. */
 export function declaredOutcomeOf(turn) {
     return turn.outcome ?? declaredOutcomeFromClosingLine(turn.message);
 }
@@ -51,8 +51,8 @@ export const harnessAborted = {
 };
 /**
  * The wall-clock deadline. A session that took at least one material (non-idle) action before the
- * cap reached its BUDGET rather than stalling; a deadline hit with zero material actions is still
- * an honest failure (timed_out).
+ * cap reached its budget rather than stalling; a deadline hit with zero material actions is still
+ * recorded as a failure (timed_out).
  */
 export function timeLimit(session) {
     const { timeoutMs } = session;
@@ -86,8 +86,8 @@ export function spendLimit(session, estimate, maxUsd) {
     return {
         completionReason: "budget_reached",
         reason: materialActions > 0
-            ? `${spend} crossed execution.caps.maxUsd=$${maxUsd} after productive activity (${materialActions} material action(s), ${turns} turn(s)); aborted fail-closed before the next model turn`
-            : `${spend} crossed execution.caps.maxUsd=$${maxUsd} with no material progress; aborted fail-closed before the next model turn`,
+            ? `Stopped before the next model turn: ${spend} passed execution.caps.maxUsd=$${maxUsd} after productive activity (${materialActions} material action(s), ${turns} turn(s))`
+            : `Stopped before the next model turn: ${spend} passed execution.caps.maxUsd=$${maxUsd} with no material progress`,
         stopCause: "spend_limit",
     };
 }
@@ -178,7 +178,7 @@ export function providerInterrupted(interruption) {
 }
 /**
  * Safety-check categories are provider-defined enums (e.g. "malicious_instructions"), not free
- * text; the evidence records them (redacted for defense-in-depth) so it shows WHY the run paused.
+ * text; the evidence records them (redacted for defense-in-depth) so it shows why the run paused.
  */
 export function blockedOnSafetyChecks(checks) {
     return {

package/dist/actors/computer-use/loop/observation.d.ts

@@ -23,8 +23,8 @@ export declare class DesktopObserver {
     checkpoint(turnNumber: number): Promise<Checkpoint>;
     /**
      * Hand an observation the next turn may react to to the runtime hooks, and note whether it
-     * carried app state. Runtime-only: the seat's live location.href goes back to the orchestrator
-     * and is never persisted.
+     * carried app state. Runtime-only: the participant's live location.href goes back to the
+     * orchestrator and is never persisted.
      */
     private handToHooks;
     /**

package/dist/actors/computer-use/loop/observation.js

@@ -4,7 +4,7 @@ import { CUA_SPEECH_LIMITS } from "../speech.js";
 import { dwellCompleted, missingFrame, stopWhenMatched } from "./ending.js";
 import { CuaAbortError, CuaStallError, raceCallBound } from "./race.js";
 import { notice } from "./trace.js";
-// One projection feeds BOTH the stop guard and the task tracker, so a criterion that would stop
+// One projection feeds both the stop guard and the task tracker, so a criterion that would stop
 // the run and a criterion that completes a task can never see different evidence for one turn.
 function stopObservationOf(observation) {
     return {
@@ -72,8 +72,8 @@ export class DesktopObserver {
     }
     /**
      * Hand an observation the next turn may react to to the runtime hooks, and note whether it
-     * carried app state. Runtime-only: the seat's live location.href goes back to the orchestrator
-     * and is never persisted.
+     * carried app state. Runtime-only: the participant's live location.href goes back to the
+     * orchestrator and is never persisted.
      */
     handToHooks(observation) {
         const { onObservedUrl, onScreenshot } = this.session.settings;
@@ -118,7 +118,7 @@ export class DesktopObserver {
                 throw error;
         }
     }
-    // An executor without stallRecovery "fail_closed" gets one retry of a stalled observe (#480).
+    // An executor without stallRecovery "fail_closed" gets one retry of a stalled observe.
     // One that cannot safely replay a pending request opts out, so even a shorter outer bound stops
     // without retrying.
     async observeBounded(label) {
@@ -185,19 +185,19 @@ export class DesktopObserver {
         }));
         session.trace.bump("screenshots");
     }
-    // Evaluated BEFORE the stopWhen check each turn so a final task whose criterion coincides with
+    // Evaluated before the stopWhen check each turn so a final task whose criterion coincides with
     // the stop condition still lands in the funnel of the very turn that ends the session.
     observeTasks(observation, turnNumber) {
         const { taskTracker } = this.session;
         if (taskTracker === undefined)
             return;
         for (const completion of taskTracker.observe(stopObservationOf(observation), turnNumber)) {
-            // The id is researcher-authored config and the kinds are rule-type names; the matched VALUES
-            // (a URL, page text) never appear here — the same discipline as the stopWhen notice.
+            // The id is researcher-authored config and the kinds are rule-type names; the matched values
+            // (a URL, page text) never appear here: the same discipline as the stopWhen notice.
             this.session.trace.record("notice", () => notice("matched", `task completed: ${this.session.redactNarration(completion.id)}`, this.session.redactNarration(`turn ${turnNumber}; matched rule ${completion.matchedRuleIndex} (${completion.matchedKinds.join("+")})`)));
         }
     }
-    // The declared observation window (#510). The harness holds, looks, and takes nothing back to
+    // The declared observation window. The harness holds, looks, and takes nothing back to
     // the model: no action, no turn, no tokens. It runs once, cut to whatever session budget is
     // left, and says in the trace that the time was deliberate.
     async dwellIfDue(observation, turnNumber) {
@@ -238,7 +238,7 @@ export class DesktopObserver {
         }
         const heldMs = session.now() - dwellStartedAtMs;
         session.trace.record("notice", () => notice(
-        // A window that ENDS the session is structured, harness-owned completion evidence, the
+        // A window that ends the session is structured, harness-owned completion evidence, the
         // same class as a matched stopWhen, and the verdict resolver reads it that way.
         dwell.then === "stop" ? "matched" : "ok", "dwell window complete", `${frames} frame(s) over ${heldMs}ms; no model turn was requested during the window`));
         return { next: dwell.then, heldMs };

package/dist/actors/computer-use/loop/provider-call.d.ts

@@ -8,7 +8,7 @@ export type TurnReply = {
 };
 /**
  * Ask the provider for one turn. A fail_closed provider gets one single dispatch; any other is
- * raced against turnTimeoutMs (#469) and retried once when it stalls.
+ * raced against turnTimeoutMs and retried once when it stalls.
  */
 export declare function requestTurn(session: LoopSession, request: CuaTurnRequest, turnNumber: number): Promise<TurnReply>;
 /**

package/dist/actors/computer-use/loop/provider-call.js

@@ -12,7 +12,7 @@ import { reportedCounts, settledReceipt } from "./usage.js";
 const CUA_PROVIDER_CLEANUP_GRACE_MS = 5000;
 /**
  * Ask the provider for one turn. A fail_closed provider gets one single dispatch; any other is
- * raced against turnTimeoutMs (#469) and retried once when it stalls.
+ * raced against turnTimeoutMs and retried once when it stalls.
  */
 export async function requestTurn(session, request, turnNumber) {
     const { provider } = session;

package/dist/actors/computer-use/loop/session.js

@@ -7,7 +7,7 @@ import { UsageLedger } from "./usage.js";
 // (screenshot, wait, screenshot, wait), and a short idle limit ends that session as gave_up before
 // the mail can arrive.
 const DEFAULT_IDLE_STEPS = 24;
-// A no-progress turn also needs a repeated action (#383), so this needs less headroom than the
+// A no-progress turn also needs a repeated action, so this needs less headroom than the
 // idle limit.
 const DEFAULT_NO_PROGRESS_STEPS = 20;
 const DEFAULT_TURN_TIMEOUT_MS = 180_000;
@@ -105,9 +105,9 @@ export class LoopSession {
     remaining() {
         return this.timeoutMs - (this.now() - this.startedAtMs);
     }
-    // Model-authored narration: literal-scrub known provisioned values, THEN pattern-redact.
+    // Model-authored narration: literal-scrub known provisioned values, then pattern-redact.
     // A value the model transcribes (a DB password it read on screen) has no shape, so redactText
-    // alone cannot catch it — the lab's scrubKnownValues, injected as scrubText, closes that.
+    // alone cannot catch it; the lab's scrubKnownValues, injected as scrubText, closes that.
     redactNarration(text) {
         return this.settings.redaction.redactText(this.scrubText(text));
     }

package/dist/actors/computer-use/loop/spend.d.ts

@@ -9,7 +9,7 @@ export declare class LostRequestRefused extends Error {
 /**
  * The spend caps, checked before the next provider request so a model stuck retrying cannot keep
  * spending. The per-participant cap stops the session once the running estimate crosses maxUsd; a null
- * estimate cannot trip it, because preflight guaranteed a rate. The study budget (#299) is checked
+ * estimate cannot trip it, because preflight guaranteed a rate. The study budget is checked
  * next.
  */
 export declare function spendStop(session: LoopSession): Stop | undefined;

package/dist/actors/computer-use/loop/spend.js

@@ -14,7 +14,7 @@ export class LostRequestRefused extends Error {
 /**
  * The spend caps, checked before the next provider request so a model stuck retrying cannot keep
  * spending. The per-participant cap stops the session once the running estimate crosses maxUsd; a null
- * estimate cannot trip it, because preflight guaranteed a rate. The study budget (#299) is checked
+ * estimate cannot trip it, because preflight guaranteed a rate. The study budget is checked
  * next.
  */
 export function spendStop(session) {