humanish 0.106.0 → 0.107.0

package/dist/run-lab.d.ts

@@ -1,13 +1,14 @@
-import type { AutomaticAnalysisHooks } from "./analysis/automatic-completion.js";
+import type { LocalVmInput } from "./routes/computer-use/types.js";
 import { type LateScorer } from "./lab/route-inputs.js";
-import { type LabBackend, type LabRoute } from "./lab/plan.js";
-import { type RunLabDriving, type RunLabHomes } from "./lab/run-lab-options.js";
+import { type LabRoute } from "./lab/plan.js";
+import type { LabDeps } from "./lab/lab-deps.js";
+import type { RunLabDriving, RunLabHomes } from "./lab/run-lab-homes.js";
 import { type LabConfig } from "./lab/types.js";
 import type { ObserverResult } from "./observer/render.js";
-import { type CuaActorLabHooks, type CuaActorLabResult } from "./routes/computer-use/types.js";
-import { type ScriptedBrowserLabHooks, type ScriptedBrowserLabResult } from "./routes/scripted/types.js";
-import { type ConcurrentSharedWorldLabResult, type SharedWorldLabHooks } from "./routes/shared-world/types.js";
-import { type TerminalProductLabHooks, type TerminalProductLabResult } from "./routes/terminal/types.js";
+import { type CuaActorLabResult } from "./routes/computer-use/types.js";
+import { type ScriptedBrowserLabResult } from "./routes/scripted/types.js";
+import { type ConcurrentSharedWorldLabResult } from "./routes/shared-world/types.js";
+import { type TerminalProductLabResult } from "./routes/terminal/types.js";
 import { type RunScorerProvenance } from "./run/bundle.js";
 import { type RunResult } from "./run/results.js";
 import { type RunLabProvenance } from "./run/status.js";
@@ -16,7 +17,13 @@ import { type RunLabProvenance } from "./run/status.js";
  * hook bags before anything runs. Each route closes the run it started on every exit through its
  * own run scope (`src/run/run.ts`).
  */
