humanish 0.106.1 → 0.108.0

package/dist/routes/computer-use/live-flush.js

@@ -1,8 +1,7 @@
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import {} from "../../observer/run-routes.js";
-import { HOOK_MEMBERS, withHookOverrides } from "../../lab/bag-overrides.js";
 /**
- * Incremental live flush (#441): as each lane's loop reports its recorded-so-far items,
+ * Incremental live flush: as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses
@@ -12,12 +11,12 @@ import { HOOK_MEMBERS, withHookOverrides } from "../../lab/bag-overrides.js";
 export function startLiveTraceFlush(args) {
     const { bundle, participantRuns, model, write } = args;
     const streamIdByParticipant = new Map(participantRuns.map((spec) => [spec.planned.id, spec.streamId]));
-    // The persona each lane is running, so the live flush can say who is in it.
+    // The persona each participant is running, so the live flush can say who is in it.
     const personaByStream = new Map(participantRuns
         .map((spec) => [spec.streamId, spec.persona?.id])
         .filter((entry) => typeof entry[1] === "string"));
     const liveItemsByStream = new Map();
-    // Running token usage per lane, so a run in flight can price itself instead of reporting the
+    // Running token usage per participant, so a run in flight can price itself instead of reporting the
     // cost as unknown until the moment it ends.
     const liveUsageByStream = new Map();
     const liveMetadataByStream = new Map();
@@ -43,9 +42,9 @@ export function startLiveTraceFlush(args) {
                             liveActor: {
                                 schema: "humanish.live-actor.v1",
                                 updatedAt,
-                                // WHO is in this lane, carried while the run is live. Without it a surface
-                                // watching a live run can only name the lane, and "CUA browser — observer-live-
-                                // check" is the harness talking about itself where the participant should be.
+                                // Who this participant is, carried while the run is live. Without it a
+                                // surface watching a live run can only name the participant id and the stream
+                                // label (`<participant id> · browser`), which describe the harness, not the participant.
                                 ...(personaByStream.get(stream.id) === undefined
                                     ? {}
                                     : { persona: { id: personaByStream.get(stream.id) } }),
@@ -114,34 +113,27 @@ export function startLiveTraceFlush(args) {
     return { flush, stop };
 }
 /**
- * The live desktop views (runtime stream URLs) lanes report, attached to whichever Observer shows
+ * The live desktop views (runtime stream URLs) participants report, attached to whichever Observer shows
  * the run. The URLs carry auth, so they live in memory and on the Observer result, never in run
  * artifacts.
  */
