humanish 0.107.0 → 0.109.0

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/debrief.js

@@ -1,4 +1,4 @@
-import { isCuaAdmissionLimitError } from "../admission-limit.js";
+import { isComputerUseAdmissionLimitError } from "../admission-limit.js";
 import { singleDispatch } from "./provider-call.js";
 import { CuaDeadlineError, raceSessionDeadline, requestScope } from "./race.js";
 import { notice } from "./trace.js";
@@ -110,7 +110,7 @@ async function debriefExchange(session, provider, context, trigger, boundMs, rec
     }
     catch (error) {
         // A failed optional report cannot rewrite the already observed structured completion.
-        if (isCuaAdmissionLimitError(error)) {
+        if (isComputerUseAdmissionLimitError(error)) {
             return record("skipped", "the adapter reported a local admission limit before provider dispatch; no closing request was sent");
         }
         const detail = signal?.aborted

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,9 +67,9 @@ 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;
+export declare function blockedOnSafetyChecks(checks: string, count: number): Stop;
 /**
  * A vision provider against a screenshot-less observation is a fail-closed harness error, not a
  * silent crash. The provider sets requiresFrame; a state-reasoning provider omits it.

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

@@ -1,9 +1,10 @@
-import { isCuaExecutorError } from "../executor-error.js";
-import { isCuaPromptRefusedError, isCuaProviderError } from "../provider-error.js";
+import { isComputerUseExecutorError } from "../executor-error.js";
+import { isComputerUsePromptRefusedError, isComputerUseProviderError } from "../provider-error.js";
 import { CuaAbortError, CuaDeadlineError } from "./race.js";
 import { notice } from "./trace.js";
+import { plural } from "../../../run/text.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 +26,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 +52,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;
@@ -67,8 +68,8 @@ export function timeLimit(session) {
     return {
         completionReason: "budget_reached",
         reason: session.actionHistory.interruptedActionOutcome
-            ? `reached the ${timeoutMs}ms time budget with ${materialActions} material action attempt(s), ${turns} turn(s); the latest action outcome is uncertain`
-            : `reached the ${timeoutMs}ms time budget after productive activity (${materialActions} material action(s), ${turns} turn(s))`,
+            ? `reached the ${timeoutMs}ms time budget with ${plural(materialActions, "material action attempt")}, ${plural(turns, "turn")}; the latest action outcome is uncertain`
+            : `reached the ${timeoutMs}ms time budget after productive activity (${plural(materialActions, "material action")}, ${plural(turns, "turn")})`,
         stopCause: "time_limit",
     };
 }
@@ -82,12 +83,12 @@ export function spendLimit(session, estimate, maxUsd) {
     const booked = session.usage.reservedRequests;
     const spend = booked === 0
         ? `estimated spend $${estimate}`
-        : `estimated spend $${estimate}, including the worst case of ${booked} lost request(s),`;
+        : `estimated spend $${estimate}, including the worst case of ${plural(booked, "lost request")},`;
     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 (${plural(materialActions, "material action")}, ${plural(turns, "turn")})`
+            : `Stopped before the next model turn: ${spend} passed execution.caps.maxUsd=$${maxUsd} with no material progress`,
         stopCause: "spend_limit",
     };
 }
@@ -178,12 +179,12 @@ 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) {
+export function blockedOnSafetyChecks(checks, count) {
     return {
         completionReason: "blocked_approval",
-        reason: `paused on model safety check(s): ${checks}; not acknowledged`,
+        reason: `paused on ${count === 1 ? "a model safety check" : `${count} model safety checks`}: ${checks}; not acknowledged`,
         evidence: {
             kind: "approval",
             body: () => ({ lifecycle: "completed", status: "blocked", title: `safety check: ${checks}` }),
@@ -258,7 +259,7 @@ export function stopForError(session, error) {
     const { lastActionTitle } = session.actionHistory;
     const lastAction = () => lastActionTitle === undefined ? undefined : `last action: ${redact(lastActionTitle)}`;
     const screenshot = session.lastScreenshotRef === undefined ? {} : { screenshotRef: session.lastScreenshotRef };
-    if (isCuaPromptRefusedError(error)) {
+    if (isComputerUsePromptRefusedError(error)) {
         // The provider's policy decision about the prompt, not a harness fault; never resent.
         const reason = `${error.message}; the prompt was not sent again`;
         return {
@@ -268,7 +269,7 @@ export function stopForError(session, error) {
             evidence: noticeEvidence("error", "provider refused the prompt", `phase: ${redact(session.phase)}; ${reason}`),
         };
     }
-    if (isCuaProviderError(error)) {
+    if (isComputerUseProviderError(error)) {
         const reason = `participant provider error: ${error.code}${error.failurePhase ? ` during ${error.failurePhase}` : ""}; cleanup: ${error.receipt.cleanup}`;
         return {
             completionReason: "harness_error",
@@ -276,7 +277,7 @@ export function stopForError(session, error) {
             evidence: noticeEvidence("error", "participant provider error", reason),
         };
     }
-    if (isCuaExecutorError(error)) {
+    if (isComputerUseExecutorError(error)) {
         const detail = () => [
             `phase: ${redact(session.phase)}`,
             `code: ${error.code}`,

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

@@ -1,10 +1,11 @@
 import { evaluateStopWhen } from "../../stop-conditions.js";
-import { CuaExecutorError, isCuaExecutorError } from "../executor-error.js";
+import { ComputerUseExecutorError, isComputerUseExecutorError } from "../executor-error.js";
 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
+import { plural } from "../../../run/text.js";
+// 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 +73,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;
@@ -114,11 +115,11 @@ export class DesktopObserver {
             this.observeTasks(final, turnNumber);
         }
         catch (error) {
-            if (isCuaExecutorError(error))
+            if (isComputerUseExecutorError(error))
                 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) {
@@ -133,7 +134,7 @@ export class DesktopObserver {
             if (executor.stallRecovery === "fail_closed") {
                 // The outer bound says nothing about whether the still-pending request completed.
                 // The owning session will close it; this loop must not send a replacement request.
-                throw new CuaExecutorError("deadline_exceeded", "outcome_uncertain");
+                throw new ComputerUseExecutorError("deadline_exceeded", "outcome_uncertain");
             }
             session.trace.record("notice", () => notice("warn", "observation stalled; retrying once", `${error.what} produced nothing within ${error.afterMs}ms; asking the desktop again`));
             return await raceCallBound(`observe (${label}, retry)`, executor.observe(), session.remaining(), session.observationTimeoutMs, session.signal);
@@ -153,7 +154,7 @@ export class DesktopObserver {
             this.session.trace.record("notice", () => notice("ok", "speech heard", this.session.redactNarration(utterance.text)));
         }
         if (this.pendingHeardSpeech.length > CUA_SPEECH_LIMITS.utterances) {
-            throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+            throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
         }
         return this.pendingHeardSpeech.length === 0
             ? observation
@@ -185,19 +186,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,9 +239,9 @@ 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`));
+        dwell.then === "stop" ? "matched" : "ok", "dwell window complete", `${plural(frames, "frame")} 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

@@ -1,5 +1,5 @@
-import { isCuaAdmissionLimitError } from "../admission-limit.js";
-import { CuaProviderError, isCuaProviderError } from "../provider-error.js";
+import { isComputerUseAdmissionLimitError } from "../admission-limit.js";
+import { ComputerUseProviderError, isComputerUseProviderError } from "../provider-error.js";
 import { adapterLimit, providerStalledTwice, usageUnreported } from "./ending.js";
 import { CuaAbortError, CuaDeadlineError, CuaStallError, raceCallBound, requestScope, } from "./race.js";
 import { bookLostRequest, LostRequestRefused, spendGate } from "./spend.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;
@@ -32,7 +32,7 @@ export async function requestTurn(session, request, turnNumber) {
     catch (error) {
         // Stops are concluded here, before `finally` ends the request scope, so their notices are
         // recorded before any abort listener runs.
-        if (isCuaAdmissionLimitError(error))
+        if (isComputerUseAdmissionLimitError(error))
             return { stop: session.conclude(adapterLimit) };
         if (error instanceof LostRequestRefused)
             return { stop: session.conclude(error.stop) };
@@ -73,7 +73,7 @@ async function retryStalledTurn(session, request, turnNumber, stall, stalled) {
         };
     }
     catch (retryError) {
-        if (isCuaAdmissionLimitError(retryError))
+        if (isComputerUseAdmissionLimitError(retryError))
             return { stop: session.conclude(adapterLimit) };
         if (retryError instanceof LostRequestRefused)
             return { stop: session.conclude(retryError.stop) };
@@ -101,7 +101,7 @@ export async function singleDispatch(session, kind, dispatch, boundMs) {
     const pending = Promise.resolve()
         .then(() => {
         if (scope.signal.aborted)
-            throw new CuaProviderError("cancelled", {
+            throw new ComputerUseProviderError("cancelled", {
                 dispatched: false,
                 usageComplete: false,
                 cleanup: "confirmed",
@@ -135,11 +135,11 @@ export async function singleDispatch(session, kind, dispatch, boundMs) {
     }
     const failure = "error" in outcome ? outcome.error : undefined;
     const requestSettlement = settlementRef.current;
-    const providerError = isCuaProviderError(failure)
+    const providerError = isComputerUseProviderError(failure)
         ? failure
         : requestSettlement &&
             "error" in requestSettlement &&
-            isCuaProviderError(requestSettlement.error)
+            isComputerUseProviderError(requestSettlement.error)
             ? requestSettlement.error
             : undefined;
     const turn = requestSettlement && "turn" in requestSettlement ? requestSettlement.turn : undefined;
@@ -157,8 +157,8 @@ export async function singleDispatch(session, kind, dispatch, boundMs) {
     if (failure instanceof CuaAbortError || failure instanceof CuaDeadlineError)
         throw failure;
     if (failure instanceof CuaStallError)
-        throw new CuaProviderError("timeout", receipt, usage, providerError?.failurePhase);
-    throw providerError ?? new CuaProviderError("process_failed", receipt, usage);
+        throw new ComputerUseProviderError("timeout", receipt, usage, providerError?.failurePhase);
+    throw providerError ?? new ComputerUseProviderError("process_failed", receipt, usage);
 }
 /**
  * Whether a single-dispatch turn is a valid turn from a continuing request (see
@@ -175,7 +175,7 @@ function isContinuingTurn(kind, turn) {
             turn.usage !== undefined ||
             turn.interruption !== undefined ||
             turn.closingReport !== undefined) {
-            throw new CuaProviderError("invalid_response", {
+            throw new ComputerUseProviderError("invalid_response", {
                 dispatched: "unknown",
                 usageComplete: false,
                 cleanup: "unconfirmed",
@@ -188,7 +188,7 @@ function isContinuingTurn(kind, turn) {
         r.dispatched !== true ||
         typeof r.usageComplete !== "boolean" ||
         r.cleanup !== "confirmed") {
-        throw new CuaProviderError("invalid_response", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, turn.usage);
+        throw new ComputerUseProviderError("invalid_response", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, turn.usage);
     }
     return false;
 }

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

@@ -1,9 +1,9 @@
 import type { ActorTraceItem, ParticipantDeclaredOutcome } from "../../contract.js";
 import type { AffordanceObservation } from "../../affordance.js";
-import { TaskTracker } from "../../../lab/tasks.js";
+import { TaskTracker } from "../../../study/tasks.js";
 import type { DebriefTrigger, Stop } from "./ending.js";
 import { TraceRecorder } from "./trace.js";
-import type { CuaExecutor, CuaLoopOptions, CuaProvider, CuaSafetyCheck } from "./types.js";
+import type { CuaExecutor, CuaProvider, CuaSafetyCheck, LoopRunOptions } from "./types.js";
 import { UsageLedger } from "./usage.js";
 export type ScreenshotRef = NonNullable<ActorTraceItem["screenshotRef"]>;
 /**
@@ -11,7 +11,7 @@ export type ScreenshotRef = NonNullable<ActorTraceItem["screenshotRef"]>;
  * wrapped callbacks are fields on LoopSession instead. Callers destructure hooks to call them.
  */
 export type LoopSettings = {
-    readonly [K in "instructions" | "persona" | "redaction" | "stopWhen" | "dwell" | "tasks" | "maxUsd" | "overRunBudget" | "estimateTurnCostUsd" | "onObservedUrl" | "onMessage" | "onScreenshot" | "onTrace"]: CuaLoopOptions[K];
+    readonly [K in "instructions" | "persona" | "redaction" | "stopWhen" | "dwell" | "tasks" | "maxUsd" | "overRunBudget" | "estimateTurnCostUsd" | "onObservedUrl" | "onMessage" | "onScreenshot" | "onTrace"]: LoopRunOptions[K];
 };
 /** The participant's dispatched actions, as the backstop and failure notices describe them. */
 export interface ActionHistory {
@@ -63,7 +63,7 @@ export declare class LoopSession {
     debriefTrigger: DebriefTrigger | undefined;
     private stopCause;
     private readonly scrubText;
-    constructor(options: CuaLoopOptions);
+    constructor(options: LoopRunOptions);
     remaining(): number;
     redactNarration(text: string): string;
     /** Hand a watcher the trace so far with the running usage, without waiting on it. */

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

@@ -1,4 +1,4 @@
-import { TaskTracker } from "../../../lab/tasks.js";
+import { TaskTracker } from "../../../study/tasks.js";
 import { TraceRecorder } from "./trace.js";
 import { UsageLedger } from "./usage.js";
 // The state one loop session shares across its phases: the options as read at entry, the session
@@ -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 run'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) {

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

@@ -1,5 +1,6 @@
 import { summarizeAffordanceUse } from "../../affordance.js";
 import { ACTOR_TRACE_SCHEMA, } from "../../contract.js";
+import { plural } from "../../../run/text.js";
 export function notice(status, title, text) {
     return { lifecycle: "completed", status, title, text };
 }
@@ -20,7 +21,7 @@ export class TraceRecorder {
     constructor(now) {
         this.now = now;
     }
-    // The ONE recording choke point (#441): every trace item is stamped `at` from the
+    // The single recording choke point: every trace item is stamped `at` from the
     // loop's injected clock as it is recorded, so timed playback reads recorded facts
     // (deterministic in tests via the injected `now`). The id is allocated before the body is
     // built, so a body that fails to build (a redaction error) still consumes its id.
@@ -40,7 +41,7 @@ export function statusForCompletionReason(reason) {
         case "turn_completed": // turn_completed is a Codex reason; this loop emits goal_satisfied
             return "passed";
         // A session that ran out of time or budget did not reach its goal, whatever it achieved along
-        // the way. Calling that `passed` is how a truncated study came to be reported as a green one —
+        // the way. Calling that `passed` is how a truncated study came to be reported as a green one,
         // and why "raise the timeout" kept landing on the operator instead of on the tool. This switch
         // is exhaustive with no default, so a new completion reason forces a compile error here.
         case "budget_reached":
@@ -51,7 +52,7 @@ export function statusForCompletionReason(reason) {
             return "blocked";
         // A participant who stopped trying is the single most valuable thing a usability study
         // produces. Recording it as `failed` said the instrument broke, which is a different claim and
-        // a false one — see docs/principles/three-roles.md.
+        // a false one; see docs/principles/three-roles.md.
         case "gave_up":
             return "abandoned";
         // Only the harness failing is a harness failure.
@@ -76,13 +77,13 @@ export function loopResult(session, stop, debrief) {
     const screenshotNote = !(counts.screenshots > 0)
         ? "no screenshots captured"
         : session.redactScreenshots
-            ? `${counts.screenshots} screenshot(s) redacted to blurred thumbnails via RedactionHooks`
-            : `${counts.screenshots} full-fidelity screenshot(s) retained for local use — NOT redacted for publishing; set redactScreenshots to blur a share-as-is bundle`;
-    // Self-describing artifact (invariant 6): when any observation carried structured app state,
+            ? `${plural(counts.screenshots, "screenshot")} redacted to blurred thumbnails via RedactionHooks`
+            : `${plural(counts.screenshots, "unblurred screenshot")} kept for local use and not redacted for publishing; set redactScreenshots to blur screenshots in a bundle you plan to share`;
+    // Self-describing artifact: when any observation carried structured app state,
     // the trace says how the loop handled it: it fed progress and task checks and was not written to
     // the trace. The appState itself never appears in this bundle.
     const notes = session.observedAppState
-        ? `${screenshotNote}. App state was observed each turn to drive progress detection (a state-driven executor) and was NOT written to the trace — it is a runtime-only progress input, never persisted as evidence in this slice.`
+        ? `${screenshotNote}. App state was read each turn to detect progress (an in-process executor) and was not written to the trace: it is used only while the run is live and is never stored as evidence.`
         : screenshotNote;
     const tokenUsage = usage.tokenUsage();
     const trace = {
@@ -90,6 +91,7 @@ export function loopResult(session, stop, debrief) {
         provider: provider.id,
         ...usage.liveMetadata(),
         ...(provider.version === undefined ? {} : { providerVersion: provider.version }),
+        ...(provider.conversation === undefined ? {} : { conversation: provider.conversation }),
         protocol: "cua-loop",
         lane: "computer-use",
         persona: settings.persona,
@@ -130,8 +132,8 @@ export function loopResult(session, stop, debrief) {
         ...(usage.interactionUsageIncomplete(session.capDeclared)
             ? { interactionUsageIncomplete: true }
             : {}),
-        // The funnel is present exactly when a protocol was declared — including a session that ended
-        // on turn 0, whose funnel honestly reads 0/N. No tasks declared means no funnel, not an empty one.
+        // The funnel is present exactly when a protocol was declared, including a session that ended
+        // on turn 0, whose funnel reads 0/N. No tasks declared means no funnel, not an empty one.
         ...(session.taskTracker === undefined ? {} : { taskFunnel: session.taskTracker.funnel() }),
         ...(tokenUsage === undefined ? {} : { tokenUsage }),
         capabilities: provider.capabilities,