humanish 0.108.0 → 0.109.0

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

@@ -1,6 +1,6 @@
 import {} from "../contract.js";
 import { defaultCodexCliVersion, untestedOperatorReleaseWarning } from "./codex-admission.js";
-import { CuaProviderError, isCuaProviderError, } from "../computer-use/provider-error.js";
+import { ComputerUseProviderError, isComputerUseProviderError, } from "../computer-use/provider-error.js";
 import { validateBrowserControlPng, validateHeardSpeech } from "../../browser-control/protocol.js";
 import { createRestrictedCodexSession, } from "./restricted-session.js";
 import { PARTICIPANT_PROFILE, PARTICIPANT_LIMITS as L, PARTICIPANT_FINAL_SCHEMA, participantToolSchema, parseParticipantTool, parseParticipantFinal, } from "./restricted-participant-policy.js";
@@ -150,15 +150,15 @@ const runReceipt = (result) => ({
  */
 function finalTurn(result, receipt, usage, stopped) {
     if (stopped.stopped)
-        throw new CuaProviderError(stopped.failedCleanup ? "cleanup_unconfirmed" : "cancelled", receipt, usage, result.failurePhase);
+        throw new ComputerUseProviderError(stopped.failedCleanup ? "cleanup_unconfirmed" : "cancelled", receipt, usage, result.failurePhase);
     if (result.status !== "completed" || result.errorCode !== null)
-        throw new CuaProviderError(codeOf(result.errorCode), receipt, usage, result.failurePhase);
+        throw new ComputerUseProviderError(codeOf(result.errorCode), receipt, usage, result.failurePhase);
     let turn;
     try {
         turn = parseParticipantFinal(result.output);
     }
     catch {
-        throw new CuaProviderError("invalid_response", receipt, usage, "response");
+        throw new ComputerUseProviderError("invalid_response", receipt, usage, "response");
     }
     return {
         ...turn,
@@ -340,9 +340,9 @@ function launchNativeRun(settings, state, req, imageUrl) {
         catch (error) {
             revokeParticipant(state);
             state.events.emit({
-                error: isCuaProviderError(error)
+                error: isComputerUseProviderError(error)
                     ? error
-                    : new CuaProviderError("process_failed", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, usage),
+                    : new ComputerUseProviderError("process_failed", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, usage),
             });
         }
         finally {
@@ -356,7 +356,7 @@ async function runParticipantTurn(settings, state, req, signal, debrief) {
         return state.events.next();
     if (signal.aborted) {
         revokeParticipant(state);
-        throw new CuaProviderError("cancelled", noDispatch());
+        throw new ComputerUseProviderError("cancelled", noDispatch());
     }
     const conversation = {
         instructions: state.instructions,
@@ -365,7 +365,7 @@ async function runParticipantTurn(settings, state, req, signal, debrief) {
         lastActionCount: state.lastActionCount,
     };
     if (rejectsParticipantRequest(req, conversation))
-        throw new CuaProviderError("request_rejected", noDispatch());
+        throw new ComputerUseProviderError("request_rejected", noDispatch());
     const onAbort = () => {
         revokeParticipant(state);
     };
@@ -382,7 +382,7 @@ async function runParticipantTurn(settings, state, req, signal, debrief) {
         else if (!state.active)
             launchNativeRun(settings, state, req, imageUrl);
         else
-            throw new CuaProviderError("busy", noDispatch());
+            throw new ComputerUseProviderError("busy", noDispatch());
         return await state.events.next();
     }
     finally {
@@ -426,7 +426,7 @@ function participantProvider(settings, state, start) {
 export function createRestrictedCodexParticipant(options = {}) {
     const timeoutMs = options.requestTimeoutMs ?? L.requestMs;
     if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > L.requestMs)
-        throw new CuaProviderError("request_rejected", noDispatch());
+        throw new ComputerUseProviderError("request_rejected", noDispatch());
     const operator = options.authMode === "operator";
     const speechEnabled = options.speechEnabled === true;
     const settings = {
@@ -458,9 +458,9 @@ export function createRestrictedCodexParticipant(options = {}) {
     let pending, closing;
     const start = (req, signal, debrief) => {
         if (state.closed && !state.events.waiting)
-            return Promise.reject(new CuaProviderError("request_rejected", noDispatch()));
+            return Promise.reject(new ComputerUseProviderError("request_rejected", noDispatch()));
         if (pending)
-            return Promise.reject(new CuaProviderError("busy", noDispatch()));
+            return Promise.reject(new ComputerUseProviderError("busy", noDispatch()));
         const task = runParticipantTurn(settings, state, req, signal, debrief);
         pending = task;
         void task

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

@@ -13,8 +13,8 @@ export interface RestrictedCodexSessionOptions {
     cliVersion?: string;
     /**
      * 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
+     * scripts/codex-qualify.mjs can launch a candidate admission would refuse. No library export, study
+     * manifest, CLI flag, RunStudyOptions field or StudyDeps seam reaches it
      * (tests/actors/codex/cli-versions-seam.test.ts).
      */
     cliVersions?: readonly string[];

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

@@ -4,7 +4,7 @@ import { type E2BDesktopExecutorOptions, type E2BDesktopLike } from "../../subst
 import { type OpenAiResponsesProviderOptions } from "./openai-provider.js";
 import { type RedactionHooks } from "../../evidence/redaction.js";
 import type { DwellWindow, StopWhen } from "../stop-conditions.js";
-import type { LabTask } from "../../lab/tasks.js";
+import type { StudyTask } from "../../study/tasks.js";
 export interface CuaActorSessionOptions {
     /** The composed mission (persona + scenario/participant instruction) handed to the model. */
     instructions: string;
@@ -51,10 +51,10 @@ export interface CuaActorSessionOptions {
     stopWhen?: StopWhen;
     /** 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.
+    /** The study'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[];
+    tasks?: readonly StudyTask[];
     /** 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. */
@@ -64,12 +64,12 @@ export interface CuaActorSessionOptions {
     /** 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
+    /** Runtime-only observed-URL callback threaded to the loop; see LoopTaps.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 LoopTaps.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 LoopTaps.onScreenshot. */
     onScreenshot?: (frame: Buffer) => void;
     /** Per-turn trace snapshot callback threaded to the loop; see CuaLoopOptions.onTrace. */
     onTrace?: (items: readonly ActorTraceItem[], usage: ActorTokenUsage, metadata?: CuaLiveMetadata) => void;

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

@@ -7,7 +7,7 @@
 //
 // The loop already returns a fully-formed ActorTrace at result.trace, so there is no separate
 // toActorTrace mapper: runCuaActorSession returns the CuaLoopResult unchanged.
-import { runComputerUseLoop, } from "./loop.js";
+import { runComputerUseLoopWithTaps, } from "./loop.js";
 import { createE2BDesktopExecutor, } from "../../substrates/e2b/desktop-executor.js";
 import { createOpenAiResponsesProvider, } from "./openai-provider.js";
 import { defaultRedactionHooks } from "../../evidence/redaction.js";
@@ -55,7 +55,7 @@ export async function runCuaActorSession(options) {
         ...(options.onScreenshot === undefined ? {} : { onScreenshot: options.onScreenshot }),
         ...(options.onTrace === undefined ? {} : { onTrace: options.onTrace }),
     };
-    const result = await runComputerUseLoop(loopOptions);
+    const result = await runComputerUseLoopWithTaps(loopOptions);
     if (result.trace.executionProfile?.billing === "account-unknown") {
         result.trace.estimatedCost = estimateActorCostForExecution(result.trace.tokenUsage, result.trace.ids.model, result.trace.executionProfile);
     }

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

@@ -5,8 +5,8 @@
  * outcome or usage is unknown. Import this class from the same humanish installation as the
  * loop/provider; names, message text and lookalike objects are not the contract.
  */
-export declare class CuaAdmissionLimitError extends Error {
+export declare class ComputerUseAdmissionLimitError extends Error {
     constructor();
 }
 /** Internal nominal check: neither a matching payload nor a forged prototype is a declaration. */
-export declare function isCuaAdmissionLimitError(error: unknown): error is CuaAdmissionLimitError;
+export declare function isComputerUseAdmissionLimitError(error: unknown): error is ComputerUseAdmissionLimitError;

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

@@ -6,14 +6,14 @@ const admissionLimits = new WeakSet();
  * outcome or usage is unknown. Import this class from the same humanish installation as the
  * loop/provider; names, message text and lookalike objects are not the contract.
  */
-export class CuaAdmissionLimitError extends Error {
+export class ComputerUseAdmissionLimitError extends Error {
     constructor() {
         super("The adapter refused the request before provider dispatch because a local admission limit was reached.");
-        this.name = "CuaAdmissionLimitError";
+        this.name = "ComputerUseAdmissionLimitError";
         admissionLimits.add(this);
     }
 }
 /** Internal nominal check: neither a matching payload nor a forged prototype is a declaration. */
-export function isCuaAdmissionLimitError(error) {
+export function isComputerUseAdmissionLimitError(error) {
     return typeof error === "object" && error !== null && admissionLimits.has(error);
 }

package/dist/actors/computer-use/executor-error.d.ts

@@ -21,11 +21,11 @@ export declare function isCuaExecutorErrorCode(value: unknown): value is CuaExec
  * began; a lost acknowledgement or partial action is `outcome_uncertain`, never a retry.
  * Import from the same installation as the loop: names and lookalike objects do not qualify.
  */
-export declare class CuaExecutorError extends Error {
+export declare class ComputerUseExecutorError extends Error {
     readonly code: CuaExecutorErrorCode;
     readonly disposition: CuaExecutorDisposition;
     constructor(code: CuaExecutorErrorCode, disposition: CuaExecutorDisposition);
 }
 /** A forged prototype is not an executor declaration. */
-export declare function isCuaExecutorError(error: unknown): error is CuaExecutorError;
+export declare function isComputerUseExecutorError(error: unknown): error is ComputerUseExecutorError;
 export {};

package/dist/actors/computer-use/executor-error.js

@@ -22,7 +22,7 @@ const executorErrors = new WeakSet();
  * began; a lost acknowledgement or partial action is `outcome_uncertain`, never a retry.
  * Import from the same installation as the loop: names and lookalike objects do not qualify.
  */
-export class CuaExecutorError extends Error {
+export class ComputerUseExecutorError extends Error {
     code;
     disposition;
     constructor(code, disposition) {
@@ -31,7 +31,7 @@ export class CuaExecutorError extends Error {
             throw new TypeError("Invalid desktop executor error declaration.");
         }
         super(messages[code]);
-        this.name = "CuaExecutorError";
+        this.name = "ComputerUseExecutorError";
         this.code = code;
         this.disposition = disposition;
         // Keep the values used in durable diagnostics finite even for JavaScript callers.
@@ -43,6 +43,6 @@ export class CuaExecutorError extends Error {
     }
 }
 /** A forged prototype is not an executor declaration. */
-export function isCuaExecutorError(error) {
+export function isComputerUseExecutorError(error) {
     return typeof error === "object" && error !== null && executorErrors.has(error);
 }

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

@@ -1,6 +1,6 @@
 import { classifyCuaAction } from "../../affordance.js";
 import { commandFailureInfo, isCommandExitError } from "../../../substrates/command-failure.js";
-import { CuaExecutorError, isCuaExecutorError } from "../executor-error.js";
+import { ComputerUseExecutorError, isComputerUseExecutorError } from "../executor-error.js";
 import { CuaAbortError, CuaDeadlineError, CuaStallError, raceCallBound, raceSessionDeadline, requestScope, } from "./race.js";
 import { notice } from "./trace.js";
 // The participant's actions: their public labels, what counts as a material action, and how one
@@ -131,7 +131,7 @@ export async function runActionBatch(session, actions) {
             status = await dispatchAction(session, action, title);
         }
         catch (error) {
-            const declared = isCuaExecutorError(error)
+            const declared = isComputerUseExecutorError(error)
                 ? error.disposition
                 : isCommandExitError(error)
                     ? "skipped"
@@ -139,7 +139,7 @@ export async function runActionBatch(session, actions) {
             if (declared !== undefined)
                 execution.actions.push({ index, status: declared });
             countAttempt(session, action, title, declared);
-            if (isCuaExecutorError(error) &&
+            if (isComputerUseExecutorError(error) &&
                 error.code === "action_rejected" &&
                 error.disposition === "not_dispatched") {
                 // Later actions may depend on this one (type, then submit). Return
@@ -150,7 +150,7 @@ export async function runActionBatch(session, actions) {
                 trace.record("notice", () => notice("warn", "action rejected before dispatch", session.redactNarration(`action: ${title}; code: action_rejected; disposition: not_dispatched; remaining batch actions not dispatched: ${actions.length - index - 1}`)));
                 return { execution, hint: rejectedActionHint(title) };
             }
-            if (isCuaExecutorError(error) || !isCommandExitError(error))
+            if (isComputerUseExecutorError(error) || !isCommandExitError(error))
                 throw error;
             // A skipped action changes nothing on screen, so a persistently-failing run makes no
             // progress and still terminates via the idle/no-progress backstop (gave_up),
@@ -213,7 +213,7 @@ async function executeAction(session, action, title, boundMs) {
     }
     catch (error) {
         if (error instanceof CuaStallError && session.executor.stallRecovery === "fail_closed") {
-            throw new CuaExecutorError("deadline_exceeded", "outcome_uncertain");
+            throw new ComputerUseExecutorError("deadline_exceeded", "outcome_uncertain");
         }
         if (error instanceof CuaDeadlineError || error instanceof CuaAbortError) {
             // The loop's deadline/abort may win before the executor can report whether its

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

@@ -69,7 +69,7 @@ export declare function providerInterrupted(interruption: NonNullable<CuaTurn["i
  * 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.
  */
-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,7 +1,8 @@
-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: the first non-empty line of the
  * participant's last message, exactly one of three phrases, punctuation and case forgiven. Anything
@@ -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,11 +83,11 @@ 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
-            ? `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} 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",
     };
@@ -180,10 +181,10 @@ 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.
  */
-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.js

@@ -1,9 +1,10 @@
 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";
+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) {
@@ -114,7 +115,7 @@ export class DesktopObserver {
             this.observeTasks(final, turnNumber);
         }
         catch (error) {
-            if (isCuaExecutorError(error))
+            if (isComputerUseExecutorError(error))
                 throw error;
         }
     }
@@ -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
@@ -240,7 +241,7 @@ export class DesktopObserver {
         session.trace.record("notice", () => notice(
         // 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.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";
@@ -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
@@ -107,7 +107,7 @@ export class LoopSession {
     }
     // 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/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 };
 }
@@ -76,8 +77,8 @@ 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} unblurred screenshot(s) kept for local use and not redacted for publishing; set redactScreenshots to blur screenshots in a bundle you plan to share`;
+            ? `${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.