-export declare function runLab(config: LabConfig, options: RunLabOptions): Promise<LabOutcome>;
+export declare function runLab(config: LabConfig, options: InternalRunLabOptions, deps?: LabDeps): Promise<LabOutcome>;
+/**
+ * runLab as the package exports it (`src/index.ts`): the public options only. A JavaScript caller
+ * that passes a field RunLabOptions no longer has is refused in the route's own result envelope
+ * before anything runs.
+ */
+export declare function runPackageLab(config: LabConfig, options: RunLabOptions): Promise<LabOutcome>;
 /** A lab planned once: the route's refusal, or the run of its plan. */
 export type PreparedLab = {
     readonly ok: false;
@@ -28,46 +35,41 @@ export type PreparedLab = {
 };
 /**
  * Normalizes the options and plans the lab once, so a caller can present a refusal before it loads
- * anything the run needs. A local browser study's desktop lane and provider are bound first, so the
- * plan is made with them; with createDesktopLane the caller provides the desktop, and with
- * buildExecutor it drives the app in process and needs none.
+ * anything the run needs. A local browser study's provider is bound first, so the plan is made with
+ * it, and its desktop goes to the computer-use run as `localVm`; with inProcess the caller drives
+ * the app in process and needs no desktop.
  */
-export declare function prepareLab(config: LabConfig, options: RunLabOptions): Promise<PreparedLab>;
+export declare function prepareLab(config: LabConfig, options: InternalRunLabOptions, deps?: LabDeps): Promise<PreparedLab>;
 /**
- * Runtime overrides from CLI flags, the typed homes (`RunLabHomes`, `RunLabDriving`) and the older
- * route hook bags they replace. Each wins over the config when provided.
+ * What a package caller passes to runLab: the run's settings and the typed homes (`RunLabHomes`,
+ * `RunLabDriving`). Each wins over the config when provided.
  */
 export type RunLabOptions = RunLabBase & RunLabHomes & RunLabDriving;
 interface RunLabBase {
-    automaticAnalysis?: AutomaticAnalysisHooks;
     cwd: string;
     runId?: string;
-    /** Which manifest this run came from (#455): threaded to the route so the run's own
-     *  status record and bundle can say which lab produced it. Absent for library callers who
-     *  hand a LabConfig directly — the run is then honestly lab-less rather than guessed. */
-    lab?: RunLabProvenance;
     dryRun?: boolean;
     open?: boolean;
     /** Participant count override: preview participants or computer-use desktops. */
     count?: number;
-    /** CUA fan-out only: create a new run for failed/selected lanes from a prior run. */
+    /** CUA fan-out only: create a new run for failed/selected participants from a prior run. */
     rerun?: {
         sourceRunId: string;
         participantIds?: string[];
-        /** @deprecated The older name of `participantIds`. */
-        laneIds?: string[];
     };
     onObserverReady?: (observer: ObserverResult & {
         ok: true;
     }) => Promise<void> | void;
-    /** Computer-use route hooks: subject provisioning (library callers) + test DI seams. */
-    cuaHooks?: CuaActorLabHooks;
-    /** Scripted-browser route hooks: browser injection + test DI seams (mirror of cuaHooks). */
-    scriptedHooks?: ScriptedBrowserLabHooks;
-    /** Terminal-product route hooks: sandbox/runtime-auth DI seams (mirror of cuaHooks). */
-    terminalHooks?: TerminalProductLabHooks;
-    /** Shared-world route hooks: sandbox / runSession / checkpoint DI seams (mirror of cuaHooks). */
-    sharedWorldHooks?: SharedWorldLabHooks;
+}
+/** runLab's options inside the package: the public ones plus what only the CLI and tests set. */
+export type InternalRunLabOptions = RunLabOptions & RunLabInternals;
+interface RunLabInternals {
+    /**
+     * Which manifest this run came from (#455). planLab puts it on the plan, and the route reads
+     * plan.lab for the run's status record and bundle. Absent for a library caller that passes a
+     * LabConfig directly; that run records no lab.
+     */
+    lab?: RunLabProvenance;
     /**
      * CONFIG-DECLARED scorer provenance (#316), forwarded alongside whichever hooks bag carries the
      * loaded scorer. Its presence is the "declared" marker the terminal route reads to flip a
@@ -75,15 +77,15 @@ interface RunLabBase {
      * (path + digest), never adopter-supplied; absent for library callers.
      */
     scorerProvenance?: RunScorerProvenance;
+    /** The local VM study's desktop, analysis gate and signal, for a local browser lab. */
+    localVm?: LocalVmInput;
 }
 /** A run's result and the route it ran on. */
-interface RouteOutcome<R extends LabRoute, B extends LabBackend, T> {
+interface RouteOutcome<R extends LabRoute, T> {
     route: R;
-    /** @deprecated The route's older name. Use `route`; this field goes in the next minor. */
-    backend: B;
     result: T;
 }
-export type LabOutcome = RouteOutcome<"preview", "synthetic", RunResult> | RouteOutcome<"computer-use", "cua", CuaActorLabResult> | RouteOutcome<"scripted", "scripted", ScriptedBrowserLabResult> | RouteOutcome<"terminal", "terminal", TerminalProductLabResult> | RouteOutcome<"shared-world", "concurrent-shared-world", ConcurrentSharedWorldLabResult>;
+export type LabOutcome = RouteOutcome<"preview", RunResult> | RouteOutcome<"computer-use", CuaActorLabResult> | RouteOutcome<"scripted", ScriptedBrowserLabResult> | RouteOutcome<"terminal", TerminalProductLabResult> | RouteOutcome<"shared-world", ConcurrentSharedWorldLabResult>;
 /**
  * A plan past its route's local checks that need no scorer: the refusal they returned, or the
  * route's run, which takes a scorer loaded after them.

package/dist/run-lab.js

@@ -6,10 +6,9 @@
 // refusal before it loads a declared review scorer.
 import { computerUseInput, scriptedInput, sharedWorldInput, terminalInput, } from "./lab/route-inputs.js";
 import { planLab, resolveLabDryRun, routeOf } from "./lab/plan.js";
-import { normalizeRunLabOptions, optionRefusalOutcome, } from "./lab/run-lab-options.js";
+import { normalizeRunLabOptions, optionRefusalOutcome, removedOptionRefusal, } from "./lab/run-lab-options.js";
 import {} from "./lab/types.js";
 import { admitComputerUsePlan, computerUseLabRefusal } from "./routes/computer-use/route.js";
-import { participantDesktopOf } from "./routes/computer-use/participant-desktop.js";
 import {} from "./routes/computer-use/types.js";
 import { admitPreviewPlan, previewLabRefusal } from "./routes/preview.js";
 import { admitScriptedPlan, scriptedLabRefusal } from "./routes/scripted/route.js";
@@ -27,40 +26,51 @@ import { isLocalBrowserLab, localBrowserDefaults } from "./substrates/local/runt
  * hook bags before anything runs. Each route closes the run it started on every exit through its
  * own run scope (`src/run/run.ts`).
  */
-export async function runLab(config, options) {
-    const prepared = await prepareLab(config, options);
+export async function runLab(config, options, deps = {}) {
+    const prepared = await prepareLab(config, options, deps);
     return prepared.ok ? prepared.run() : prepared.outcome;
 }
+/**
+ * runLab as the package exports it (`src/index.ts`): the public options only. A JavaScript caller
+ * that passes a field RunLabOptions no longer has is refused in the route's own result envelope
+ * before anything runs.
+ */
+export async function runPackageLab(config, options) {
+    const removed = removedOptionRefusal(options);
+    if (removed === undefined)
+        return runLab(config, options);
+    const lab = localBrowserDefaults(config);
+    return optionRefusalOutcome(lab, routeOf(lab), options, removed);
+}
 /**
  * Normalizes the options and plans the lab once, so a caller can present a refusal before it loads
- * anything the run needs. A local browser study's desktop lane and provider are bound first, so the
- * plan is made with them; with createDesktopLane the caller provides the desktop, and with
- * buildExecutor it drives the app in process and needs none.
+ * anything the run needs. A local browser study's provider is bound first, so the plan is made with
+ * it, and its desktop goes to the computer-use run as `localVm`; with inProcess the caller drives
+ * the app in process and needs no desktop.
  */
-export async function prepareLab(config, options) {
+export async function prepareLab(config, options, deps = {}) {
     const lab = localBrowserDefaults(config);
     const route = routeOf(lab);
     const normalized = normalizeRunLabOptions(lab, route, options);
     if (!normalized.ok)
         return { ok: false, outcome: optionRefusalOutcome(lab, route, options, normalized) };
-    const hooks = normalized.options.cuaHooks;
-    const localVm = isLocalBrowserLab(lab) &&
-        (hooks === undefined || participantDesktopOf(hooks) === undefined) &&
-        hooks?.buildExecutor === undefined
-        ? (await import("./routes/computer-use/local-vm.js")).prepareLocalVmStudy
+    // An in-process executor needs no desktop, and a caller that already prepared the study passes
+    // its localVm, which a second study would replace.
+    const prepareLocalVm = isLocalBrowserLab(lab) && options.inProcess === undefined && options.localVm === undefined
+        ? (await import("./routes/computer-use/local-vm.js")).prepareLocalVmRun
         : undefined;
-    const study = localVm?.({ ...normalized.options, config: lab });
-    const planning = study?.options ?? normalized.options;
-    const planned = planLab(lab, planning);
+    const vm = prepareLocalVm?.({ ...normalized.options, config: lab });
+    const planning = vm === undefined ? normalized.options : { ...vm.options, localVm: vm.localVm };
+    const planned = planLab(lab, planning, deps);
     if (!planned.ok) {
-        await study?.close();
-        const outcome = await refusalOutcome(lab, planning, planned.refusal);
+        await vm?.close();
+        const outcome = await refusalOutcome(lab, planning, planned.refusal, deps, normalized.emit);
         outcome.result.warnings.push(...normalized.warnings);
         return { ok: false, outcome };
     }
-    const admitted = await admitPlan(lab, planning, planned.planned.plan);
+    const admitted = await admitPlan(lab, planning, planned.planned.plan, deps, normalized.emit);
     if (!admitted.ok) {
-        await study?.close();
+        await vm?.close();
         admitted.outcome.result.warnings.push(...normalized.warnings);
         return { ok: false, outcome: admitted.outcome };
     }
@@ -88,61 +98,55 @@ export async function prepareLab(config, options) {
                 return outcome;
             }
             finally {
-                await study?.close();
+                await vm?.close();
             }
         },
     };
 }
 /** The route's admit function for a plan, with the route's input from the run's options. */
-async function admitPlan(config, options, plan) {
+async function admitPlan(config, options, plan, deps, emit) {
     switch (plan.route) {
         case "preview":
             return admitPreviewPlan(plan, options);
         case "computer-use":
-            return admitComputerUsePlan(plan, computerUseInput(options), config);
+            return admitComputerUsePlan(plan, computerUseInput(options, deps, emit), config);
         case "scripted":
-            return admitScriptedPlan(plan, scriptedInput(options));
+            return admitScriptedPlan(plan, scriptedInput(options, deps, emit));
         case "terminal":
-            return admitTerminalPlan(plan, terminalInput(options));
+            return admitTerminalPlan(plan, terminalInput(options, deps, emit));
         case "shared-world":
-            return admitSharedWorldPlan(plan, sharedWorldInput(options), config);
+            return admitSharedWorldPlan(plan, sharedWorldInput(options, deps, emit), config);
     }
 }
 /** The refused route's own result, with the envelope and analysis record its runner returns. */
-async function refusalOutcome(config, options, refusal) {
+async function refusalOutcome(config, options, refusal, deps, emit) {
     // Spend-safe default: a lab goes live only when the config (or CLI) says so.
     const dryRun = resolveLabDryRun(config, options.dryRun, true) ?? true;
-    const lab = options.lab === undefined ? {} : { lab: options.lab };
     switch (refusal.route) {
         case "preview":
             return {
                 route: "preview",
-                backend: "synthetic",
                 result: previewLabRefusal(options.cwd, refusal),
             };
         case "computer-use":
             return {
                 route: "computer-use",
-                backend: "cua",
-                result: await computerUseLabRefusal({ ...computerUseInput(options), ...lab, config, dryRun }, refusal),
+                result: await computerUseLabRefusal({ ...computerUseInput(options, deps, emit), config, dryRun }, refusal),
             };
         case "scripted":
             return {
                 route: "scripted",
-                backend: "scripted",
-                result: await scriptedLabRefusal({ ...scriptedInput(options), ...lab, config, dryRun }, refusal),
+                result: await scriptedLabRefusal({ ...scriptedInput(options, deps, emit), config, dryRun }, refusal),
             };
         case "terminal":
             return {
                 route: "terminal",
-                backend: "terminal",
-                result: await terminalLabRefusal({ ...terminalInput(options), ...lab, config, dryRun }, refusal),
+                result: await terminalLabRefusal({ ...terminalInput(options, deps, emit), config, dryRun }, refusal),
             };
         case "shared-world":
             return {
                 route: "shared-world",
-                backend: "concurrent-shared-world",
-                result: await sharedWorldLabRefusal({ ...sharedWorldInput(options), ...lab, config, dryRun }, refusal),
+                result: await sharedWorldLabRefusal({ ...sharedWorldInput(options, deps, emit), config, dryRun }, refusal),
             };
     }
 }

package/dist/subject/desktop-cli.d.ts

@@ -3,7 +3,7 @@ import { type SubjectPhaseEvent } from "./steps.js";
 /**
  * Prepare a CLI study's runtime and, only when declared, its product (#495, #515).
  *
- * The install runs UNKEYED and before the session starts, for the same reason the clone route
+ * The install runs unkeyed and before the session starts, for the same reason the clone route
  * provisions its subject first: what is being studied begins when the participant looks at the
  * screen. Omitting install deliberately studies product installation; Node/npm remain a
  * harness prerequisite so the participant can follow the product's public npm instructions.

package/dist/subject/desktop-cli.js

@@ -6,7 +6,7 @@ import { emitPhaseCompleted, emitPhaseStarted, INSTALL_TIMEOUT_MS, } from "./ste
 /**
  * Prepare a CLI study's runtime and, only when declared, its product (#495, #515).
  *
- * The install runs UNKEYED and before the session starts, for the same reason the clone route
+ * The install runs unkeyed and before the session starts, for the same reason the clone route
  * provisions its subject first: what is being studied begins when the participant looks at the
  * screen. Omitting install deliberately studies product installation; Node/npm remain a
  * harness prerequisite so the participant can follow the product's public npm instructions.

package/dist/subject/local-tree-archive.d.ts

@@ -74,7 +74,7 @@ export declare function createLocalTreeArchive(root: string, options?: CreateLoc
 /**
  * Normalize an author-supplied exclude entry to the relPath shape enumeration
  * produces (no leading "./", no trailing "/"). Absolute paths and glob syntax
- * are REJECTED, not silently no-op'd: an exclude the author believed in but
+ * are rejected instead of silently ignored: an exclude the author believed in but
  * that never matches anything is a leak vector, so unusable shapes fail
  * closed at the packing boundary (and, for lab manifests, already at parse
  * time in src/lab/parse/subject.ts).

package/dist/subject/local-tree-archive.js

@@ -1,6 +1,6 @@
 // Local working-tree packaging for `subject.source: local-tree`.
 //
-// Enumeration produces ONE file list that drives BOTH the tar archive and the
+// Enumeration produces one file list that drives both the tar archive and the
 // content digest (archiveSha256), so the digest can never diverge from what
 // actually gets packed. A prior in-house harness reimplemented exclusion in a
 // second, independent digest walker that could drift from what its tar
@@ -113,7 +113,7 @@ export function createLocalTreeArchive(root, options = {}) {
             (extraExclude.length > 0 ? " and extraExclude" : "") +
             "; local-tree packing requires at least one non-denylisted file or symlink. (Paths in this message are basenames only; the packed root is the lab resolution cwd.)");
     }
-    // Check the cap from enumerated sizes BEFORE reading/hashing file bytes, so
+    // Check the cap from enumerated sizes before reading/hashing file bytes, so
     // an oversized tree fails closed without the cost of hashing all of it.
     const enumeratedBytes = entries.reduce((sum, entry) => (entry.kind === "file" ? sum + entry.size : sum), 0);
     if (enumeratedBytes > maxArchiveBytes) {
@@ -200,7 +200,7 @@ function captureGitInfo(root) {
         return undefined;
     }
     // Pathspec-scoped to the packed root: `git status --porcelain` without a
-    // pathspec reports the WHOLE enclosing repository, which would report a
+    // pathspec reports the whole enclosing repository, which would report a
     // clean packed subtree as dirty whenever an unrelated sibling package in a
     // monorepo has in-progress changes.
     const status = execFileSync("git", ["status", "--porcelain", "--", "."], {
@@ -290,7 +290,7 @@ function isDenylistedSegment(relPath) {
 /**
  * Normalize an author-supplied exclude entry to the relPath shape enumeration
  * produces (no leading "./", no trailing "/"). Absolute paths and glob syntax
- * are REJECTED, not silently no-op'd: an exclude the author believed in but
+ * are rejected instead of silently ignored: an exclude the author believed in but
  * that never matches anything is a leak vector, so unusable shapes fail
  * closed at the packing boundary (and, for lab manifests, already at parse
  * time in src/lab/parse/subject.ts).

package/dist/subject/local-tree.d.ts

@@ -5,14 +5,14 @@ import type { Shell } from "../substrates/shell.js";
 import { type SubjectPhaseEvent } from "./steps.js";
 /**
  * Provision a local-tree subject inside the sandbox: upload the once-per-run packed archive
- * (identical bytes across every fan-out lane) → extract it into SUBJECT_DIR → the
+ * (identical bytes across every fan-out participant) → extract it into SUBJECT_DIR → the
  * same shared serve pipeline provisionCloneSubject uses. Unlike the clone route there is no
  * in-sandbox git refresh: the archive excludes .git entirely (see local-tree-archive.ts), so
  * subject identity is the host-side LocalTreeArchive captured at pack time, never anything
  * resolved in-sandbox.
  */
 export declare function provisionLocalTreeSubject(shell: Shell, args: {
-    /** The once-per-run packed archive bytes (shared byte-identically across every lane). */
+    /** The once-per-run packed archive bytes (shared byte-identically across every participant). */
     archiveBuffer: ArrayBuffer;
     serve: LabSubjectServe;
     /** Declared subject state (seed steps; external declaration is provenance-only). */

package/dist/subject/local-tree.js

@@ -7,7 +7,7 @@ import { SOURCE_TIMEOUT_MS, emitPhaseCompleted, emitPhaseStarted, SUBJECT_DIR, }
 const LOCAL_TREE_REMOTE_ARCHIVE_PATH = "/home/user/.humanish-source.tar.gz";
 /**
  * Provision a local-tree subject inside the sandbox: upload the once-per-run packed archive
- * (identical bytes across every fan-out lane) → extract it into SUBJECT_DIR → the
+ * (identical bytes across every fan-out participant) → extract it into SUBJECT_DIR → the
  * same shared serve pipeline provisionCloneSubject uses. Unlike the clone route there is no
  * in-sandbox git refresh: the archive excludes .git entirely (see local-tree-archive.ts), so
  * subject identity is the host-side LocalTreeArchive captured at pack time, never anything

package/dist/subject/node-bootstrap.d.ts

@@ -6,7 +6,7 @@ export declare const NODE_NPM_PREFIX_SCRIPT: string;
 export declare const NODE_BOOTSTRAP_TIMEOUT_MS: number;
 /**
  * Install Node from the pinned official archive when the desktop has no working Node >=20 and
- * npm. The terminal lane, desktop CLI studies and the subject serve pipeline share it. It needs no
+ * npm. The terminal route, desktop CLI studies and the subject serve pipeline share it. It needs no
  * apt: every network call is one bounded curl, so a stalled mirror fails the step within minutes.
  */
 export declare const NODE_BOOTSTRAP_COMMAND: string;

package/dist/subject/node-bootstrap.js

@@ -20,7 +20,7 @@ export const NODE_NPM_PREFIX_SCRIPT = [
 export const NODE_BOOTSTRAP_TIMEOUT_MS = 5 * 60_000;
 /**
  * Install Node from the pinned official archive when the desktop has no working Node >=20 and
- * npm. The terminal lane, desktop CLI studies and the subject serve pipeline share it. It needs no
+ * npm. The terminal route, desktop CLI studies and the subject serve pipeline share it. It needs no
  * apt: every network call is one bounded curl, so a stalled mirror fails the step within minutes.
  */
 export const NODE_BOOTSTRAP_COMMAND = [
@@ -54,13 +54,13 @@ export const NODE_BOOTSTRAP_COMMAND = [
     "for executable in node npm npx; do",
     `  sudo -n ln -sfn "$node_target/bin/$executable" "/usr/local/bin/$executable"`,
     "done",
-    // Keep global product executables on the existing ordinary/sudo PATH (#679). The new
+    // Keep global product executables on the existing ordinary/sudo `PATH` (#679). The new
     // versioned distribution is the only config we modify; no user/global npmrc or profile.
     `sudo -n "$node_target/bin/node" -e '${NODE_NPM_PREFIX_SCRIPT}' "$node_target/lib/node_modules/npm/npmrc"`,
     "hash -r",
     `node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 20 ? 0 : 1)' && npm --version >/dev/null`,
-    // Product installation already uses sudo; detect a template whose sudo PATH cannot see Node
-    // rather than changing global PATH or permissions to make it look supported.
+    // Product installation already uses sudo; detect a template whose sudo `PATH` cannot see Node
+    // rather than changing global `PATH` or permissions to make it look supported.
     `sudo -n node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 20 ? 0 : 1)' && sudo -n npm --version >/dev/null`,
     "fi",
 ].join("\n");

package/dist/subject/runtime.js

@@ -1,18 +1,18 @@
 // Provide the runtime a subject's serve pipeline needs, instead of failing at exit 127 (#371).
 //
-// The stock E2B `desktop` template ships python3 and curl but NO Node. That fact has now been
+// The stock E2B `desktop` template ships python3 and curl but no Node. That fact has now been
 // rediscovered three times: the in-sandbox comms catch was rewritten from node to python3 in 0.29.0
-// for exactly this reason, the terminal lane bootstraps Node explicitly, and the computer-use
+// for exactly this reason, the terminal route bootstraps Node explicitly, and the computer-use
 // clone/local-tree route did neither — so any lab whose `serve.install` runs npm or pnpm died with
-// `pnpm: command not found` AFTER a sandbox had been created and paid for.
+// `pnpm: command not found` after a sandbox had been created and paid for.
 //
 // It failed invisibly up front: `lab inspect` was clean, the plan printed normally, the sandbox
 // provisioned, and the first signal was a shell exit code attributed to "subject install failed".
 // Nobody can debug that from the outside.
 //
-// The posture here is PROVIDE, not warn. An adopter writing a lab for a Node app should not have to
+// The harness provides the runtime instead of warning about it. An adopter writing a lab for a Node app should not have to
 // know which binaries the template happens to carry — that is the harness's job, and the terminal
-// lane already treats it that way. Detection is conservative and the bootstrap is skipped whenever
+// route already treats it that way. Detection is conservative and the bootstrap is skipped whenever
 // a runtime is already present, so a custom template that ships Node pays nothing.
 /** Package managers and runtimes whose absence on the stock template breaks a serve pipeline. */
 const NODE_COMMANDS = ["npm", "npx", "pnpm", "yarn", "bun", "node", "vite", "next", "tsx"];

package/dist/subject/serve.js

@@ -114,7 +114,7 @@ export async function runSubjectServePipeline(shell, args) {
     await refresh();
     await startSubject(step);
     await waitForSubjectReady(step);
-    // after-ready: fixture loading through the RUNNING app (loopback curl from in-sandbox:
+    // after-ready: fixture loading through the running app (loopback curl from in-sandbox:
     // steps are author-trusted provisioning, not actors, so no new URL policy surface). These
     // complete before the caller opens the browser and the session timer starts.
     await runState("after-ready");

package/dist/subject/steps.d.ts

@@ -24,14 +24,14 @@ export declare function isoNow(now: () => number): string;
 export declare function emitPhaseStarted(onPhase: ((event: SubjectPhaseEvent) => void) | undefined, now: () => number, phase: string, message: string): void;
 /** Emit the matching phase-completed event: always carries ok and durationMs (>= 0). */
 export declare function emitPhaseCompleted(onPhase: ((event: SubjectPhaseEvent) => void) | undefined, now: () => number, startedAt: number, phase: string, ok: boolean, message: string): void;
-/** Default phase-boundary sink (stderr): one line per event, prefixed with the lane id ONLY
- *  when laneCount > 1. Single-lane emission is unconditional: total single-lane silence for the
+/** Default phase-boundary sink (stderr): one line per event, prefixed with the participant id
+ *  only when laneCount > 1. Single-participant emission is unconditional: total single-participant silence for the
  *  whole clone/install/build/ready boot is the bug this event stream exists to close.
- *  Overridable via CuaActorLabHooks.onPhase so deterministic tests capture instead of writing to
+ *  Overridable via LabDeps.subjectPhaseSink so deterministic tests capture instead of writing to
  *  the real stderr. */
 export declare function defaultSubjectPhaseSink(event: SubjectPhaseEvent, ctx: {
     laneId: string;
     laneCount: number;
 }): void;
-/** The shared-world subject's phase line: one shared plane, so no lane prefix. */
+/** The shared-world subject's phase line: one shared plane, so no participant prefix. */
 export declare function defaultSharedWorldPhaseSink(event: SubjectPhaseEvent): void;

package/dist/subject/steps.js

@@ -22,17 +22,17 @@ export function emitPhaseCompleted(onPhase, now, startedAt, phase, ok, message)
         message,
     });
 }
-/** Default phase-boundary sink (stderr): one line per event, prefixed with the lane id ONLY
- *  when laneCount > 1. Single-lane emission is unconditional: total single-lane silence for the
+/** Default phase-boundary sink (stderr): one line per event, prefixed with the participant id
+ *  only when laneCount > 1. Single-participant emission is unconditional: total single-participant silence for the
  *  whole clone/install/build/ready boot is the bug this event stream exists to close.
- *  Overridable via CuaActorLabHooks.onPhase so deterministic tests capture instead of writing to
+ *  Overridable via LabDeps.subjectPhaseSink so deterministic tests capture instead of writing to
  *  the real stderr. */
 export function defaultSubjectPhaseSink(event, ctx) {
     const durationSuffix = event.durationMs === undefined ? "" : ` (${event.durationMs}ms)`;
-    const prefix = ctx.laneCount > 1 ? `humanish cua [${ctx.laneId}]` : "humanish cua";
+    const prefix = ctx.laneCount > 1 ? `humanish computer-use [${ctx.laneId}]` : "humanish computer-use";
     process.stderr.write(`${prefix}: ${event.message}${durationSuffix}\n`);
 }
-/** The shared-world subject's phase line: one shared plane, so no lane prefix. */
+/** The shared-world subject's phase line: one shared plane, so no participant prefix. */
 export function defaultSharedWorldPhaseSink(event) {
     const durationSuffix = event.durationMs === undefined ? "" : ` (${event.durationMs}ms)`;
     process.stderr.write(`humanish shared-world (concurrent): ${event.message}${durationSuffix}\n`);

package/dist/substrates/desktop-session.d.ts

@@ -10,6 +10,8 @@ export type DesktopReleaseResult = {
     status: "unconfirmed";
     reason: "release_unavailable" | "invalid_result" | "release_failed";
     error?: unknown;
+    /** Why release is unavailable, when it is not the missing kill method. */
+    detail?: string;
 };
 export interface DesktopSession {
     readonly resourceId: string;

package/dist/substrates/e2b/cdp-probe.d.ts

@@ -5,7 +5,7 @@ export interface ChromeCdpProbeArgs {
     cdpPort?: number;
     /** The launched profile dir; the probe re-reads DevToolsActivePort at observe time. */
     profileDir?: string;
-    /** The URL this lane opened; attributes the page when no target id is pinned yet. */
+    /** The URL this participant opened; attributes the page when no target id is pinned yet. */
     targetUrl: string;
     /** The pinned page target id from the launch-time geometry capture. */
     targetId?: string;
@@ -24,7 +24,7 @@ export interface ChromeCdpProbeArgs {
      * "state": url/title/text/scrollY. "geometry": outer window + CSS viewport. "port": resolution
      * only. "emulate": apply mobile emulation (#221) to the selected page and exit (the overrides that
      * are session-scoped, UA / touch / DPR, lapse when the socket closes). "hold": the same over a browser-level
-     * socket, then stay attached until killed (how a lane keeps them for its whole life) and attach
+     * socket, then stay attached until killed (how a participant keeps them for its whole life) and attach
      * to every page target Chrome opens later, sending it the same overrides and a reload the moment
      * it exists, never pausing it (#623). "fidelity": read
      * back what the page reports about itself (UA, DPR, viewport, touch), the proof for the bundle.

package/dist/substrates/e2b/cdp-probe.js

@@ -15,7 +15,7 @@
 //
 // The script takes ONE JSON argument and prints ONE JSON line. Failures print
 // `{"unavailable": "<reason>"}` with exit 0 so the caller can say WHY the channel is dark instead
-// of swallowing an exit code; the TypeScript side turns that into a lane warning that names the
+// of swallowing an exit code; the TypeScript side turns that into a participant warning that names the
 // consequence ("url/text criteria will read as NEVER MEASURED").
 import { shellQuote } from "../shell.js";
 /**

package/dist/substrates/e2b/desktop-browser.d.ts

@@ -2,12 +2,12 @@ import type { LabDesktopBrowser } from "../../lab/types.js";
 import type { E2BDesktopSandbox } from "./sdk.js";
 import type { DesktopMediaEvidence } from "./desktop-media.js";
 export declare const DESKTOP_SETTLE_MS = 8000;
-/** The DevTools port every Chromium lane launches with; see `chrome_debug_flags` below. */
+/** The DevTools port every Chromium participant launches with; see `chrome_debug_flags` below. */
 export declare const CHROME_DEVTOOLS_PORT = 9222;
 /**
  * The shell step that waits for DevTools after a Chromium launch. `pid` is a shell word (the
  * launch script passes "$launch_pid"). Without python3 it prints nothing, which reads as no
- * readiness evidence: the lane keeps its previous behavior.
+ * readiness evidence: the participant keeps its previous behavior.
  */
 export declare function chromeDevToolsReadinessCommand(args: {
     pid: string;
@@ -33,7 +33,7 @@ export interface DesktopBrowserEvidence {
     media?: DesktopMediaEvidence;
 }
 export type DesktopBrowserFamily = "chromium" | "firefox" | "unknown";
-/** Runtime-only identity for the exact browser process started by this lane. */
+/** Runtime-only identity for the exact browser process started for this participant. */
 export interface DesktopBrowserLaunchIdentity {
     processId: string;
     profileDir: string;

package/dist/substrates/e2b/desktop-browser.js

@@ -9,11 +9,11 @@ import { e2bShell } from "./shell.js";
 // Settle after opening the browser or the terminal, before the first screenshot: long enough for
 // a cold browser and page load to paint (2 s captured a blank desktop; the render needs 6-9 s).
 export const DESKTOP_SETTLE_MS = 8_000;
-/** The DevTools port every Chromium lane launches with; see `chrome_debug_flags` below. */
+/** The DevTools port every Chromium participant launches with; see `chrome_debug_flags` below. */
 export const CHROME_DEVTOOLS_PORT = 9222;
 /**
  * How long the launch command waits for Chrome's DevTools port to answer. Six live launches on the
- * stock desktop answered in 4.8-7.7 s; two device-emulated lanes failed when it had not answered
+ * stock desktop answered in 4.8-7.7 s; two device-emulated participants failed when it had not answered
  * about 11 s after launch, and a CI leg once waited 20 s for the port marker.
  */
 const CHROME_DEVTOOLS_READY_MS = 30_000;
@@ -85,7 +85,7 @@ while True:
 /**
  * The shell step that waits for DevTools after a Chromium launch. `pid` is a shell word (the
  * launch script passes "$launch_pid"). Without python3 it prints nothing, which reads as no
- * readiness evidence: the lane keeps its previous behavior.
+ * readiness evidence: the participant keeps its previous behavior.
  */
 export function chromeDevToolsReadinessCommand(args) {
     return [
@@ -113,7 +113,7 @@ export async function findVisibleBrowserWindowId(desktop, requestTimeoutMs, brow
         return undefined;
     // The candidate loop keeps the LAST identity match: with a launch identity the match is
     // unique anyway, and without one every family candidate matches, so the newest visible
-    // window of the launched family wins (the window this lane just opened).
+    // window of the launched family wins (the window this participant just opened).
     const finder = browserFamily === "firefox"
         ? [
             "find_firefox_window() {",