humanish 0.107.0 → 0.109.0

package/dist/actors/scripted-browser/browser-command.js

@@ -1,5 +1,5 @@
 // Find a Chromium binary on the host for the scripted browser: HUMANISH_BROWSER_COMMAND first, then
-// the macOS Chrome path, then google-chrome, chromium and chromium-browser on PATH. A candidate
+// the macOS Chrome path, then google-chrome, chromium and chromium-browser on `PATH`. A candidate
 // counts only if `--version` runs.
 import { execFile } from "node:child_process";
 import path from "node:path";

package/dist/actors/scripted-browser/steps.js

@@ -176,7 +176,7 @@ async function waitForPageText(page, expectedText, timeoutMs) {
 }
 export function buildBlockedBrowserPersonaSteps(args) {
     // The journey never ran, so no screenshot was written for these steps. The
-    // failure IS the evidence: keep the blocked status + reason, but omit the
+    // failure is the evidence: keep the blocked status + reason, but omit the
     // screenshot reference so the bundle never claims an artifact that does not
     // exist (otherwise verify's missingLocalEvidenceArtifacts fails closed on
     // evidence that was never meant to exist).

package/dist/actors/scripted-browser/types.d.ts

@@ -108,7 +108,7 @@ export interface BrowserPersonaStepCapture {
     /**
      * Path to the step screenshot the producer actually wrote. Omitted for blocked
      * steps where the failure itself is the recorded evidence and no screenshot was
-     * written — the bundle must not reference an artifact that does not exist. A step that
+     * written: the bundle must not reference an artifact that does not exist. A step that
      * ran and attempted a screenshot keeps this even when its assertions failed, so a broken
      * producer still fails verify.
      */

package/dist/actors/stop-conditions.d.ts

@@ -14,7 +14,7 @@ export interface StopWhen {
     any: StopWhenRule[];
 }
 /**
- * A declared observation window (#510): once `when` matches (or at the start, when `when` is
+ * A declared observation window: once `when` matches (or at the start, when `when` is
  * absent), the harness holds the page for `ms`, captures a frame every `everyMs`, takes no action
  * and requests no model turn, then hands control back to the participant (`then: continue`) or
  * ends the session (`then: stop`). Bounded by the session budget: a window that would outlast it

package/dist/analysis/automatic-completion.d.ts

@@ -1,16 +1,16 @@
 import { FinishedRun } from "../run/run.js";
 import type { AnalysisConfig } from "./types.js";
-import type { LabDeps } from "../lab/lab-deps.js";
-import type { LabEvent } from "../lab/run-lab-events.js";
+import type { StudyDeps } from "../study/study-deps.js";
+import type { StudyEvent } from "../study/run-study-events.js";
 import { type AutomaticAnalysisDeps } from "./automatic.js";
 import type { AutomaticAnalysisOutcome } from "./job.js";
 /** What a route's input gives its analysis: the test's runner and deps, the signal and onEvent. */
 export interface AnalysisInput {
-    readonly deps?: Pick<LabDeps, "analysis">;
+    readonly deps?: Pick<StudyDeps, "analysis">;
     /** Cancels the analysis only. */
     readonly analysisSignal?: AbortSignal;
     /** Receives analysis-started and analysis-finished. */
-    readonly emit?: (event: LabEvent) => void;
+    readonly emit?: (event: StudyEvent) => void;
 }
 export interface AutomaticAnalysisResult {
     automaticAnalysis?: AutomaticAnalysisOutcome;
@@ -27,15 +27,15 @@ export declare function completeAutomaticAnalysis<T extends {
     runId: string;
     dryRun: boolean;
 }>(result: T, finished: FinishedRun | undefined, config: AnalysisConfig | undefined, input: AnalysisInput | undefined, { trigger, preferLargerOutput, refusal, }?: {
-    /** "default" when the lab declared no analysis; its missing-key skip is not a failure. */
+    /** "default" when the study declared no analysis; its missing-key skip is not a failure. */
     trigger?: "default" | "explicit";
-    /** The lab omitted an output limit, so a larger one may be used within the admission budget. */
+    /** The study omitted an output limit, so a larger one may be used within the admission budget. */
     preferLargerOutput?: boolean;
     /** The route's reason not to analyze this run; see AutomaticAnalysisDeps.refusal. */
     refusal?: AutomaticAnalysisDeps["refusal"];
 }): Promise<T & AutomaticAnalysisResult>;
 /**
- * True when an analysis the lab never declared was refused because its conservative estimate is
+ * True when an analysis the study never declared was refused because its conservative estimate is
  * over the default cap. The author did not ask for it, so the refusal does not fail the run;
  * `humanish analyze --max-cost` can still run it.
  */

package/dist/analysis/automatic-completion.js

@@ -72,7 +72,7 @@ export async function completeAutomaticAnalysis(result, finished, config, input,
     }
 }
 /**
- * True when an analysis the lab never declared was refused because its conservative estimate is
+ * True when an analysis the study never declared was refused because its conservative estimate is
  * over the default cap. The author did not ask for it, so the refusal does not fail the run;
  * `humanish analyze --max-cost` can still run it.
  */

package/dist/analysis/automatic-config.d.ts

@@ -1,14 +1,14 @@
-import type { LabRoute } from "../lab/plan.js";
+import type { StudyRoute } from "../study/plan.js";
 import type { AnalysisConfig } from "./types.js";
 export declare const DEFAULT_ANALYSIS_TIMEOUT_MS = 600000;
 export declare const DEFAULT_ANALYSIS_MODEL = "gpt-6-astra";
-interface LabAnalysisSettings {
+interface StudyAnalysisSettings {
     model?: string;
     question?: string;
     timeoutMs?: number;
 }
-/** The lab's review.analysis: a provider selection for a separate review after a live study. */
-export type LabAnalysis = LabAnalysisSettings & ({
+/** The study's review.analysis: a provider selection for a separate review after a live study. */
+export type StudyAnalysis = StudyAnalysisSettings & ({
     provider?: "openai";
     maxCostUsd: number;
     maxOutputTokens?: number;
@@ -17,7 +17,7 @@ export type LabAnalysis = LabAnalysisSettings & ({
     maxCostUsd?: null;
     maxOutputTokens?: null;
 });
-/** The spend cap on an analysis the lab did not declare. */
+/** The spend cap on an analysis the study did not declare. */
 export declare const DEFAULT_ANALYSIS_MAX_COST_USD = 3;
 /** Called for parsed manifests and direct library configs, before participant execution. */
 export declare function resolveAutomaticAnalysis(raw: unknown): {
@@ -36,6 +36,6 @@ export interface AutomaticAnalysisBudget {
     trigger: "default" | "explicit";
 }
 /** Metadata only: resolving the future live-run budget never reads keys or dispatches. */
-export declare function automaticAnalysisBudget(raw: unknown, route: LabRoute): AutomaticAnalysisBudget | undefined;
+export declare function automaticAnalysisBudget(raw: unknown, route: StudyRoute): AutomaticAnalysisBudget | undefined;
 export declare function formatAutomaticAnalysisBudget(budget: AutomaticAnalysisBudget): string;
 export {};

package/dist/analysis/automatic-config.js

@@ -22,7 +22,7 @@ const SENSITIVE_QUESTION = {
     ok: false,
     message: "review.analysis.question contains sensitive text and cannot be sent for analysis.",
 };
-/** The spend cap on an analysis the lab did not declare. */
+/** The spend cap on an analysis the study did not declare. */
 export const DEFAULT_ANALYSIS_MAX_COST_USD = 3;
 /** Called for parsed manifests and direct library configs, before participant execution. */
 export function resolveAutomaticAnalysis(raw) {

package/dist/analysis/codex-config.d.ts

@@ -2,7 +2,11 @@ import type { CodexAnalysisIdentity, AnalysisConfig } from "./types.js";
 export declare const CODEX_ANALYSIS_MODEL: "gpt-6-astra";
 /** Before dispatch, analysis replaces the default release with the detected one. */
 export declare function codexAnalysisIdentity(model: string, cliVersion?: string): CodexAnalysisIdentity;
-/** Execution admission: the identity must name a release qualified on this host. */
+/** Execution admission: an isolated-mode host, and an identity naming a release the launcher starts. */
 export declare function validCodexAnalysisConfig(config: AnalysisConfig, platform?: NodeJS.Platform, arch?: string): boolean;
-/** Reading historical artifacts never inserts defaults or selects a launch policy. */
+/**
+ * Reading historical artifacts never inserts defaults or selects a launch policy: the restricted
+ * analyst's fixed identity, from any recordable release, so a change to launch admission never
+ * invalidates a saved report.
+ */
 export declare function validStoredCodexAnalysisConfig(config: AnalysisConfig): boolean;

package/dist/analysis/codex-config.js

@@ -1,7 +1,7 @@
-import { RECORDED_CODEX_CLI_VERSIONS } from "../actors/contract.js";
-import { defaultCodexCliVersion, qualifiedCodexCliVersions, } from "../actors/codex/qualified-versions.js";
+import { isRecordedCodexCliVersion } from "../actors/contract.js";
+import { admitsCodexCliVersion, defaultCodexCliVersion, supportsIsolatedCodex, } from "../actors/codex/codex-admission.js";
 import { RESTRICTED_CODEX_ANALYSIS_IDENTITY, RESTRICTED_CODEX_ANALYSIS_MODELS, } from "../actors/codex/restricted-policy.js";
-/** This account route is qualified against per-host CLI releases, one model and one tool policy. */
+/** This account route runs the releases codex-admission.ts admits, one model and one tool policy. */
 const CODEX_ANALYSIS_TOOL_POLICY = RESTRICTED_CODEX_ANALYSIS_IDENTITY.toolPolicy;
 export const CODEX_ANALYSIS_MODEL = RESTRICTED_CODEX_ANALYSIS_MODELS[0];
 const CODEX_ANALYSIS_EFFORT = RESTRICTED_CODEX_ANALYSIS_IDENTITY.reasoningEffort;
@@ -26,13 +26,6 @@ export function codexAnalysisIdentity(model, cliVersion = defaultCodexCliVersion
         cliVersion,
     });
 }
-/** Reader profiles are append-only. A new launch qualification must not invalidate a saved report. */
-const storedProfiles = RECORDED_CODEX_CLI_VERSIONS.map((cliVersion) => ({
-    cliVersion,
-    toolPolicy: "restricted-codex-v1",
-    model: "gpt-6-astra",
-    reasoningEffort: "low",
-}));
 function matchesProfile(config, expected) {
     if (config.provider !== "codex")
         return false;
@@ -54,16 +47,31 @@ function matchesProfile(config, expected) {
         Object.keys(config.identity).length === Object.keys(expected).length &&
         Object.entries(expected).every(([key, value]) => config.identity[key] === value));
 }
-/** Execution admission: the identity must name a release qualified on this host. */
+/** Execution admission: an isolated-mode host, and an identity naming a release the launcher starts. */
 export function validCodexAnalysisConfig(config, platform = process.platform, arch = process.arch) {
     if (config.provider !== "codex")
         return false;
     const cliVersion = config.identity?.cliVersion;
     return (config.model === CODEX_ANALYSIS_MODEL &&
-        qualifiedCodexCliVersions(platform, arch).some((version) => version === cliVersion) &&
+        supportsIsolatedCodex(platform, arch) &&
+        typeof cliVersion === "string" &&
+        admitsCodexCliVersion(cliVersion) &&
         matchesProfile(config, codexAnalysisIdentity(config.model, cliVersion)));
 }
-/** Reading historical artifacts never inserts defaults or selects a launch policy. */
+/**
+ * Reading historical artifacts never inserts defaults or selects a launch policy: the restricted
+ * analyst's fixed identity, from any recordable release, so a change to launch admission never
+ * invalidates a saved report.
+ */
 export function validStoredCodexAnalysisConfig(config) {
-    return storedProfiles.some((profile) => matchesProfile(config, identityFor(profile)));
+    if (config.provider !== "codex")
+        return false;
+    const cliVersion = config.identity?.cliVersion;
+    return (isRecordedCodexCliVersion(cliVersion) &&
+        matchesProfile(config, identityFor({
+            cliVersion,
+            toolPolicy: "restricted-codex-v1",
+            model: "gpt-6-astra",
+            reasoningEffort: "low",
+        })));
 }

package/dist/analysis/execute.d.ts

@@ -3,7 +3,7 @@ import { type AnalysisFetch, type AnalysisProvider } from "./provider.js";
 import type { RejectedAnalysisOutput } from "./diagnostics.js";
 export declare const ANALYSIS_PROMPT_VERSION = "study-evidence-6";
 export declare const isSupportedAnalysisModel: (model: string) => boolean;
-/** The OpenAI output limit when a lab omits maxOutputTokens, and the most it may ask for. */
+/** The OpenAI output limit when a study omits maxOutputTokens, and the most it may ask for. */
 export declare const DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS = 16384;
 export declare const MAX_ANALYSIS_OUTPUT_TOKENS = 32768;
 export interface AnalysisAdmission {

package/dist/analysis/execute.js

@@ -21,7 +21,7 @@ const SUPPORTED_ANALYSIS_MODELS = Object.freeze([
 ]);
 const SUPPORTED_MODELS = new Set(SUPPORTED_ANALYSIS_MODELS);
 export const isSupportedAnalysisModel = (model) => SUPPORTED_MODELS.has(model);
-/** The OpenAI output limit when a lab omits maxOutputTokens, and the most it may ask for. */
+/** The OpenAI output limit when a study omits maxOutputTokens, and the most it may ask for. */
 export const DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS = 16_384;
 export const MAX_ANALYSIS_OUTPUT_TOKENS = 32_768;
 const MAX_EVIDENCE_BYTES = 1024 * 1024;

package/dist/analysis/service.js

@@ -1,4 +1,4 @@
-import { describeQualifiedCodexCliVersions } from "../actors/codex/qualified-versions.js";
+import { defaultCodexCliVersion, describeCodexCliAdmission, } from "../actors/codex/codex-admission.js";
 import { validCodexAnalysisConfig } from "./codex-config.js";
 import { randomUUID } from "node:crypto";
 import { lstat, mkdir, realpath, rmdir } from "node:fs/promises";
@@ -43,7 +43,7 @@ const messages = {
     ANALYSIS_VERIFY_FAILED: "The run must pass verification before analysis.",
     ANALYSIS_RUN_ACTIVE: "Analysis requires a completed recording. Wait for the study to finish.",
     ANALYSIS_NO_PARTICIPANTS: "This run contains no participant evidence to analyze.",
-    ANALYSIS_REQUIRES_LIVE_RUN: "A dry-run proves harness contracts, not participant behavior. Select a completed live study for analysis.",
+    ANALYSIS_REQUIRES_LIVE_RUN: "A dry run has no participant behavior to analyze. Select a completed live run.",
     ANALYSIS_SOURCE_UNAVAILABLE: "The source recording is missing, unsafe, or exceeds the input limit.",
     ANALYSIS_SOURCE_CHANGED: "The source recording changed during analysis. The result cannot be published against different evidence.",
     ANALYSIS_BUSY: "Another analysis holds this run's .analysis-lock directory. If it was interrupted, confirm it has stopped before removing that empty directory.",
@@ -56,9 +56,9 @@ const messages = {
 };
 const codexRecovery = {
     analysis_codex_busy: "Another restricted Codex analyst or setup check is active in this process. Wait for it to finish, then explicitly retry.",
-    analysis_codex_unavailable: `The qualified Codex CLI is unavailable. Install a qualified Codex CLI (${describeQualifiedCodexCliVersions()}) and sign in with a ChatGPT account, then retry --provider codex.`,
-    analysis_codex_unsupported_version: `Codex account analysis requires a qualified CLI version (${describeQualifiedCodexCliVersions()}). Other versions have not passed this tool-policy contract.`,
-    analysis_codex_incompatible_release: `This Codex CLI release changed app-server protocol fields humanish reads, so no request was sent; the warnings name each change. Install a release humanish was tested with (${describeQualifiedCodexCliVersions()}), then retry.`,
+    analysis_codex_unavailable: `The Codex CLI is unavailable. Install one (${describeCodexCliAdmission()}) and sign in with a ChatGPT account, then retry --provider codex.`,
+    analysis_codex_unsupported_version: `This Codex CLI release is refused: ${describeCodexCliAdmission()}. \`humanish doctor\` names the release it found, why, and the command that replaces it.`,
+    analysis_codex_incompatible_release: `This Codex CLI release changed app-server protocol fields humanish reads, so no request was sent; the warnings name each change. Install the last tested release (${defaultCodexCliVersion()}), then retry.`,
     analysis_codex_unsupported_platform: "This platform has not qualified the restricted Codex account launcher.",
     analysis_codex_login_required: "Sign in to Codex with a ChatGPT account, then retry humanish analyze --provider codex --rerun.",
     analysis_codex_unsupported_auth: "Codex analysis requires ChatGPT account authentication; API-key and custom provider authentication are not used as fallbacks.",

package/dist/analysis/types.d.ts

@@ -1,6 +1,7 @@
 import type { ActorStatus, ActorCompletionReason, ActorStopCause, ParticipantDeclaredOutcome } from "../actors/contract.js";
 import type { CuaGoalSource } from "../actors/goal-source.js";
 import type { AutomaticAnalysisView } from "./job.js";
+import type { RunAnalysisCost } from "../run/run-cost.js";
 /** Independent interpretation of retained evidence; never a participant or harness verdict. */
 export declare const ANALYSIS_SCHEMA: "humanish.study-analysis.v1";
 export declare const ANALYSIS_CORRECTION_SCHEMA: "humanish.study-analysis-correction.v1";
@@ -213,5 +214,10 @@ export interface LoadedAnalysis {
     warnings: string[];
     /** Independent post-run execution metadata; never changes evidence sharing grades. */
     automatic?: AutomaticAnalysisView;
+    /**
+     * What the run's analysis requests cost, every attempt counted once (src/run/costs.ts
+     * readAnalysisAccounting, the reader stats uses). Absent when the run sent none.
+     */
+    spend?: RunAnalysisCost;
 }
 export {};

package/dist/browser-control/client.js

@@ -1,4 +1,4 @@
-import { CuaExecutorError, } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError, } from "../actors/computer-use/executor-error.js";
 import { BROWSER_CONTROL_LIMITS, BROWSER_CONTROL_VERSION, decodeBrowserControlObservation, parseBrowserControlReply, sameBrowserControlIdentity, validateBrowserControlAction, validateBrowserControlIdentity, } from "./protocol.js";
 import { BrowserControlTransport } from "./transport.js";
 import { receiveBrowserControlRecording } from "./recording-transfer.js";
@@ -8,7 +8,7 @@ export function createBrowserControlClient(options) {
     if (!Number.isFinite(timeoutMs) ||
         timeoutMs < 1 ||
         timeoutMs > BROWSER_CONTROL_LIMITS.maxRequestTimeoutMs)
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     const state = {
         identity,
         timeoutMs,
@@ -47,7 +47,7 @@ function closeClient(state, code) {
     state.pending = undefined;
     if (operation) {
         operation.dispose();
-        operation.reject(new CuaExecutorError(code, operation.written ? "outcome_uncertain" : "not_dispatched"));
+        operation.reject(new ComputerUseExecutorError(code, operation.written ? "outcome_uncertain" : "not_dispatched"));
     }
 }
 /** Settles the pending exchange once both its reply has arrived and its request write finished. */
@@ -68,7 +68,7 @@ function finishExchange(session) {
             code !== "action_rejected" ||
             disposition !== "not_dispatched")
             session.transport.close(code);
-        operation.reject(new CuaExecutorError(code, disposition));
+        operation.reject(new ComputerUseExecutorError(code, disposition));
     }
 }
 /** Matches a reply frame to the pending request; any mismatch closes the channel. */
@@ -120,12 +120,12 @@ function acceptReply(session, value) {
 function exchange(session, operation, action, signal, destination) {
     const { transport } = session;
     if (session.closed)
-        return Promise.reject(new CuaExecutorError("executor_closed", "not_dispatched"));
+        return Promise.reject(new ComputerUseExecutorError("executor_closed", "not_dispatched"));
     if (signal?.aborted)
-        return Promise.reject(new CuaExecutorError("cancelled", "not_dispatched"));
+        return Promise.reject(new ComputerUseExecutorError("cancelled", "not_dispatched"));
     if (session.seq >= Number.MAX_SAFE_INTEGER) {
         transport.close("protocol_mismatch");
-        return Promise.reject(new CuaExecutorError("protocol_mismatch", "not_dispatched"));
+        return Promise.reject(new ComputerUseExecutorError("protocol_mismatch", "not_dispatched"));
     }
     session.seq += 1;
     const seq = session.seq;
@@ -174,9 +174,9 @@ function exchange(session, operation, action, signal, destination) {
 /** Runs one public operation at a time on an open client. */
 async function withOperation(session, work) {
     if (session.closed)
-        throw new CuaExecutorError("executor_closed", "not_dispatched");
+        throw new ComputerUseExecutorError("executor_closed", "not_dispatched");
     if (session.busy)
-        throw new CuaExecutorError("executor_busy", "not_dispatched");
+        throw new ComputerUseExecutorError("executor_busy", "not_dispatched");
     session.busy = true;
     try {
         return await work();
@@ -202,34 +202,34 @@ async function observe(session) {
     }
     catch {
         session.transport.close("invalid_response");
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     }
 }
 async function execute(session, action, signal) {
     const validAction = validateBrowserControlAction(action);
     if (validAction.kind === "speak" && !session.speechEnabled) {
-        throw new CuaExecutorError("action_rejected", "not_dispatched");
+        throw new ComputerUseExecutorError("action_rejected", "not_dispatched");
     }
     if (signal?.aborted)
-        throw new CuaExecutorError("cancelled", "not_dispatched");
+        throw new ComputerUseExecutorError("cancelled", "not_dispatched");
     try {
         await hello(session, signal);
     }
     catch (error) {
-        if (error instanceof CuaExecutorError)
-            throw new CuaExecutorError(error.code, "not_dispatched");
+        if (error instanceof ComputerUseExecutorError)
+            throw new ComputerUseExecutorError(error.code, "not_dispatched");
         throw error;
     }
     await exchange(session, "EXECUTE", validAction, signal);
 }
 async function finishRecording(session, destination) {
     if (!destination || destination.destroyed)
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     try {
         await hello(session);
         const reply = await exchange(session, "FINISH_RECORDING", undefined, undefined, destination);
         if (!reply.ok || !reply.recording)
-            throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+            throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
         return reply.recording;
     }
     catch (error) {

package/dist/browser-control/dispatcher.js

@@ -1,4 +1,4 @@
-import { CuaExecutorError } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError } from "../actors/computer-use/executor-error.js";
 import { BROWSER_CONTROL_LIMITS, BROWSER_CONTROL_VERSION, encodeBrowserControlObservation, parseBrowserControlRequest, safeBrowserControlFailure, sameBrowserControlIdentity, validateBrowserControlIdentity, } from "./protocol.js";
 import { BrowserControlTransport } from "./transport.js";
 import { sendBrowserControlRecording } from "./recording-transfer.js";
@@ -103,7 +103,7 @@ function failure(common, error, invoked) {
 async function dispatch(session, request, signal) {
     const common = replyCommon(session.identity, request);
     if (!authorized(session.options) || signal.aborted) {
-        const refusal = new CuaExecutorError("session_revoked", "not_dispatched");
+        const refusal = new ComputerUseExecutorError("session_revoked", "not_dispatched");
         await sendReply(session, request, failure(common, refusal, false));
         return;
     }
@@ -160,7 +160,7 @@ async function execute(session, request, common, signal) {
     let invoked = false, reply;
     try {
         if (request.action.kind === "speak" && session.options.executor.speechEnabled !== true) {
-            throw new CuaExecutorError("action_rejected", "not_dispatched");
+            throw new ComputerUseExecutorError("action_rejected", "not_dispatched");
         }
         // No await between the owner gate in dispatch and invocation. The physical driver must
         // check this signal again immediately before each actual input after preparation.
@@ -183,7 +183,7 @@ async function finishRecording(session, request, common, signal) {
     let reply;
     try {
         if (!options.finishRecording)
-            throw new CuaExecutorError("action_rejected", "not_dispatched");
+            throw new ComputerUseExecutorError("action_rejected", "not_dispatched");
         const recording = await options.finishRecording();
         let metadata;
         try {

package/dist/browser-control/protocol.js

@@ -1,7 +1,7 @@
 import { PNG } from "pngjs";
 import { z } from "zod";
 import { CUA_SPEECH_LIMITS } from "../actors/computer-use/speech.js";
-import { CuaExecutorError, isCuaExecutorError, } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError, isComputerUseExecutorError, } from "../actors/computer-use/executor-error.js";
 import { desktopRecordingMetadataSchema } from "../evidence/desktop-recording-types.js";
 export const BROWSER_CONTROL_VERSION = 1;
 export const BROWSER_CONTROL_LIMITS = Object.freeze({
@@ -219,7 +219,7 @@ const replySchema = z.discriminatedUnion("ok", [
 export function validateBrowserControlIdentity(value) {
     const parsed = identitySchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     return parsed.data;
 }
 export function sameBrowserControlIdentity(a, b) {
@@ -230,41 +230,41 @@ export function sameBrowserControlIdentity(a, b) {
 export function parseBrowserControlRequest(value) {
     const parsed = requestSchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     const request = parsed.data;
     if (request.requestId !== `request-${request.seq}` ||
         (request.operation === "EXECUTE" && request.actionId !== `action-${request.seq}`))
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     return request;
 }
 export function parseBrowserControlReply(value) {
     const parsed = replySchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     const reply = parsed.data;
     if ((reply.operation === "EXECUTE") !== (reply.actionId !== undefined) ||
         (reply.ok &&
             ((reply.operation === "OBSERVE") !== (reply.observation !== undefined) ||
                 (reply.operation === "FINISH_RECORDING") !== (reply.recording !== undefined))))
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     return reply;
 }
 export function validateBrowserControlAction(value) {
     const parsed = wireActionSchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_request", "not_dispatched");
+        throw new ComputerUseExecutorError("invalid_request", "not_dispatched");
     return parsed.data;
 }
 export function validateHeardSpeech(value) {
     const parsed = heardSpeechListSchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     return parsed.data;
 }
 /** Check dimensions before allocating decoder output; v1 accepts browser-style 8-bit, noninterlaced PNG. */
 export function validateBrowserControlPng(bytes) {
     const fail = () => {
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     };
     if (bytes.length < 45 ||
         bytes.length > BROWSER_CONTROL_LIMITS.pngBytes ||
@@ -316,7 +316,7 @@ export function encodeBrowserControlObservation(observation) {
     if (!observation ||
         observation.appState !== undefined ||
         !Buffer.isBuffer(observation.screenshot))
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     validateBrowserControlPng(observation.screenshot);
     const parsed = observationSchema.safeParse({
         png: observation.screenshot.toString("base64"),
@@ -328,17 +328,17 @@ export function encodeBrowserControlObservation(observation) {
         ...(observation.heardSpeech !== undefined ? { heardSpeech: observation.heardSpeech } : {}),
     });
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     return parsed.data;
 }
 export function decodeBrowserControlObservation(value) {
     const parsed = observationSchema.safeParse(value);
     if (!parsed.success)
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     const { png, ...state } = parsed.data;
     const screenshot = Buffer.from(png, "base64");
     if (screenshot.toString("base64") !== png)
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     validateBrowserControlPng(screenshot);
     return {
         screenshot,
@@ -351,7 +351,7 @@ export function decodeBrowserControlObservation(value) {
     };
 }
 export function safeBrowserControlFailure(error, dispatched) {
-    if (isCuaExecutorError(error))
+    if (isComputerUseExecutorError(error))
         return { code: error.code, disposition: error.disposition };
     return {
         code: "action_rejected",

package/dist/browser-control/recording-transfer.js

@@ -1,6 +1,6 @@
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { CuaExecutorError } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError } from "../actors/computer-use/executor-error.js";
 import { DESKTOP_RECORDING_MAX_BYTES } from "../evidence/desktop-recording-types.js";
 const BROWSER_CONTROL_RECORDING_TRANSFER_TIMEOUT_MS = 120_000;
 function exactBytes(expected) {
@@ -17,7 +17,7 @@ function exactBytes(expected) {
 }
 function validLength(bytes) {
     if (!Number.isSafeInteger(bytes) || bytes < 1 || bytes > DESKTOP_RECORDING_MAX_BYTES) {
-        throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+        throw new ComputerUseExecutorError("invalid_response", "outcome_uncertain");
     }
 }
 export async function receiveBrowserControlRecording(source, destination, bytes) {
@@ -28,7 +28,7 @@ export async function receiveBrowserControlRecording(source, destination, bytes)
         });
     }
     catch {
-        throw new CuaExecutorError("transport_failed", "outcome_uncertain");
+        throw new ComputerUseExecutorError("transport_failed", "outcome_uncertain");
     }
 }
 export async function sendBrowserControlRecording(source, destination, bytes) {
@@ -43,6 +43,6 @@ export async function sendBrowserControlRecording(source, destination, bytes) {
     }
     catch {
         destination.destroy();
-        throw new CuaExecutorError("transport_failed", "outcome_uncertain");
+        throw new ComputerUseExecutorError("transport_failed", "outcome_uncertain");
     }
 }

package/dist/browser-control/transport.js

@@ -1,6 +1,6 @@
 import { TextDecoder } from "node:util";
 import { BROWSER_CONTROL_LIMITS } from "./protocol.js";
-import { CuaExecutorError, } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError, } from "../actors/computer-use/executor-error.js";
 /** Owned byte channel only. This module never discovers endpoints or reconnects. */
 export class BrowserControlTransport {
     stream;
@@ -92,7 +92,7 @@ export class BrowserControlTransport {
     /** Relinquish the live byte stream synchronously after a complete frame. */
     handoff() {
         if (this.ended || this.handedOff || this.payload !== undefined || this.headerUsed !== 0) {
-            throw new CuaExecutorError("transport_failed", "outcome_uncertain");
+            throw new ComputerUseExecutorError("transport_failed", "outcome_uncertain");
         }
         this.handedOff = true;
         clearTimeout(this.frameTimer);
@@ -112,9 +112,9 @@ export class BrowserControlTransport {
     };
     send(value, beforeWrite = () => { }) {
         if (this.ended || this.handedOff)
-            return Promise.reject(new CuaExecutorError("executor_closed", "not_dispatched"));
+            return Promise.reject(new ComputerUseExecutorError("executor_closed", "not_dispatched"));
         if (this.sending)
-            return Promise.reject(new CuaExecutorError("executor_busy", "not_dispatched"));
+            return Promise.reject(new ComputerUseExecutorError("executor_busy", "not_dispatched"));
         let payload;
         try {
             const json = JSON.stringify(value);
@@ -123,7 +123,7 @@ export class BrowserControlTransport {
             payload = Buffer.from(json);
         }
         catch {
-            return Promise.reject(new CuaExecutorError("invalid_request", "not_dispatched"));
+            return Promise.reject(new ComputerUseExecutorError("invalid_request", "not_dispatched"));
         }
         const frame = Buffer.allocUnsafe(4 + payload.length);
         frame.writeUInt32BE(payload.length);
@@ -144,7 +144,7 @@ export class BrowserControlTransport {
             try {
                 beforeWrite();
                 if (this.ended) {
-                    done(new CuaExecutorError("executor_closed", "not_dispatched"));
+                    done(new ComputerUseExecutorError("executor_closed", "not_dispatched"));
                     return;
                 }
                 this.stream.write(frame, (error) => {
@@ -178,7 +178,7 @@ export class BrowserControlTransport {
             this.stream.off("close", releaseListeners);
         };
         this.stream.once("close", releaseListeners);
-        this.pendingWrite?.(new CuaExecutorError(code, "outcome_uncertain"));
+        this.pendingWrite?.(new ComputerUseExecutorError(code, "outcome_uncertain"));
         this.stream.destroy();
         // A stream whose close event already happened will not emit it again. `closed`
         // can also precede queued error/close events, so defer removal past native ticks.

package/dist/cli/commands/analysis-signals.d.ts

@@ -1,8 +1,8 @@
-import type { RunLabOptions } from "../../run-lab.js";
+import type { RunStudyOptions } from "../../run-study.js";
 import type { CliIo } from "../io.js";
 /**
  * Post-run analysis cancellation for the CLI: while analysis runs, SIGINT, SIGTERM and SIGHUP abort
  * it. The listeners exist only during analysis; before it, the run's own handlers
  * (run-signals.ts) hold the signals and hand them over here.
  */
-export declare function cliAnalysisOptions(io: Pick<CliIo, "writeErr">): Pick<RunLabOptions, "onEvent" | "analysisSignal">;
+export declare function cliAnalysisOptions(io: Pick<CliIo, "writeErr">): Pick<RunStudyOptions, "onEvent" | "analysisSignal">;