humanish 0.108.0 → 0.109.1

package/dist/comms/external-evidence.js

@@ -4,10 +4,11 @@
 // shape for pattern redaction to find.
 import { redactText, toErrorMessage } from "../evidence/redaction.js";
 import { scrubSecretValues } from "../evidence/secret-scrub.js";
-import { addressedRecipients } from "../lab/parse/comms.js";
+import { addressedRecipients } from "../study/parse/comms.js";
 import { writeContainedOutputFile } from "../run/contained-output.js";
 import { FakeInbox } from "./fake-inbox.js";
 import { collectExternalCommsThread } from "./sandbox-catch.js";
+import { plural } from "../run/text.js";
 /**
  * The shortest catch bearer token humanish uses. The token guards GET /deliveries on a host the run
  * reaches over the network, so it must not be guessable: 16 random base64 characters are 96 bits.
@@ -33,7 +34,7 @@ export function catchTokenRefusal(token) {
         return undefined;
     return `The comms catch token is ${token.length} characters; it must be at least ${MIN_CATCH_TOKEN_LENGTH}, such as the output of \`openssl rand -hex 16\`, on the catch and in the run.`;
 }
-/** The catch token the run sends: the value of `authTokenEnv`, when the lab names one. */
+/** The catch token the run sends: the value of `authTokenEnv`, when the study names one. */
 export function catchTokenOf(external, env) {
     return external.authTokenEnv === undefined ? undefined : env[external.authTokenEnv];
 }