-export function trackRuntimeStreams(hooks) {
+export function trackRuntimeStreams(onStream) {
     let liveObserver;
     const urls = [];
     return {
-        // The caller's bag may be a class instance, so it is wrapped rather than spread.
-        hooks: withHookOverrides(hooks, HOOK_MEMBERS.cua, {
-            onRuntimeStreamReady: async (stream) => {
-                await hooks.onRuntimeStreamReady?.(stream);
-                urls.push({ streamId: stream.streamId, url: stream.url });
-                if (liveObserver)
-                    attachObserverRuntimeStreamUrls(liveObserver, urls);
-            },
-            onRuntimeStreamEnded: async (stream) => {
-                await hooks.onRuntimeStreamEnded?.(stream);
-                // Mark, never remove: the tile needs to KNOW the live view ended (and say so) rather than
-                // have the stream silently vanish from the overlay (#357).
-                for (const entry of urls) {
-                    if (entry.streamId === stream.streamId)
+        onStream: async (event) => {
+            await onStream?.(event);
+            if (event.type === "ready")
+                urls.push({ streamId: event.streamId, url: event.url });
+            // Mark, never remove: the tile needs to know the live view ended (and say so) rather than
+            // have the stream silently vanish from the overlay.
+            else
+                for (const entry of urls)
+                    if (entry.streamId === event.streamId)
                         entry.ended = true;
-                }
-                if (liveObserver)
-                    attachObserverRuntimeStreamUrls(liveObserver, urls);
-            },
-        }),
+            if (liveObserver)
+                attachObserverRuntimeStreamUrls(liveObserver, urls);
+        },
         showIn: (observer) => {
             liveObserver = observer;
         },

package/dist/routes/computer-use/{run-lanes.d.ts → live-phase.d.ts}

@@ -10,10 +10,12 @@ export declare function runLabParticipants(setup: CuaRunSetup, participants: Cua
     result: {
         automaticAnalysis?: import("../../analysis/job.js").AutomaticAnalysisOutcome;
         automaticAnalysisTrigger?: "default" | "explicit";
-        schema: typeof import("./types.js").CUA_ACTOR_LAB_SCHEMA;
+        schema: typeof import("../../run/study-result.js").STUDY_RESULT_SCHEMA;
+        route: "computer-use";
+        studyId: string;
+        labId: string;
         ok: boolean;
         cwd: string;
-        labId: string;
         actor: string;
         appUrl: string;
         dryRun: boolean;

package/dist/routes/computer-use/{run-lanes.js → live-phase.js}

@@ -1,28 +1,29 @@
 // The computer-use run's live phase: the in-progress bundle and its live-trace flush, email
-// receiving, the lanes themselves, and the drain of an operator-hosted inbox.
+// receiving, the participants themselves, and the drain of an operator-hosted inbox.
 import { prepareReceivingRun } from "../../comms/receiving-runtime.js";
 import { liveObserverResult } from "../../observer/live.js";
 import { pricedModel } from "../../lab/plan-base.js";
-import { runAllCuaParticipants } from "./lanes.js";
+import { runAllCuaParticipants } from "./participant-execution.js";
 import { startLiveTraceFlush } from "./live-flush.js";
 import { drainExternalComms } from "./external-comms.js";
 import { buildCuaRunBundle, judgeComputerUseRun } from "./bundle.js";
-import {} from "./types.js";
+import { participantSubjectEnv } from "./types.js";
 /**
  * Runs the participants (a dry run runs none). Returns the refusal when real email setup fails, or
  * the participant outcomes and the warnings the finish records.
  */
 export async function runLabParticipants(setup, participants) {
-    const { plan, input, cwd, streams, descriptor, subjectRoute, run } = setup;
-    const { participantRuns, participantPlan, scrubKnownValues, bundleBase } = setup;
+    const { plan, input, cwd, streams, descriptor, run } = setup;
+    const { participantRuns, participantPlan, bundleBase } = setup;
     const { env, knownSecretValues, deps, liveTrace, externalComms, inProgress, fail } = participants;
     const { dryRun } = plan;
-    const { inProcessRoute, subjectEnvNames } = subjectRoute;
+    const inProcess = plan.runner.desktop === "in-process";
+    const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId, paths: runPaths } = run;
-    // A live run writes what it is doing AS IT DOES IT, whether or not anyone is currently watching.
-    // This used to be gated on `options.onObserverReady` — the interactive Observer callback — so a
-    // run launched by an agent (`lab run --json`), detached, or from the terminal surface recorded
-    // nothing at all until it completed, and anything asking "what is this participant doing right
+    // A live run writes what it is doing as it does it, whether or not anyone is currently watching.
+    // This is not gated on `options.onObserverReady` (the interactive Observer callback): gated, a
+    // run launched by an agent (`lab run --json`), detached, or from the terminal surface records
+    // nothing at all until it completes, and anything asking "what is this participant doing right
     // now" got silence for the whole run. Who reads the evidence is not the run's business; the
     // callback below stays conditional, the writing does not.
     if (!dryRun) {
@@ -46,7 +47,7 @@ export async function runLabParticipants(setup, participants) {
         streams.showIn(liveObserver);
         if (input.onObserverReady)
             await input.onObserverReady(liveObserver);
-        // Incremental live flush (#441): as each lane's loop reports its recorded-so-far items,
+        // Incremental live flush: as each participant's loop reports its recorded-so-far items,
         // rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
         // Observer's 5s poll sees the timeline grow. The run refuses any snapshot once the final
         // write began; the route stops the flush timer on every exit below.
@@ -90,18 +91,18 @@ export async function runLabParticipants(setup, participants) {
             return {
                 ok: false,
                 result: {
-                    ...fail("HUMANISH_CUA_LAB_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
+                    ...fail("HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
                     runId,
                 },
             };
         }
     }
-    // Run lanes (dry-run runs none). In-process is always one lane.
+    // Run the participants (dry-run runs none). In-process is always one.
     let outcomes;
     let failFastReason;
     try {
         if (!dryRun)
-            ({ outcomes, failFastReason } = await runAllCuaParticipants(participantRuns, deps, participantPlan, inProcessRoute));
+            ({ outcomes, failFastReason } = await runAllCuaParticipants(participantRuns, deps, participantPlan, inProcess));
     }
     finally {
         try {
@@ -110,7 +111,7 @@ export async function runLabParticipants(setup, participants) {
         catch {
             receivingWarnings.push("Email finalization could not complete. Inspect humanish comms recover; provider cleanup remains unresolved.");
         }
-        // Stop the flush timer on every exit, including a throw from the lanes.
+        // Stop the flush timer on every exit, including a throw from the participants.
         await liveTrace.stop?.();
     }
     const externalCommsWarnings = !dryRun && externalComms && outcomes !== undefined
@@ -121,7 +122,7 @@ export async function runLabParticipants(setup, participants) {
             runPaths,
             participantRuns: participantRuns,
             outcomes,
-            scrubKnownValues,
+            knownSecretValues,
         })
         : [];
     return {

package/dist/routes/computer-use/local-tree-pack.d.ts

@@ -1,11 +1,11 @@
 import type { LabConfig } from "../../lab/types.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
-import { type CuaActorLabHooks } from "./types.js";
+import type { LabDeps } from "../../lab/lab-deps.js";
 /**
  * Pack the working tree for a local-tree run and report what left the host on stderr, by counts
  * and digest only, never paths or file names.
  */
-export declare function packRunLocalTree(hooks: CuaActorLabHooks, config: {
+export declare function packRunLocalTree(deps: LabDeps, config: {
     readonly subject: Pick<LabConfig["subject"], "localTree">;
 }, cwd: string): Promise<{
     archive: LocalTreeArchive;
@@ -14,7 +14,7 @@ export declare function packRunLocalTree(hooks: CuaActorLabHooks, config: {
 /**
  * Default local-tree packing implementation: createLocalTreeArchive(root, opts) on the host,
  * then a single read of the produced archive file into an ArrayBuffer for upload. The DI seam
- * (CuaActorLabHooks.packLocalTree) overrides this in deterministic tests so they never require
+ * (LabDeps.packLocalTree) overrides this in deterministic tests so they never require
  * tar/git.
  */
 export declare function defaultPackLocalTree(args: {

package/dist/routes/computer-use/local-tree-pack.js

@@ -1,14 +1,13 @@
-// Packing the project's working tree once per local-tree run, on the host, for every lane to upload.
+// Packing the project's working tree once per local-tree run, on the host, for every participant to upload.
 import { readFile, rm } from "node:fs/promises";
 import path from "node:path";
 import { createLocalTreeArchive } from "../../subject/local-tree-archive.js";
-import {} from "./types.js";
 /**
  * Pack the working tree for a local-tree run and report what left the host on stderr, by counts
  * and digest only, never paths or file names.
  */
-export async function packRunLocalTree(hooks, config, cwd) {
-    const packLocalTree = hooks.packLocalTree ?? defaultPackLocalTree;
+export async function packRunLocalTree(deps, config, cwd) {
+    const packLocalTree = deps.packLocalTree ?? defaultPackLocalTree;
     const packed = await packLocalTree({
         root: cwd,
         ...(config.subject.localTree?.exclude === undefined
@@ -25,7 +24,7 @@ export async function packRunLocalTree(hooks, config, cwd) {
 /**
  * Default local-tree packing implementation: createLocalTreeArchive(root, opts) on the host,
  * then a single read of the produced archive file into an ArrayBuffer for upload. The DI seam
- * (CuaActorLabHooks.packLocalTree) overrides this in deterministic tests so they never require
+ * (LabDeps.packLocalTree) overrides this in deterministic tests so they never require
  * tar/git.
  */
 export async function defaultPackLocalTree(args) {

package/dist/routes/computer-use/local-vm.d.ts

@@ -1,20 +1,23 @@
-import type { RunLabOptions } from "../../run-lab.js";
+import type { InternalRunLabOptions } from "../../run-lab.js";
 import type { LabConfig } from "../../lab/types.js";
+import type { LocalVmInput } from "./types.js";
 import { type LocalFirecrackerAssets } from "../../substrates/local/firecracker-desktop.js";
-type LocalStudyOptions = RunLabOptions & {
+type LocalVmRunOptions = InternalRunLabOptions & {
     config: LabConfig;
     assets?: LocalFirecrackerAssets;
     signal?: AbortSignal;
 };
-/** A local browser study's bindings, and the cleanup of what its lanes started. */
-export interface LocalVmStudy {
-    /** The caller's runLab options with this study's desktop lane, provider and abort signal. */
-    readonly options: RunLabOptions;
+/** A local browser study's bindings, and the cleanup of what its participants started. */
+export interface LocalVmRun {
+    /** The caller's runLab options, with the account provider when the study runs one. */
+    readonly options: InternalRunLabOptions;
+    /** The desktop, the analysis gate and the abort signal the computer-use run takes. */
+    readonly localVm: LocalVmInput;
     close(): Promise<void>;
 }
 /**
  * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run, or on a hook only an E2B desktop calls.
+ * anything starts on a lab the local study cannot run.
  */
-export declare function prepareLocalVmStudy(options: LocalStudyOptions): LocalVmStudy;
+export declare function prepareLocalVmRun(options: LocalVmRunOptions): LocalVmRun;
 export {};

package/dist/routes/computer-use/local-vm.js

@@ -1,30 +1,16 @@
 import { collectDesktopRecording } from "../../evidence/desktop-recording-artifact.js";
 import path from "node:path";
-import { inboxRecipientFor, PARTICIPANT_DESKTOP, } from "./participant-desktop.js";
-import { HOOK_MEMBERS, withHookOverrides } from "../../lab/bag-overrides.js";
-import { runCuaActorSession } from "../../actors/computer-use/actor.js";
+import { inboxRecipientFor, } from "./participant-desktop.js";
 import { createLocalFirecrackerDesktop, } from "../../substrates/local/firecracker-desktop.js";
 import { localBrowserDefaults, localBrowserUnsupportedReason, } from "../../substrates/local/runtime-config.js";
 import { prepareLocalRuntime } from "../../substrates/local/runtime.js";
+import { dockerCommandLine } from "../../substrates/local/runtime-host.js";
 import { checkRestrictedCodexAnalysisReadiness } from "../../analysis/restricted-codex.js";
 import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
+import { withCloseReport } from "./participant-model.js";
 import { guestMediaConfigSchema } from "../../guest/media-config.js";
 import { startLocalCapturedInbox } from "../../substrates/local/captured-inbox.js";
-// These hooks act on an E2B desktop or the local-tree upload to it. The study runs on a
-// Firecracker desktop and never calls them, so a caller relying on one gets an error up front.
-const e2bDesktopHooks = [
-    "prepareDesktop",
-    "loadDesktopModule",
-    "onRuntimeStreamReady",
-    "packLocalTree",
-];
-function refuseE2BDesktopHooks(hooks) {
-    const present = e2bDesktopHooks.filter((name) => hooks?.[name] !== undefined);
-    if (present.length === 0)
-        return;
-    throw new Error(`A local browser study runs on a Firecracker desktop and does not call ${present.map((name) => `cuaHooks.${name}`).join(", ")}. These hooks apply only to E2B desktops.`);
-}
-function studyMedia(config) {
+function guestMedia(config) {
     const declaredMedia = config.execution?.desktop?.media;
     return declaredMedia === undefined
         ? undefined
@@ -34,13 +20,13 @@ function studyMedia(config) {
         });
 }
 /** The runtime image, prepared once per study on first use, after the account check. */
-function studyAssets(options, account, needsMedia) {
+function guestAssets(options, account, needsMedia) {
     let preparing;
     return () => (preparing ??= (async () => {
         if (account) {
             const readiness = await checkRestrictedCodexAnalysisReadiness({ timeoutMs: 5000 });
             if (!readiness.ready)
-                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --lab <lab> before starting a local study.`);
+                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --study <study> before starting a local study.`);
         }
         return (options.assets ??
             (await prepareLocalRuntime({
@@ -64,7 +50,7 @@ function mediaEvidence(media) {
         },
     };
 }
-/** One lane's Firecracker desktop and optional captured inbox, released in finalize. */
+/** One participant's Firecracker desktop and optional captured inbox, released in finalize. */
 function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
     const { config, media, recording, state } = context;
     let session;
@@ -132,7 +118,14 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
                 }
                 if (!evidence.released) {
                     state.cleanupUnconfirmed = true;
-                    warnings.push("Local desktop cleanup is unconfirmed.");
+                    const warning = "Local desktop cleanup is unconfirmed.";
+                    warnings.push(warning);
+                    // No receipt names a local VM, so the record carries the command that removes it.
+                    evidence.sandboxRelease = {
+                        state: "unconfirmed",
+                        warning,
+                        recovery: `If container ${session.resourceId} is still listed by \`${dockerCommandLine(["ps"])}\`, remove it with \`${dockerCommandLine(["rm", "--force", "--volumes", session.resourceId])}\`.`,
+                    };
                 }
             })());
         },
@@ -141,40 +134,37 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
 }
 /** The Codex account participant, whose unconfirmed cleanup blocks the study's analysis. */
 function accountProvider(state) {
-    return {
-        async buildProvider({ executor }) {
-            const participant = createRestrictedCodexParticipant({
-                speechEnabled: executor?.speechEnabled === true,
-            });
-            state.participants.push(participant);
-            return Object.assign(participant.provider, {
-                async close() {
-                    if ((await participant.close()).status !== "confirmed") {
-                        state.cleanupUnconfirmed = true;
-                        throw new Error("Local participant cleanup is unconfirmed.");
-                    }
-                },
-            });
-        },
+    return async ({ executor }) => {
+        const participant = createRestrictedCodexParticipant({
+            speechEnabled: executor.speechEnabled === true,
+        });
+        state.participants.push(participant);
+        const provider = Object.assign(participant.provider, {
+            async close() {
+                if ((await participant.close()).status !== "confirmed") {
+                    state.cleanupUnconfirmed = true;
+                    throw new Error("Local participant cleanup is unconfirmed.");
+                }
+            },
+        });
+        // The participant runner reads the session's warnings and late refusal from the same, idempotent close.
+        return withCloseReport(provider, () => participant.close());
     };
 }
 /**
  * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run, or on a hook only an E2B desktop calls.
+ * anything starts on a lab the local study cannot run.
  */
-export function prepareLocalVmStudy(options) {
+export function prepareLocalVmRun(options) {
     const config = localBrowserDefaults(options.config);
     const unsupported = localBrowserUnsupportedReason(config);
     if (unsupported)
         throw new Error(unsupported);
-    refuseE2BDesktopHooks(options.cuaHooks);
     const recording = config.execution?.desktop?.recording;
-    const media = studyMedia(config);
-    const callerHooks = options.cuaHooks;
+    const media = guestMedia(config);
     // A caller-supplied provider replaces the Codex account participant, so the account is
     // neither checked nor used.
-    const account = config.actors[0]?.type === "local-agent" && callerHooks?.buildProvider === undefined;
-    const baseRunSession = callerHooks?.runSession ?? runCuaActorSession;
+    const account = config.actors[0]?.type === "local-agent" && options.createProvider === undefined;
     const state = { sessions: [], participants: [], cleanupUnconfirmed: false };
     const context = {
         config,
@@ -182,33 +172,16 @@ export function prepareLocalVmStudy(options) {
         signal: options.signal,
         media,
         recording,
-        assets: studyAssets(options, account, media !== undefined || recording !== undefined),
+        assets: guestAssets(options, account, media !== undefined || recording !== undefined),
         state,
     };
     const { config: _config, assets: _assets, signal: _signal, ...runOptions } = options;
     return {
-        options: {
-            ...runOptions,
-            // Wrapped rather than spread for the same reason as cuaHooks below.
-            automaticAnalysis: withHookOverrides(options.automaticAnalysis, HOOK_MEMBERS.analysis, {
-                onStart() {
-                    if (state.cleanupUnconfirmed)
-                        throw new Error("Local study cleanup is unconfirmed.");
-                    return options.automaticAnalysis?.onStart?.();
-                },
-            }),
-            // These overrides go over the caller's hooks so this study's desktop always wins:
-            // participantDesktopOf takes [PARTICIPANT_DESKTOP] before a caller's createDesktopLane.
-            // The caller's bag may be a class instance, so it is wrapped rather than spread.
-            cuaHooks: withHookOverrides(callerHooks, HOOK_MEMBERS.cua, {
-                [PARTICIPANT_DESKTOP]: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),
-                ...(account ? accountProvider(state) : {}),
-                ...(options.signal
-                    ? {
-                        runSession: (input) => baseRunSession({ ...input, signal: options.signal }),
-                    }
-                    : {}),
-            }),
+        options: account ? { ...runOptions, createProvider: accountProvider(state) } : runOptions,
+        localVm: {
+            desktop: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),
+            analysisRefusal: () => state.cleanupUnconfirmed ? "AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED" : undefined,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
         },
         async close() {
             await Promise.allSettled(state.participants.map((participant) => participant.close()));

package/dist/routes/computer-use/participant-desktop.d.ts

@@ -1,5 +1,5 @@
 import type { CuaExecutor } from "../../actors/computer-use/loop.js";
-import type { CuaActorLabHooks, DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
+import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
 import type { LabCommsEmail, LabCommsRecipient } from "../../lab/types.js";
 import type { PreparedOutputRoot } from "../../run/contained-output.js";
 /** A prepared desktop supplies only participant input/observation and its inbox location. */
@@ -13,10 +13,10 @@ export interface ReadyParticipantDesktop {
 }
 /** Existing bundle fields. Provider-specific facts remain optional and must be measured. */
 export type ParticipantDesktopEvidence = {
-    /** The substrate confirmed the desktop was released (an E2B kill or a local VM shutdown). The lane
+    /** The substrate confirmed the desktop was released (an E2B kill or a local VM shutdown). The participant
      *  outcome records it as `killed`. */
     released: boolean;
-} & Pick<ParticipantRunOutcome, "sandboxId" | "desktopDurationMs" | "desktopResources" | "streamUrlPresent" | "subjectCommit" | "desktopBrowser" | "desktopGeometry" | "stateStepRecords" | "phaseRecords" | "failureCode" | "commsArtifactPath" | "recording">;
+} & Pick<ParticipantRunOutcome, "sandboxId" | "sandboxRelease" | "desktopDurationMs" | "desktopResources" | "streamUrlPresent" | "subjectCommit" | "desktopBrowser" | "desktopGeometry" | "stateStepRecords" | "phaseRecords" | "failureCode" | "commsArtifactPath" | "recording">;
 /**
  * The desktop one participant runs on, owned from preparation through final evidence collection.
  * Call methods sequentially: prepare, openSession, then finalize in a finally block.
@@ -38,26 +38,11 @@ export interface ParticipantDesktop {
 }
 /** Builds one participant's desktop. The factory must not acquire anything; prepare does. */
 export type ParticipantDesktopFactory = (run: DesktopParticipantRun, warnings: string[], artifactRoot: PreparedOutputRoot) => ParticipantDesktop;
-/**
- * The hook-bag member a study that owns its desktops (the local VM study) sets to its factory. A
- * symbol keeps it out of the public CuaActorLabHooks, whose deprecated createDesktopLane takes the
- * flat lane record; withHookOverrides forwards it like any other member of the bag.
- */
-export declare const PARTICIPANT_DESKTOP: unique symbol;
-/** A hook bag that may carry a study's own desktop factory. */
-export type HooksWithParticipantDesktop = CuaActorLabHooks & {
-    readonly [PARTICIPANT_DESKTOP]?: ParticipantDesktopFactory;
-};
-/**
- * The desktop factory a run uses: the study's own, else the caller's deprecated createDesktopLane,
- * given the flat view of each run. Undefined means the route provisions its own desktop.
- */
-export declare function participantDesktopOf(hooks: CuaActorLabHooks): ParticipantDesktopFactory | undefined;
-/** The lane's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A lane told to check an inbox it can never receive into would stall,
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
 export declare function inboxRecipientFor(commsEmail: LabCommsEmail, participantId: string): LabCommsRecipient | undefined;
-/** True when a lane has a declared comms recipient WITH an address, so the drain can actually match the
- *  mail the persona will be told to read. Gates the inbox instruction to lanes that can receive mail —
- *  a lane told to check an inbox it can never receive into would just stall. */
+/** True when a participant has a declared comms recipient with an address, so the drain can actually match the
+ *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
+ *  mail; a participant told to check an inbox it can never receive into would just stall. */
 export declare function participantHasInboxRecipient(commsEmail: LabCommsEmail, participantId: string): boolean;

package/dist/routes/computer-use/participant-desktop.js

@@ -1,33 +1,13 @@
-import { legacyHookSpecOf } from "./legacy-lane-spec.js";
 import { recipientParticipantId } from "../../lab/parse/comms.js";
-/**
- * The hook-bag member a study that owns its desktops (the local VM study) sets to its factory. A
- * symbol keeps it out of the public CuaActorLabHooks, whose deprecated createDesktopLane takes the
- * flat lane record; withHookOverrides forwards it like any other member of the bag.
- */
-export const PARTICIPANT_DESKTOP = Symbol("humanish.participantDesktop");
-/**
- * The desktop factory a run uses: the study's own, else the caller's deprecated createDesktopLane,
- * given the flat view of each run. Undefined means the route provisions its own desktop.
- */
-export function participantDesktopOf(hooks) {
-    const own = hooks[PARTICIPANT_DESKTOP];
-    if (own !== undefined)
-        return own;
-    const caller = hooks.createDesktopLane;
-    return caller === undefined
-        ? undefined
-        : (run, warnings, artifactRoot) => caller(legacyHookSpecOf(run), warnings, artifactRoot);
-}
-/** The lane's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A lane told to check an inbox it can never receive into would stall,
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
 export function inboxRecipientFor(commsEmail, participantId) {
     return (commsEmail.recipients ?? []).find((recipient) => recipientParticipantId(recipient) === participantId && recipient.address !== undefined);
 }
-/** True when a lane has a declared comms recipient WITH an address, so the drain can actually match the
- *  mail the persona will be told to read. Gates the inbox instruction to lanes that can receive mail —
- *  a lane told to check an inbox it can never receive into would just stall. */
+/** True when a participant has a declared comms recipient with an address, so the drain can actually match the
+ *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
+ *  mail; a participant told to check an inbox it can never receive into would just stall. */
 export function participantHasInboxRecipient(commsEmail, participantId) {
     return inboxRecipientFor(commsEmail, participantId) !== undefined;
 }

package/dist/routes/computer-use/{lanes.d.ts → participant-execution.d.ts}

@@ -1,6 +1,6 @@
 import { type PreparedOutputRoot } from "../../run/contained-output.js";
 import type { CuaParticipantDeps, CuaParticipantPlan, CuaParticipantResult, DesktopParticipantRun, CuaSubjectProjection, ParticipantRunOutcome } from "./types.js";
-/** Build a lane's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
+/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
  *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
  *  at N>1). */
 export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOutputRoot, spec: {
@@ -10,26 +10,26 @@ export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOut
  * evidence and cleanup; this runner owns the model, trace and participant outcome. */
 export declare function runCuaParticipant(spec: DesktopParticipantRun, deps: CuaParticipantDeps): Promise<ParticipantRunOutcome>;
 /**
- * Run N>1 E2B lanes with bounded concurrency, a pipeline gate (lane 1 provisions before the rest
- * start), and session fail-fast on HARNESS errors only (queued lanes become `blocked` with a
- * pinned reason + a fail-fast event; mission verdicts never trip it). Each lane tears down ITS
- * OWN sandbox by id; nothing here ever enumerates.
+ * Run N>1 E2B participants with bounded concurrency, a pipeline gate (the first provisions
+ * before the rest start), and session fail-fast on harness errors only (queued participants
+ * become `blocked` with a pinned reason + a fail-fast event; mission verdicts never trip it).
+ * Each participant tears down its own sandbox by id; nothing here ever enumerates.
  *
- * Exported for the #342 total-runner tests: the injectable runner lets a test make one lane
- * THROW (the exact class the guard exists for) without a live sandbox. Production always uses
+ * Exported for the total-runner tests: the injectable runner lets a test make one participant
+ * throw (the exact class the guard exists for) without a live sandbox. Production always uses
  * the default.
  */
 export declare function runCuaParticipants(runs: DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, concurrency: number, runParticipant?: typeof runCuaParticipant): Promise<{
     outcomes: ParticipantRunOutcome[];
     failFastReason?: string;
 }>;
-/** Project one lane outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
+/** Project one participant outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
 export declare function toParticipantResult(spec: DesktopParticipantRun, outcome: ParticipantRunOutcome | undefined, subject: CuaSubjectProjection, dryRun: boolean): CuaParticipantResult;
 /**
- * Run every lane of a live run. The in-process route drives its single lane in this process; one
- * hosted lane runs alone; a fan-out runs at the plan's concurrency and may stop early.
+ * Run every participant of a live run. The in-process route drives its single participant in this
+ * process; one hosted participant runs alone; a fan-out runs at the plan's concurrency and may stop early.
  */
-export declare function runAllCuaParticipants(runs: readonly DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, participantPlan: CuaParticipantPlan, inProcessRoute: boolean): Promise<{
+export declare function runAllCuaParticipants(runs: readonly DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, participantPlan: CuaParticipantPlan, inProcess: boolean): Promise<{
     outcomes: ParticipantRunOutcome[];
     failFastReason: string | undefined;
 }>;