@@ -73,7 +74,7 @@ export async function collectExternalCommsEvidence(args) {
         if (collected.captured > 0) {
             return {
                 warnings: scrubbed([
-                    `The email catch captured ${collected.captured} email send(s), but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`,
+                    `The email catch captured ${plural(collected.captured, "email send")}, but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`,
                 ]),
             };
         }

package/dist/comms/fake-inbox.d.ts

@@ -21,11 +21,11 @@ export declare class FakeInbox implements CommsChannel {
     constructor(options?: FakeInboxOptions);
     provision(participantId: string): Promise<CommsAddress>;
     /**
-     * Provision an inbox for `participantId` at an explicit address (a lab-declared recipient), so
+     * Provision an inbox for `participantId` at an explicit address (a study-declared recipient), so
      * the app-under-test's send to that literal address resolves in `deliverRaw` (which drops
      * recipients with no provisioned inbox). Declaring the same address intentionally shares its
      * inbox; if `participantId` already held a different auto-generated address, the declared
-     * address supersedes it (the lab's declaration wins). Idempotent: re-declaring the same address
+     * address supersedes it (the study's declaration wins). Idempotent: re-declaring the same address
      * returns the existing inbox without clearing it.
      */
     provisionAddress(participantId: string, value: string): Promise<CommsAddress>;

package/dist/comms/fake-inbox.js

@@ -60,11 +60,11 @@ export class FakeInbox {
         return address;
     }
     /**
-     * Provision an inbox for `participantId` at an explicit address (a lab-declared recipient), so
+     * Provision an inbox for `participantId` at an explicit address (a study-declared recipient), so
      * the app-under-test's send to that literal address resolves in `deliverRaw` (which drops
      * recipients with no provisioned inbox). Declaring the same address intentionally shares its
      * inbox; if `participantId` already held a different auto-generated address, the declared
-     * address supersedes it (the lab's declaration wins). Idempotent: re-declaring the same address
+     * address supersedes it (the study's declaration wins). Idempotent: re-declaring the same address
      * returns the existing inbox without clearing it.
      */
     async provisionAddress(participantId, value) {

package/dist/comms/receiving-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { LabConfig } from "../lab/types.js";
+import type { StudyConfig } from "../study/types.js";
 import { type CommsConnection } from "./connections.js";
 import { type KeyResolutionDeps } from "../keys/key-resolution.js";
 import type { ReceivingAdapter } from "./receiving-types.js";
@@ -14,9 +14,9 @@ export declare function resolveReceivingConnection(cwd: string, name: string, en
     apiKey: string;
     adapter: ReceivingAdapter;
 }>;
-/** What receiving reads from a lab: its email declaration and the subject env it guards. */
+/** What receiving reads from a study: its email declaration and the subject env it guards. */
 export interface ReceivingSource {
-    readonly comms?: LabConfig["comms"];
+    readonly comms?: StudyConfig["comms"];
     readonly subject: {
         readonly env?: readonly string[];
         readonly envValues?: Readonly<Record<string, string>>;
@@ -32,7 +32,7 @@ export declare function prepareReceivingRun(args: {
     registerSecrets(values: string[]): void;
 }): Promise<import("./receiving.js").CommsReceivingRun | undefined>;
 /** The restriction survives restarts and screenshot redaction; it is not a claim of local processing. */
-export declare function receivingPublication(config: Pick<LabConfig, "comms">, dryRun: boolean): {
+export declare function receivingPublication(config: Pick<StudyConfig, "comms">, dryRun: boolean): {
     publication: {
         restrictions: ["real-communications"];
     };

package/dist/comms/sandbox-catch.d.ts

@@ -78,7 +78,7 @@ export declare function drainCommsCatch(shell: Shell, deployed: Pick<DeployedCom
 export declare function parseDeliveriesNdjson(text: string): RawCapturedSend[];
 /**
  * The distinct `to` addresses the captured mail was actually sent to, parsed with the same profiles
- * that route it. A lab run knows its recipients from the declared roster; a standalone catch does not,
+ * that route it. A run knows its recipients from the declared roster; a standalone catch does not,
  * so it discovers them from the mail itself. Otherwise an operator who forgot to name an address gets
  * a technically-healthy catch rendering an empty inbox forever: a false green.
  */
@@ -139,7 +139,7 @@ export declare function externalInboxUrl(external: ExternalCommsCatch): string;
 /**
  * Probe an adopter-hosted catch the way the in-sandbox one is probed: assert humanish's service marker in
  * /health, not merely any 2xx: an adopter's reverse proxy or a captive portal will happily return
- * 200 for anything, and a comms lab whose catch is not actually there collects nothing while
+ * 200 for anything, and a comms study whose catch is not actually there collects nothing while
  * looking fine. Fail-closed callers treat `false` as a hard stop before spending on a run.
  */
 export declare function externalCatchHealthy(external: ExternalCommsCatch, options?: {

package/dist/comms/sandbox-catch.js

@@ -171,7 +171,7 @@ export function parseDeliveriesNdjson(text) {
 }
 /**
  * The distinct `to` addresses the captured mail was actually sent to, parsed with the same profiles
- * that route it. A lab run knows its recipients from the declared roster; a standalone catch does not,
+ * that route it. A run knows its recipients from the declared roster; a standalone catch does not,
  * so it discovers them from the mail itself. Otherwise an operator who forgot to name an address gets
  * a technically-healthy catch rendering an empty inbox forever: a false green.
  */
@@ -298,7 +298,7 @@ export function externalInboxUrl(external) {
 /**
  * Probe an adopter-hosted catch the way the in-sandbox one is probed: assert humanish's service marker in
  * /health, not merely any 2xx: an adopter's reverse proxy or a captive portal will happily return
- * 200 for anything, and a comms lab whose catch is not actually there collects nothing while
+ * 200 for anything, and a comms study whose catch is not actually there collects nothing while
  * looking fine. Fail-closed callers treat `false` as a hard stop before spending on a run.
  */
 export async function externalCatchHealthy(external, options = {}) {

package/dist/comms/setup.d.ts

@@ -55,9 +55,9 @@ export interface CommsConfigureResult {
     connection?: string;
 }
 /** Save a local copy, never rewrite a committed manifest or silently shadow it by handle. */
-export declare function configureCommsLab(args: {
+export declare function configureCommsStudy(args: {
     cwd: string;
-    lab: string;
+    study: string;
     connection: string;
     apply?: boolean;
     planToken?: string;

package/dist/comms/setup.js

@@ -8,11 +8,10 @@ import { discoverProviderKeys, listUserKeys, probeKeySources, } from "../keys/ke
 import { COMMS_PROVIDERS, commsProviderLabel, DEFAULT_COMMS_PROVIDER, } from "./providers.js";
 import { createReceivingAdapter } from "./receiving-runtime.js";
 import { RECEIVING_SCOPE_UNSUPPORTED } from "./receiving-types.js";
-import { parseLabConfig } from "../lab/config.js";
-import { resolveLabManifest } from "../lab/discover.js";
+import { parseStudy } from "../study/config.js";
+import { resolveStudyManifest } from "../study/discover.js";
 import { assertPreparedSelectedOutputDirectory, prepareManagedHumanishOutputDirectory, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile, } from "../run/contained-output.js";
 import { otherStudyFiles } from "../study/files.js";
-import { convertStudyText, isStudyV3 } from "../study/convert.js";
 import { isNodeError } from "../run/type-guards.js";
 export async function checkCommsConnection(args) {
     const base = {
@@ -109,65 +108,63 @@ export async function receivingRequiredKey(cwd, connectionName) {
     }
 }
 /** Save a local copy, never rewrite a committed manifest or silently shadow it by handle. */
-export async function configureCommsLab(args) {
+export async function configureCommsStudy(args) {
     const base = { schema: "humanish.comms-configure.v1", ok: false, applied: false };
     try {
         const connection = (await readCommsConnections(args.cwd)).connections[args.connection];
         if (!connection)
             return { ...base, message: "Save the selected connection first." };
-        const source = await resolveLabManifest(args.cwd, args.lab);
-        if (!source.ok)
-            return { ...base, message: "The selected lab could not be read safely." };
+        const source = await resolveStudyManifest(args.cwd, args.study);
+        if (!source.ok) {
+            // A v2 source or a labs/ file gets discovery's refusal, which names the fix.
+            const named = source.error.code === "HUMANISH_STUDY_V2_UNSUPPORTED" ||
+                source.error.code === "HUMANISH_STUDY_RETIRED_DIRECTORY";
+            return {
+                ...base,
+                message: named ? source.error.message : "The selected study could not be read safely.",
+            };
+        }
         const root = await prepareSelectedOutputDirectory(args.cwd, args.cwd);
         const rel = path
             .relative(root.requestedPath, path.resolve(args.cwd, source.path))
             .replace(/\\/g, "/");
         const bytes = await readContainedRegularFile(root, rel);
         if (!bytes || bytes.length > 1024 * 1024)
-            return { ...base, message: "The lab is missing or too large." };
+            return { ...base, message: "The study file is missing or too large." };
         const text = bytes.toString("utf8");
         const raw = parse(text);
         if (!raw || typeof raw !== "object" || Array.isArray(raw))
-            return { ...base, message: "The lab must be a mapping." };
-        const lab = raw;
-        const existing = lab.comms;
+            return { ...base, message: "The study file must be a mapping." };
+        const studyRecord = raw;
+        const existing = studyRecord.comms;
         if (existing?.email && existing.email.connection === undefined)
             return {
                 ...base,
-                message: "This lab uses local capture. Preserve it or make a separate lab before selecting real email.",
+                message: "This study uses local capture. Preserve it or make a separate study before selecting real email.",
             };
-        // The copy is a v3 study. A v2 source is converted first, so the copy keeps its comments.
-        let studyText = text;
-        if (!isStudyV3(raw)) {
-            const converted = convertStudyText(text, args.cwd);
-            if (!converted.ok)
-                return {
-                    ...base,
-                    message: `This lab could not be converted to a v3 study: ${converted.reason}`,
-                };
-            studyText = converted.conversion.text;
-        }
-        const study = parseDocument(studyText);
+        // Discovery resolved the source, so it is a v3 study, and the copy keeps its comments.
+        const study = parseDocument(text);
         study.setIn(["comms", "email", "connection"], args.connection);
-        const validated = parseLabConfig(study.toJS());
+        const validated = parseStudy(study.toJS());
         if (!validated.ok)
             return {
                 ...base,
-                message: "This lab does not support real email receiving. Use a hosted computer-use app-url, clone or local-tree route; shared-world must be concurrent.",
+                message: "This study does not support real email receiving. Use a hosted computer-use app-url, clone or local-tree route; shared-world must be concurrent.",
             };
         const filename = path
             .basename(source.path)
             .replace(/\.ya?ml$/, "")
             .replace(/-receiving$/, "") + "-receiving.yaml";
         if (!/^[A-Za-z0-9_][A-Za-z0-9._-]{0,110}\.yaml$/.test(filename))
-            return { ...base, message: "Use a simple lab filename before configuring email." };
+            return { ...base, message: "Use a simple study filename before configuring email." };
         const destination = `.humanish/local/studies/${filename}`;
         if (path.basename(rel) === filename)
             return {
                 ...base,
-                message: "This is already the local receiving copy. Select its original lab to configure a separate copy, or edit this manifest directly.",
+                message: "This is already the local receiving copy. Select its original study to configure a separate copy, or edit this study file directly.",
             };
-        // A second file with this name in another study directory would make discovery refuse both.
+        // A second file with this name in another study directory would shadow it, or take the name
+        // migrate needs to move a labs/ file.
         const stem = filename.replace(/\.yaml$/, "");
         const others = await otherStudyFiles(stem, 
         // Any directory entry counts, a dangling symbolic link included: discovery would see it too.
@@ -215,7 +212,7 @@ export async function configureCommsLab(args) {
         if (args.planToken !== undefined && args.planToken !== token)
             return {
                 ...base,
-                message: "The lab or destination changed since preview. Preview again before saving.",
+                message: "The study or destination changed since preview. Preview again before saving.",
             };
         const directory = await prepareManagedHumanishOutputDirectory(args.cwd, "local", "studies");
         const lockPath = path.join(directory.physicalPath, ".comms-configure.lock");
@@ -239,13 +236,13 @@ export async function configureCommsLab(args) {
         return {
             ...plan,
             applied: true,
-            message: `Saved ${destination}. Start that exact lab path; the original manifest was preserved.`,
+            message: `Saved ${destination}. Start that exact study path; the original file was preserved.`,
         };
     }
     catch {
         return {
             ...base,
-            message: "Could not configure this lab safely. Check configuration, paths and permissions; no provider resources were created.",
+            message: "Could not configure this study safely. Check configuration, paths and permissions; no provider resources were created.",
         };
     }
 }

package/dist/evidence/redaction.d.ts

@@ -2,6 +2,17 @@
 export declare function sensitivePatterns(): readonly RegExp[];
 /** True if the text contains any secret-shaped token or known local path. */
 export declare function containsSensitive(text: string): boolean;
+/**
+ * What a shared copy of a run says in place of a provider sandbox id. scripts/public-surface-scan.mjs
+ * passes only this value at a sandbox-id key.
+ */
+export declare const REDACTED_SANDBOX_ID = "[redacted-sandbox-id]";
+/**
+ * `value` with every sandbox id replaced by REDACTED_SANDBOX_ID: strings at `sandboxId` and
+ * `subjectSandboxId`, and the `id` of each `providerResources` entry. A run keeps raw ids as local
+ * evidence for cleanup; a copy made to be shared names no sandbox.
+ */
+export declare function redactSandboxIds(value: unknown): unknown;
 /** Redact secrets to [REDACTED_SECRET] and local paths to their path labels. */
 export declare function redactText(text: string): string;
 /** Redact every sensitive match (secrets and paths) to a single [REDACTED_SECRET] label. */

package/dist/evidence/redaction.js

@@ -55,6 +55,49 @@ export function containsSensitive(text) {
 function redactLocalPaths(text, label) {
     return LOCAL_PATH_PATTERNS.reduce((current, [pattern, replacement]) => current.replace(pattern, (match) => (label ?? replacement) + (match.match(/\\+$/)?.[0] ?? "")), text);
 }
+/**
+ * What a shared copy of a run says in place of a provider sandbox id. scripts/public-surface-scan.mjs
+ * passes only this value at a sandbox-id key.
+ */
+export const REDACTED_SANDBOX_ID = "[redacted-sandbox-id]";
+/** The keys run writers put a sandbox id under; `providerResources` entries hold one as `id`. */
+const SANDBOX_ID_KEYS = new Set(["sandboxId", "subjectSandboxId"]);
+/**
+ * `value` with every sandbox id replaced by REDACTED_SANDBOX_ID: strings at `sandboxId` and
+ * `subjectSandboxId`, and the `id` of each `providerResources` entry. A run keeps raw ids as local
+ * evidence for cleanup; a copy made to be shared names no sandbox.
+ */
+export function redactSandboxIds(value) {
+    if (Array.isArray(value)) {
+        const items = value.map(redactSandboxIds);
+        return items.every((item, index) => item === value[index]) ? value : items;
+    }
+    if (value === null || typeof value !== "object")
+        return value;
+    let changed = false;
+    // fromEntries keeps a key such as __proto__ an own property, as JSON.parse made it.
+    const entries = Object.entries(value).map(([key, child]) => {
+        let next;
+        if (SANDBOX_ID_KEYS.has(key) && typeof child === "string")
+            next = REDACTED_SANDBOX_ID;
+        else if (key === "providerResources" && Array.isArray(child))
+            next = child.map((resource) => resource !== null &&
+                typeof resource === "object" &&
+                !Array.isArray(resource) &&
+                "id" in resource
+                ? Object.fromEntries(Object.entries(redactSandboxIds(resource)).map(([field, entry]) => [
+                    field,
+                    field === "id" ? REDACTED_SANDBOX_ID : entry,
+                ]))
+                : redactSandboxIds(resource));
+        else
+            next = redactSandboxIds(child);
+        if (next !== child && JSON.stringify(next) !== JSON.stringify(child))
+            changed = true;
+        return [key, next];
+    });
+    return changed ? Object.fromEntries(entries) : value;
+}
 /** Redact secrets to [REDACTED_SECRET] and local paths to their path labels. */
 export function redactText(text) {
     const withoutSecrets = SECRET_PATTERNS.reduce((current, pattern) => current.replace(pattern, "[REDACTED_SECRET]"), text);

package/dist/feedback/draft.js

@@ -100,7 +100,7 @@ export function buildDraft(bundle, bundlePath, candidateId) {
         proposed_next_state: "study-quality-review",
         acceptance_proof: [
             feedbackProofCommands(bundle.runId).verify,
-            feedbackProofCommands(bundle.runId).watch,
+            feedbackProofCommands(bundle.runId).observe,
         ],
     };
 }
@@ -192,7 +192,7 @@ export async function buildAnalysisDraft(context, options) {
         proposed_next_state: "study-quality-review",
         acceptance_proof: [
             feedbackProofCommands(bundle.runId).verify,
-            feedbackProofCommands(bundle.runId).watch,
+            feedbackProofCommands(bundle.runId).observe,
         ],
     };
 }

package/dist/feedback/export-bundle.js

@@ -8,7 +8,7 @@ import { parse as parseYaml } from "yaml";
 import { ACTOR_TRACE_SCHEMA } from "../actors/contract.js";
 import { renderObserver } from "../observer/render.js";
 import { buildObserverData } from "../observer/data.js";
-import { containsSensitive, redactScreenshot, redactText } from "../evidence/redaction.js";
+import { containsSensitive, redactSandboxIds, redactScreenshot, redactText, } from "../evidence/redaction.js";
 import { decodeEscapes } from "../evidence/encoded-text.js";
 import { readPlainText } from "../evidence/plain-text.js";
 import { streamScreenshotPaths } from "../verify/artifacts.js";
@@ -224,7 +224,8 @@ function transformText(file, imagePaths) {
         const parsed = JSON.parse(text);
         // Parsing also resolves escape sequences in string values before inspection.
         assertNoInlineRaster(JSON.stringify(parsed));
-        const transformed = updateScreenshotDeclarations(parsed, imagePaths);
+        // The copy names no sandbox: an id is local operational evidence, and the copy is shared.
+        const transformed = redactSandboxIds(updateScreenshotDeclarations(parsed, imagePaths));
         if (JSON.stringify(transformed) === JSON.stringify(parsed))
             return file.bytes;
         assertRewritableNumbers(text);
@@ -237,7 +238,7 @@ function transformText(file, imagePaths) {
                 return line;
             const parsed = JSON.parse(line);
             assertNoInlineRaster(JSON.stringify(parsed));
-            const updated = JSON.stringify(updateScreenshotDeclarations(parsed, imagePaths));
+            const updated = JSON.stringify(redactSandboxIds(updateScreenshotDeclarations(parsed, imagePaths)));
             if (updated === JSON.stringify(parsed))
                 return line;
             assertRewritableNumbers(line);
@@ -329,7 +330,7 @@ async function writeDerivative(source, stagePaths, bundle) {
             bytes = transformText(file, imagePaths);
             if (file.path === "run.json") {
                 assertRewritableNumbers(file.bytes.toString("utf8"));
-                const transformed = updateScreenshotDeclarations(bundle, imagePaths);
+                const transformed = redactSandboxIds(updateScreenshotDeclarations(bundle, imagePaths));
                 transformed.redaction = {
                     status: "passed",
                     notes: `${bundle.redaction.notes} Exported copy: screenshots were blurred during export; the original capture is retained separately. See derivation.json.`,

package/dist/feedback/export.js

@@ -23,6 +23,7 @@ import { analysisSharingProblems } from "../analysis/sharing.js";
 import { EVIDENCE_LIMITS, validateAnalysisEvidence } from "../analysis/evidence.js";
 import { readBoundedFile } from "../run/evidence-files.js";
 import { shellQuote } from "../substrates/shell.js";
+import { plural } from "../run/text.js";
 const EXPORT_SCHEMA = "humanish.export-result.v1";
 /** Past this the file stops being a thing you attach to an email. Declared, never silent. */
 export const DEFAULT_EXPORT_MAX_BYTES = 25 * 1024 * 1024;
@@ -361,7 +362,7 @@ export function formatExportHuman(result) {
     if (result.format === "bundle") {
         return [
             `humanish export ${result.runId}`,
-            `workspace: ${result.path} (${(result.bytes / 1024).toFixed(0)} KB, ${result.embeddedImages} blurred image(s))`,
+            `workspace: ${result.path} (${(result.bytes / 1024).toFixed(0)} KB, ${plural(result.embeddedImages, "blurred image")})`,
             `share safety: ${result.shareSafety.status}`,
             `verify: humanish verify --cwd ${shellQuote(result.path)} --run ${shellQuote(result.runId)}`,
             `feedback: humanish feedback draft --cwd ${shellQuote(result.path)} --run ${shellQuote(result.runId)}`,
@@ -371,7 +372,7 @@ export function formatExportHuman(result) {
     }
     const lines = [
         `humanish export ${result.runId}`,
-        `file: ${result.path} (${(result.bytes / 1024).toFixed(0)} KB, ${result.embeddedImages} image(s) embedded)`,
+        `file: ${result.path} (${(result.bytes / 1024).toFixed(0)} KB, ${plural(result.embeddedImages, "image")} embedded)`,
         `share safety: ${result.shareSafety.status}${result.watermarked ? " (watermarked: local only)" : ""}`,
         ...result.warnings.map((warning) => `warning: ${warning}`),
     ];

package/dist/feedback/proof.d.ts

@@ -2,7 +2,7 @@ import type { RunBundle, RunFeedbackCandidate } from "../run/bundle.js";
 /** Commands run from the evidence workspace using an installed humanish CLI. */
 export declare function feedbackProofCommands(runId: string): {
     verify: string;
-    watch: string;
+    observe: string;
 };
 /** Legacy command compatibility belongs in the draft, never in the source receipt. */
 export declare function projectFeedbackAcceptanceProof(bundle: RunBundle, candidate: RunFeedbackCandidate): string[];

package/dist/feedback/proof.js

@@ -5,7 +5,7 @@ export function feedbackProofCommands(runId) {
     const argument = /^[a-z0-9][a-z0-9._-]*$/i.test(runId) ? runId : shellQuote(runId);
     return {
         verify: `humanish verify --run ${argument} --json`,
-        watch: `humanish watch --run ${argument} --no-open`,
+        observe: `humanish observe --run ${argument} --no-open`,
     };
 }
 /** Legacy command compatibility belongs in the draft, never in the source receipt. */
@@ -17,7 +17,7 @@ export function projectFeedbackAcceptanceProof(bundle, candidate) {
         if (instruction === `pnpm humanish -- verify --run ${bundle.runId} --json`)
             return commands.verify;
         if (instruction === `pnpm humanish -- watch --run ${bundle.runId} --no-open`)
-            return commands.watch;
+            return commands.observe;
         return instruction;
     });
 }

package/dist/guest/bootstrap.js

@@ -1,6 +1,6 @@
 import { desktopRecordingConfigSchema, } from "../evidence/desktop-recording-types.js";
 import { validateBrowserControlIdentity, sameBrowserControlIdentity, } from "../browser-control/protocol.js";
-import { CuaExecutorError } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError } from "../actors/computer-use/executor-error.js";
 import { createBrowserControlClient } from "../browser-control/client.js";
 import { guestMediaConfigSchema } from "./media-config.js";
 export const GUEST_BOOTSTRAP_VERSION = 1;
@@ -15,7 +15,7 @@ export const GUEST_BOOTSTRAP_LIMITS = Object.freeze({
     connectMs: 3000,
     port: 5251,
 });
-const refused = () => new CuaExecutorError("protocol_mismatch", "not_dispatched");
+const refused = () => new ComputerUseExecutorError("protocol_mismatch", "not_dispatched");
 /** Same entry authority as the local desktop's opaque app-port forward. */
 export function validateGuestInitialUrl(value) {
     try {
@@ -223,7 +223,7 @@ export class GuestBootstrapReader {
             return;
         this.terminal = true;
         this.release();
-        this.reject(new CuaExecutorError(code, "not_dispatched"));
+        this.reject(new ComputerUseExecutorError(code, "not_dispatched"));
         this.stream.destroy();
         this.onFailure();
     }
@@ -249,7 +249,7 @@ export async function connectGuestBootstrap(stream, identity, signal, initialUrl
     const request = encodeGuestBootstrap(identity, false, initialUrl, media, recording);
     await new Promise((resolve, reject) => {
         let bytes = Buffer.alloc(0), done = false;
-        const timer = setTimeout(() => finish(new CuaExecutorError("deadline_exceeded", "not_dispatched")), GUEST_BOOTSTRAP_LIMITS.connectMs);
+        const timer = setTimeout(() => finish(new ComputerUseExecutorError("deadline_exceeded", "not_dispatched")), GUEST_BOOTSTRAP_LIMITS.connectMs);
         const finish = (error) => {
             if (done)
                 return;
@@ -277,9 +277,9 @@ export async function connectGuestBootstrap(stream, identity, signal, initialUrl
         const end = () => {
             if (done)
                 stream.destroy();
-            finish(new CuaExecutorError("transport_failed", "not_dispatched"));
+            finish(new ComputerUseExecutorError("transport_failed", "not_dispatched"));
         };
-        const abort = () => finish(new CuaExecutorError("session_revoked", "not_dispatched"));
+        const abort = () => finish(new ComputerUseExecutorError("session_revoked", "not_dispatched"));
         const data = (chunk) => {
             if (!Buffer.isBuffer(chunk) || bytes.length + chunk.length > 64 + 1028) {
                 finish(refused());

package/dist/guest/browser-tools.js

@@ -1,5 +1,5 @@
 import { BROWSER_CONTROL_LIMITS } from "../browser-control/protocol.js";
-import { CuaExecutorError, isCuaExecutorError } from "../actors/computer-use/executor-error.js";
+import { ComputerUseExecutorError, isComputerUseExecutorError, } from "../actors/computer-use/executor-error.js";
 /** Owner-only composition for a single headed Chromium page. Never an actor API. */
 export function createGuestBrowserTools(native, content) {
     let addressBarArmed = false;
@@ -11,7 +11,7 @@ export function createGuestBrowserTools(native, content) {
             const inputGeneration = ++generation;
             await native.input(args, signal);
             if (signal.aborted || inputGeneration !== generation)
-                throw new CuaExecutorError("session_revoked", "outcome_uncertain");
+                throw new ComputerUseExecutorError("session_revoked", "outcome_uncertain");
             // Positive navigation intent, not an inference from document.hasFocus().
             addressBarArmed =
                 args.length === 3 &&
@@ -28,15 +28,15 @@ export function createGuestBrowserTools(native, content) {
             // separate qualification. Do not silently switch routes or transliterate.
             if (!/^[\x20-\x7e]+$/.test(text) ||
                 Buffer.byteLength(text) > BROWSER_CONTROL_LIMITS.textBytes) {
-                throw new CuaExecutorError("action_rejected", "not_dispatched");
+                throw new ComputerUseExecutorError("action_rejected", "not_dispatched");
             }
             const preparedGeneration = generation;
             let used = false;
             function check() {
                 if (signal.aborted)
-                    throw new CuaExecutorError("session_revoked", "not_dispatched");
+                    throw new ComputerUseExecutorError("session_revoked", "not_dispatched");
                 if (used || preparedGeneration !== generation)
-                    throw new CuaExecutorError("action_rejected", "not_dispatched");
+                    throw new ComputerUseExecutorError("action_rejected", "not_dispatched");
             }
             check();
             await content.assertReady(signal);
@@ -52,15 +52,15 @@ export function createGuestBrowserTools(native, content) {
                     try {
                         await native.input(["key", "--clearmodifiers", "ctrl+l"], signal);
                         if (signal.aborted)
-                            throw new CuaExecutorError("session_revoked", "outcome_uncertain");
+                            throw new ComputerUseExecutorError("session_revoked", "outcome_uncertain");
                         await content.assertReady(signal);
                         if (signal.aborted || preparedGeneration !== generation)
-                            throw new CuaExecutorError("session_revoked", "outcome_uncertain");
+                            throw new ComputerUseExecutorError("session_revoked", "outcome_uncertain");
                         await native.typeAscii(text, signal);
                     }
                     catch (error) {
                         // Ctrl+L itself is input. No content fallback after that dispatch.
-                        throw new CuaExecutorError(isCuaExecutorError(error) ? error.code : "execution_failed", "outcome_uncertain");
+                        throw new ComputerUseExecutorError(isComputerUseExecutorError(error) ? error.code : "execution_failed", "outcome_uncertain");
                     }
                 },
                 async close() {