humanish 0.106.1 → 0.108.0

package/dist/routes/computer-use/e2b-desktop/fidelity.js

@@ -1,13 +1,13 @@
-// Device fidelity for one E2B desktop lane: mobile emulation beyond viewport size (#221), the
-// browser-state observer that watches it for drift (#623), and the final browser geometry.
+// Device fidelity for one E2B desktop participant: mobile emulation beyond viewport size, the
+// browser-state observer that watches it for drift, and the final browser geometry.
 import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
 import { readDetachedLog } from "../../../substrates/detached.js";
 import { applyMobileEmulation, DEFAULT_MOBILE_USER_AGENT, makeChromeBrowserStateObserver, } from "../../../substrates/e2b/desktop-cdp.js";
 import { captureDesktopBrowserGeometry } from "../../../substrates/e2b/desktop-geometry.js";
 import { e2bShell } from "../../../substrates/e2b/shell.js";
-/** Only lanes on a mobile preset are emulated; the flags go on the browser command line. */
-export function mobileLaunchFlags(config, spec) {
-    const requested = config.execution?.desktop?.fidelity;
+/** Only participants on a mobile preset are emulated; the flags go on the browser command line. */
+export function mobileLaunchFlags(residual, spec) {
+    const requested = residual.execution?.desktop?.fidelity;
     if (!requested?.mobileEmulation || !spec.planned.device.preset.isMobile)
         return [];
     return [
@@ -25,14 +25,15 @@ function cdpEndpoint(identity, targetUrl) {
 }
 /**
  * Apply mobile fidelity to the launch page before the geometry capture and the participant's first
- * observation. A request that cannot be applied fails the lane closed with the reason. Only lanes on
- * a mobile preset are emulated: a run-wide flag must not hand a desktop or tablet lane an iPhone
- * user agent (the first live proof did exactly that to the desktop newcomer beside the phone lane).
- * Those lanes carry no fidelity block, which is honest.
+ * observation. A request that cannot be applied fails the participant closed with the reason. Only
+ * participants on a mobile preset are emulated: a run-wide flag must not hand a desktop or tablet
+ * participant an iPhone user agent (the first live proof did exactly that to the desktop newcomer
+ * beside the phone participant). Those participants carry no fidelity block, since nothing was
+ * emulated.
  */
 export async function applyParticipantMobileFidelity(args) {
     const { spec, deps } = args;
-    const request = deps.config.execution?.desktop?.fidelity;
+    const request = deps.residual.execution?.desktop?.fidelity;
     const none = {
         applied: undefined,
         emulatedTargetId: undefined,
@@ -62,11 +63,11 @@ export function participantBrowserStateObserver(args) {
     const { spec, deps, fidelity, warnings } = args;
     return makeChromeBrowserStateObserver(args.desktop, deps.requestTimeoutMs, cdpEndpoint(args.launchIdentity, args.targetUrl), {
         targetId: args.targetId,
-        // Once per lane: a dark observation channel is a gap in the instrument, and the
-        // funnel's NEVER MEASURED count needs this line to explain itself (#514).
+        // Once per participant: a dark observation channel is a gap in the instrument, and the
+        // funnel's "never measured" count needs this line to explain itself.
         onUnavailable: (reason) => {
             warnings.push(`Browser-state observer unavailable for participant ${spec.planned.id} (${redactText(deps.scrubKnownValues(reason))}); ` +
-                "urlIncludes/urlPathEquals/textIncludes stop conditions and task criteria are NOT being measured this session.");
+                "urlIncludes, urlPathEquals and textIncludes stop conditions and task criteria are not measured in this session.");
         },
         drift: fidelity.emulatedTargetId === undefined
             ? undefined
@@ -75,11 +76,11 @@ export function participantBrowserStateObserver(args) {
                 expectedWidth: spec.planned.device.preset.width,
                 expectTouch: fidelity.applied?.requested.touch === true,
                 onDrift: (reason) => {
-                    warnings.push(`Mobile emulation drift for participant ${spec.planned.id}: ${reason} (#623).`);
+                    warnings.push(`Mobile emulation drift for participant ${spec.planned.id}: ${reason}.`);
                 },
                 onCovered: (coveredTargetId, read) => {
                     // A later tab the page itself reported at the phone width: evidence that
-                    // the emulation followed the participant (#623), kept on the bundle.
+                    // the emulation followed the participant, kept on the bundle.
                     if (fidelity.applied === undefined)
                         return;
                     fidelity.applied = {
@@ -94,9 +95,9 @@ export function participantBrowserStateObserver(args) {
     });
 }
 /**
- * The lane's final browser geometry, measured while the sandbox is alive. A final capture that
- * measured EITHER field wins whole, so a partial final capture omits fields the launch-time capture
- * had (honest omission); only a final capture that measured NOTHING falls back to the launch-time
+ * The participant's final browser geometry, measured while the sandbox is alive. A final capture that
+ * measured either field wins whole, so a partial final capture omits fields the launch-time capture
+ * had; only a final capture that measured nothing falls back to the launch-time
  * capture. Also reads the emulation holder's log into the fidelity block.
  */
 export async function finalParticipantGeometry(args) {
@@ -126,7 +127,7 @@ export async function finalParticipantGeometry(args) {
     ];
     warnings.push(...geometryWarnings);
     // The emulation holder's own log, after its announce line: which later targets it
-    // attached to, what it sent, and any reply that came back as an error (#623). Read while
+    // attached to, what it sent, and any reply that came back as an error. Read while
     // the sandbox is alive; the first live proof had no way to say what the holder did.
     if (fidelity.applied !== undefined && fidelity.holderName !== undefined) {
         const holderLog = await readDetachedLog(e2bShell(desktop), fidelity.holderName, deps.requestTimeoutMs).catch(() => "");

package/dist/routes/computer-use/e2b-desktop/prepare.d.ts

@@ -5,12 +5,12 @@ export declare const CUA_ACTOR_LAB_PROVIDER_METADATA: {
     readonly tool: "humanish";
 };
 /**
- * Create the lane's sandbox, record its resources, run the adopter's prepare hook, and attach the
- * lane's inbox and comms catch. Returns the sandbox, which the later steps drive.
+ * Create the participant's sandbox, record its resources, run the adopter's prepare hook, and attach the
+ * participant's inbox and comms catch. Returns the sandbox, which the later steps drive.
  */
 export declare function acquireParticipantDesktop(ctx: E2BParticipantContext, state: E2BParticipantState): Promise<E2BDesktopSandbox>;
 /**
- * Verify the lane's screen in the sandbox. A mismatch fails the lane closed unless the run records
+ * Verify the participant's screen in the sandbox. A mismatch fails the participant closed unless the run records
  * requested and verified geometry side by side.
  */
 export declare function verifyParticipantScreen(ctx: E2BParticipantContext, state: E2BParticipantState, desktop: E2BDesktopSandbox): Promise<void>;

package/dist/routes/computer-use/e2b-desktop/prepare.js

@@ -1,5 +1,5 @@
-// The first half of an E2B desktop lane's preparation: acquire the sandbox, verify its screen, and
-// provision the subject. Each step fills the lane's state; a step that cannot proceed throws.
+// The first half of an E2B desktop participant's preparation: acquire the sandbox, verify its screen, and
+// provision the subject. Each step fills the participant's state; a step that cannot proceed throws.
 import { redactText } from "../../../evidence/redaction.js";
 import { provisionCloneSubject } from "../../../subject/clone.js";
 import { provisionDesktopCli } from "../../../subject/desktop-cli.js";
@@ -10,22 +10,24 @@ import { acquireE2BDesktopSandbox, e2bDesktopTemplate } from "../../../substrate
 import { loadE2BDesktopModule } from "../../../substrates/e2b/sdk.js";
 import { e2bShell } from "../../../substrates/e2b/shell.js";
 import { attachReceivingInbox, participantCommsEnv, startCommsCatch } from "./comms.js";
+import { participantSubjectEnv } from "../types.js";
 export const CUA_ACTOR_LAB_PROVIDER_METADATA = {
     mode: "cua-actor-lab",
     tool: "humanish",
 };
 /**
- * Create the lane's sandbox, record its resources, run the adopter's prepare hook, and attach the
- * lane's inbox and comms catch. Returns the sandbox, which the later steps drive.
+ * Create the participant's sandbox, record its resources, run the adopter's prepare hook, and attach the
+ * participant's inbox and comms catch. Returns the sandbox, which the later steps drive.
  */
 export async function acquireParticipantDesktop(ctx, state) {
     const { spec, deps, warnings } = ctx;
-    const { config, subjectEnvNames, env } = deps;
-    const subjectEnvValues = config.subject.envValues ?? {};
-    // Off-app comms (#297): the base-URL env is injected at sandbox create, so the app reads it at
+    const { residual, env } = deps;
+    const subjectEnvNames = participantSubjectEnv(deps.subject);
+    const subjectEnvValues = residual.subject.envValues ?? {};
+    // Off-app comms: the base-URL env is injected at sandbox create, so the app reads it at
     // boot; the catch starts right after create.
     const commsEnv = participantCommsEnv(ctx.comms);
-    const desktopModule = await (deps.hooks.loadDesktopModule ?? loadE2BDesktopModule)();
+    const desktopModule = await (deps.desktopModule ?? loadE2BDesktopModule)();
     // An explicit template wins. Speech gets the versioned media image; ordinary
     // browser studies retain the SDK default desktop.
     const acquired = await acquireE2BDesktopSandbox({
@@ -36,11 +38,11 @@ export async function acquireParticipantDesktop(ctx, state) {
             timeoutMs: deps.sandboxMs,
             metadata: {
                 ...CUA_ACTOR_LAB_PROVIDER_METADATA,
-                labId: config.id,
-                simId: spec.recordId,
-                laneId: spec.planned.id,
-                laneIndex: String(spec.planned.index),
-                laneCount: String(deps.participantCount),
+                labId: deps.labId,
+                recordId: spec.recordId,
+                participantId: spec.planned.id,
+                participantIndex: String(spec.planned.index),
+                participantCount: String(deps.participantCount),
             },
             // The participant's model key never enters the sandbox (the model drives from outside).
             // The subject's declared env names are provisioned here on the clone route.
@@ -62,7 +64,7 @@ export async function acquireParticipantDesktop(ctx, state) {
             dpi: 96,
             lifecycle: { onTimeout: "kill" },
         },
-        template: e2bDesktopTemplate(config),
+        template: e2bDesktopTemplate(residual),
         retry: {
             // The default loader reclaims an acquired handle before retrying failed desktop startup.
             // Its error names the cleanup outcome; pre-construction allocation failures remain unowned.
@@ -76,7 +78,7 @@ export async function acquireParticipantDesktop(ctx, state) {
                 });
             },
         },
-        // The receipt is on disk before any work, so `humanish reclaim` can kill this lane's
+        // The receipt is on disk before any work, so `humanish reclaim` can kill this participant's
         // sandbox by exact id after an interrupt.
         receipt: { root: deps.artifactRoot, participantId: spec.planned.id, now: deps.now },
     });
@@ -92,13 +94,10 @@ export async function acquireParticipantDesktop(ctx, state) {
     if ("reason" in desktopResources) {
         warnings.push(`Desktop resource size unavailable (${desktopResources.reason}); compute cost remains unpriced.`);
     }
-    if (deps.hooks.prepareDesktop) {
-        await deps.hooks.prepareDesktop(desktop, {
-            laneId: spec.planned.id,
-            laneIndex: spec.planned.index,
-            laneCount: deps.participantCount,
-        });
-    }
+    await deps.prepareDesktop?.(desktop, {
+        kind: "participant",
+        participant: { id: spec.planned.id, index: spec.planned.index, count: deps.participantCount },
+    });
     if (deps.receiving) {
         state.receivingInboxUrl = await attachReceivingInbox(shell, spec, { ...deps, receiving: deps.receiving }, ctx.targetUrl);
         state.commsArtifactPath = "comms/receiving.json";
@@ -108,7 +107,7 @@ export async function acquireParticipantDesktop(ctx, state) {
     return desktop;
 }
 /**
- * Verify the lane's screen in the sandbox. A mismatch fails the lane closed unless the run records
+ * Verify the participant's screen in the sandbox. A mismatch fails the participant closed unless the run records
  * requested and verified geometry side by side.
  */
 export async function verifyParticipantScreen(ctx, state, desktop) {
@@ -130,12 +129,12 @@ export async function verifyParticipantScreen(ctx, state, desktop) {
         state.desktopGeometry = { ...state.desktopGeometry, warnings: [screenGeometry.warning] };
     }
     if (screenGeometry.error && deps.screenMismatchPolicy !== "record-evidence") {
-        state.failureCode = "HUMANISH_CUA_LAB_DEVICE_GEOMETRY";
+        state.failureCode = "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY";
         throw new Error(screenGeometry.error);
     }
     if (screenGeometry.error && screenGeometry.verified) {
         // record-evidence policy: the bundle keeps requested vs verified as separate facts and
-        // discloses the divergence instead of failing this lane's world mid-flight.
+        // discloses the divergence instead of failing this participant's world mid-flight.
         const mismatchWarning = deps.scrubKnownValues(`Participant ${spec.planned.id} requested a ${spec.planned.device.resolution[0]}x${spec.planned.device.resolution[1]} screen but xdpyinfo reports ${screenGeometry.verified.width}x${screenGeometry.verified.height}; recording requested vs verified separately instead of failing the participant closed.`);
         warnings.push(mismatchWarning);
         state.desktopGeometry = {
@@ -147,28 +146,26 @@ export async function verifyParticipantScreen(ctx, state, desktop) {
 /** Install a desktop CLI, or clone or unpack the subject and serve it, in the sandbox. */
 export async function provisionParticipantSubject(ctx, state, desktop) {
     const { deps } = ctx;
-    const { config, cloneRoute, localTreeRoute, serve, subjectRepo } = deps;
+    const { residual, subject } = deps;
     const shell = e2bShell(desktop);
-    if (ctx.desktopCliRoute) {
-        // Prepare the runtime and any declared product install, UNKEYED. With install omitted,
+    if (subject.kind === "desktop-cli") {
+        // Prepare the runtime and any declared product install, with no keys. With install omitted,
         // the participant discovers and installs the product from its public surfaces.
         await provisionDesktopCli(shell, {
-            product: config.subject.product?.name ?? "",
-            ...(config.subject.product?.install === undefined
-                ? {}
-                : { install: config.subject.product.install }),
+            product: subject.product.name,
+            ...(subject.product.install === undefined ? {} : { install: subject.product.install }),
             requestTimeoutMs: deps.requestTimeoutMs,
             scrub: deps.scrubKnownValues,
             onPhase: ctx.onSubjectPhase,
         });
     }
-    if (cloneRoute && serve && subjectRepo) {
+    if (subject.kind === "clone") {
         state.subjectCommit = await provisionCloneSubject(shell, {
-            repo: subjectRepo,
-            depth: config.subject.clone?.depth ?? 1,
-            serve,
-            ...(config.subject.state === undefined ? {} : { state: config.subject.state }),
-            hasGithubToken: deps.hasGithubToken,
+            repo: subject.repo,
+            depth: residual.subject.clone?.depth ?? 1,
+            serve: subject.serve,
+            ...(subject.state === undefined ? {} : { state: subject.state }),
+            hasGithubToken: subject.env.includes("GITHUB_TOKEN"),
             requestTimeoutMs: deps.requestTimeoutMs,
             scrub: deps.scrubKnownValues,
             onCommit: (commit) => {
@@ -178,21 +175,21 @@ export async function provisionParticipantSubject(ctx, state, desktop) {
                 state.stateStepRecords.push(record);
             },
             onPhase: ctx.onSubjectPhase,
-            ...deps.hooks.detachedTimers,
+            ...deps.detachedTimers,
         });
     }
-    else if (localTreeRoute && serve && deps.localTreeArchiveBuffer) {
+    else if (subject.kind === "local-tree" && deps.localTreeArchiveBuffer) {
         await provisionLocalTreeSubject(shell, {
             archiveBuffer: deps.localTreeArchiveBuffer,
-            serve,
-            ...(config.subject.state === undefined ? {} : { state: config.subject.state }),
+            serve: subject.serve,
+            ...(subject.state === undefined ? {} : { state: subject.state }),
             requestTimeoutMs: deps.requestTimeoutMs,
             scrub: deps.scrubKnownValues,
             onStateStep: (record) => {
                 state.stateStepRecords.push(record);
             },
             onPhase: ctx.onSubjectPhase,
-            ...deps.hooks.detachedTimers,
+            ...deps.detachedTimers,
         });
     }
 }

package/dist/routes/computer-use/e2b-desktop/start.d.ts

@@ -9,6 +9,6 @@ export declare function startParticipantMedia(ctx: E2BParticipantContext, state:
 export declare function openParticipantSurface(ctx: E2BParticipantContext, state: E2BParticipantState, desktop: E2BDesktopSandbox): Promise<void>;
 /**
  * Measure the browser window and start the live stream. A stream that cannot start is a warning;
- * unusable browser geometry fails the lane before any participant action.
+ * unusable browser geometry fails the participant before any action.
  */
 export declare function startParticipantStream(ctx: E2BParticipantContext, state: E2BParticipantState, desktop: E2BDesktopSandbox): Promise<void>;

package/dist/routes/computer-use/e2b-desktop/start.js

@@ -1,16 +1,17 @@
-// The second half of an E2B desktop lane's preparation, and the start of its session: speech and
+// The second half of an E2B desktop participant's preparation, and the start of its session: speech and
 // recording, then the browser or terminal the participant sees, then the live stream. Each step
-// fills the lane's state.
+// fills the participant's state.
 import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
 import { CHROME_DEVTOOLS_PORT, DESKTOP_SETTLE_MS, openDesktopBrowserTarget, openDesktopTerminal, startDesktopStream, } from "../../../substrates/e2b/desktop-browser.js";
 import { captureDesktopBrowserGeometry } from "../../../substrates/e2b/desktop-geometry.js";
 import { prepareDesktopMedia, startE2BDesktopMedia, } from "../../../substrates/e2b/desktop-media.js";
 import { startE2BDesktopRecording } from "../../../substrates/e2b/desktop-recording.js";
 import { applyParticipantMobileFidelity, mobileLaunchFlags } from "./fidelity.js";
+import { streamEvent } from "../../../lab/run-lab-homes.js";
 /** Start the declared speech worker and screen recording. A recording that cannot start is a warning. */
 export async function startParticipantMedia(ctx, state, desktop) {
     const { spec, deps, warnings } = ctx;
-    const requestedMedia = deps.config.execution?.desktop?.media;
+    const requestedMedia = deps.residual.execution?.desktop?.media;
     if (!ctx.desktopCliRoute && requestedMedia?.microphone?.source === "speech") {
         state.speech = await startE2BDesktopMedia({
             desktop,
@@ -20,7 +21,7 @@ export async function startParticipantMedia(ctx, state, desktop) {
             requestTimeoutMs: deps.requestTimeoutMs,
         });
     }
-    const requestedRecording = deps.config.execution?.desktop?.recording;
+    const requestedRecording = deps.residual.execution?.desktop?.recording;
     if (requestedRecording) {
         try {
             state.recording = await startE2BDesktopRecording({
@@ -43,28 +44,28 @@ export async function startParticipantMedia(ctx, state, desktop) {
  */
 export async function openParticipantSurface(ctx, state, desktop) {
     const { spec, deps, warnings, targetUrl } = ctx;
-    const { config } = deps;
-    if (ctx.desktopCliRoute) {
+    const { residual, subject } = deps;
+    if (subject.kind === "desktop-cli") {
         // A terminal window, opened the way the browser is opened on every other route: the
         // participant arrives at a desktop with the thing they were asked to use already in front
-        // of them. They can still open another from the dock — that is the point of a desktop.
-        await openDesktopTerminal(desktop, deps.requestTimeoutMs, config.subject.product?.workdir);
+        // of them. They can still open another from the dock; that is the point of a desktop.
+        await openDesktopTerminal(desktop, deps.requestTimeoutMs, subject.product.workdir);
         await desktop.wait(DESKTOP_SETTLE_MS).catch(() => undefined);
         return;
     }
-    const requestedMedia = config.execution?.desktop?.media;
-    // A declared camera (#509) is in place before the browser starts: the feed is generated or
-    // uploaded first, and a feed that cannot be produced fails the lane closed here.
+    const requestedMedia = residual.execution?.desktop?.media;
+    // A declared camera is in place before the browser starts: the feed is generated or
+    // uploaded first, and a feed that cannot be produced fails the participant closed here.
     const mediaEvidence = requestedMedia === undefined
         ? undefined
-        : await prepareDesktopMedia(desktop, requestedMedia, config.policies?.mediaPermission ?? "prompt", deps.labCwd, deps.requestTimeoutMs);
-    const emulationFlags = mobileLaunchFlags(config, spec);
-    const browserLaunch = await openDesktopBrowserTarget(desktop, targetUrl, deps.requestTimeoutMs, config.execution?.desktop?.browser, [...emulationFlags, ...(mediaEvidence?.flags ?? [])], state.speech?.env ?? state.recording?.env);
+        : await prepareDesktopMedia(desktop, requestedMedia, residual.policies?.mediaPermission ?? "prompt", deps.labCwd, deps.requestTimeoutMs);
+    const emulationFlags = mobileLaunchFlags(residual, spec);
+    const browserLaunch = await openDesktopBrowserTarget(desktop, targetUrl, deps.requestTimeoutMs, residual.execution?.desktop?.browser, [...emulationFlags, ...(mediaEvidence?.flags ?? [])], state.speech?.env ?? state.recording?.env);
     state.desktopBrowser =
         mediaEvidence === undefined
             ? browserLaunch.evidence
             : {
-                requested: config.execution?.desktop?.browser ?? "default",
+                requested: residual.execution?.desktop?.browser ?? "default",
                 ...browserLaunch.evidence,
                 media: mediaEvidence,
             };
@@ -76,8 +77,8 @@ export async function openParticipantSurface(ctx, state, desktop) {
     state.browserLaunched = true;
     noteDevToolsReadiness(ctx, browserLaunch.devTools, emulationFlags.length > 0);
     await desktop.wait(DESKTOP_SETTLE_MS).catch(() => undefined);
-    // Mobile fidelity (#221) is applied outside startParticipantStream's best-effort catch, so a request
-    // that cannot be applied fails the lane closed.
+    // Mobile fidelity is applied outside startParticipantStream's best-effort catch, so a request
+    // that cannot be applied fails the participant closed.
     state.fidelity = await applyParticipantMobileFidelity({
         desktop,
         spec,
@@ -90,14 +91,14 @@ export async function openParticipantSurface(ctx, state, desktop) {
     });
 }
 /**
- * DevTools answering later than this after launch is recorded as a warning on the lane. Six live
- * launches answered in 4.8-7.7 s; the reads this wait now guards used to give up at about 11 s.
+ * DevTools answering later than this after launch is recorded as a warning on the participant. Six live
+ * launches answered in 4.8-7.7 s; without this wait the reads it guards give up at about 11 s.
  */
 const SLOW_DEVTOOLS_MS = 10_000;
 /**
  * Records how Chrome's DevTools port answered after launch, as a timed phase in the bundle. A
- * device-emulated lane fails closed when the port never answered, because emulation is applied
- * over DevTools. Other lanes continue with a warning: their DevTools reads already degrade to
+ * device-emulated participant fails closed when the port never answered, because emulation is applied
+ * over DevTools. Other participants continue with a warning: their DevTools reads already degrade to
  * warnings of their own.
  */
 function noteDevToolsReadiness(ctx, devTools, emulated) {
@@ -132,7 +133,7 @@ function noteDevToolsReadiness(ctx, devTools, emulated) {
 }
 /**
  * Measure the browser window and start the live stream. A stream that cannot start is a warning;
- * unusable browser geometry fails the lane before any participant action.
+ * unusable browser geometry fails the participant before any action.
  */
 export async function startParticipantStream(ctx, state, desktop) {
     const { spec, deps, warnings } = ctx;
@@ -156,8 +157,8 @@ export async function startParticipantStream(ctx, state, desktop) {
             state.browserWindowId = browserGeometry.browserWindowId;
             state.browserTargetId = browserGeometry.browserTargetId;
         }
-        // A browser lane streams its browser window when one was found. A CLI lane has no window id
-        // and streams the whole desktop: a person studying a terminal app opens other windows, and
+        // A browser participant streams its browser window when one was found. A CLI participant has
+        // no window id and streams the whole desktop: a person studying a terminal app opens other windows, and
         // a stream bound to the first one would quietly stop being evidence.
         await startDesktopStream(desktop, state.browserWindowId);
         const candidateStreamUrl = desktop.stream.getUrl({
@@ -168,13 +169,14 @@ export async function startParticipantStream(ctx, state, desktop) {
         });
         if (typeof candidateStreamUrl === "string" && candidateStreamUrl.trim().length > 0) {
             state.streamUrl = candidateStreamUrl;
-            await deps.hooks.onRuntimeStreamReady?.({
-                laneId: spec.planned.id,
+            await deps.onStream(streamEvent({
+                type: "ready",
+                participantId: spec.planned.id,
                 sandboxId: desktop.sandboxId,
-                simId: spec.recordId,
+                recordId: spec.recordId,
                 streamId: spec.streamId,
                 url: candidateStreamUrl,
-            });
+            }));
         }
         else {
             warnings.push("Live desktop stream started but did not return a usable watch URL; Observer will fall back to screenshots.");
@@ -184,10 +186,10 @@ export async function startParticipantStream(ctx, state, desktop) {
         warnings.push(`Live desktop stream unavailable (run continues; evidence still captured): ${redactText(deps.scrubKnownValues(toErrorMessage(error)))}`);
     }
     // This is outside the stream's best-effort catch: unusable geometry is a harness failure,
-    // never a participant finding about missing controls. Both per-lane and shared-world seats
+    // never a participant finding about missing controls. Both computer-use and shared-world participants
     // use this route.
     if (state.initialBrowserGeometry?.unusable !== undefined) {
-        state.failureCode = "HUMANISH_CUA_LAB_DEVICE_GEOMETRY";
+        state.failureCode = "HUMANISH_COMPUTER_USE_DEVICE_GEOMETRY";
         throw new Error(`${state.failureCode}: ${state.initialBrowserGeometry.unusable} Participant actions were not started.`);
     }
 }

package/dist/routes/computer-use/e2b-desktop/state.d.ts

@@ -12,11 +12,11 @@ import type { E2BDesktopSandbox } from "../../../substrates/e2b/sdk.js";
 import type { ParticipantDesktopEvidence } from "../participant-desktop.js";
 import type { ParticipantComms, RunningCommsCatch } from "./comms.js";
 import type { ParticipantFidelity } from "./fidelity.js";
-import type { CuaActorLabErrorCode, CuaParticipantDeps, DesktopParticipantRun } from "../types.js";
-/** What every step of one lane reads: its spec, the run's dependencies and where it points. */
+import type { CuaActorLabErrorCode, E2BDesktopDeps, DesktopParticipantRun, SandboxReleaseFact } from "../types.js";
+/** What every step of one participant reads: its spec, the run's dependencies and where it points. */
 export interface E2BParticipantContext {
     readonly spec: DesktopParticipantRun;
-    readonly deps: CuaParticipantDeps;
+    readonly deps: E2BDesktopDeps;
     readonly warnings: string[];
     readonly targetUrl: string;
     readonly desktopCliRoute: boolean;
@@ -37,6 +37,7 @@ export interface E2BParticipantState {
     sandboxTornDownAtMs: number | undefined;
     desktopResources: DesktopResourceObservation | undefined;
     released: boolean;
+    sandboxRelease: SandboxReleaseFact | undefined;
     failureCode: CuaActorLabErrorCode | undefined;
     commsCatch: RunningCommsCatch | undefined;
     commsArtifactPath: string | undefined;
@@ -61,5 +62,5 @@ export interface E2BParticipantState {
     streamUrl: string | undefined;
 }
 export declare function newParticipantState(spec: DesktopParticipantRun): E2BParticipantState;
-/** The lane's outcome evidence, read from its state. */
+/** The participant's outcome evidence, read from its state. */
 export declare function desktopEvidenceOf(state: E2BParticipantState): ParticipantDesktopEvidence;

package/dist/routes/computer-use/e2b-desktop/state.js

@@ -1,5 +1,5 @@
-// What one E2B desktop lane records as it runs. The prepare, start and teardown steps fill one
-// record in order, and desktopEvidenceOf reads it for the lane's outcome.
+// What one E2B desktop participant records as it runs. The prepare, start and teardown steps fill one
+// record in order, and desktopEvidenceOf reads it for the participant's outcome.
 import { declaredScreenForRender, } from "../../../substrates/e2b/desktop-geometry.js";
 export function newParticipantState(spec) {
     const declaredScreen = declaredScreenForRender(spec.planned.device.preset, spec.planned.device.name, spec.planned.device.resolution);
@@ -11,6 +11,7 @@ export function newParticipantState(spec) {
         sandboxTornDownAtMs: undefined,
         desktopResources: undefined,
         released: false,
+        sandboxRelease: undefined,
         failureCode: undefined,
         commsCatch: undefined,
         commsArtifactPath: undefined,
@@ -42,7 +43,7 @@ export function newParticipantState(spec) {
         streamUrl: undefined,
     };
 }
-/** The lane's outcome evidence, read from its state. */
+/** The participant's outcome evidence, read from its state. */
 export function desktopEvidenceOf(state) {
     // Host-side approximation of the E2B desktop's billed lifetime; feeds the desktop-minute cost
     // estimate. Never negative.
@@ -54,6 +55,7 @@ export function desktopEvidenceOf(state) {
         ...(desktopDurationMs === undefined ? {} : { desktopDurationMs }),
         ...(state.desktopResources === undefined ? {} : { desktopResources: state.desktopResources }),
         released: state.released,
+        ...(state.sandboxRelease === undefined ? {} : { sandboxRelease: state.sandboxRelease }),
         streamUrlPresent: state.streamUrl !== undefined,
         ...(state.subjectCommit === undefined ? {} : { subjectCommit: state.subjectCommit }),
         ...(state.desktopBrowser === undefined ? {} : { desktopBrowser: state.desktopBrowser }),

package/dist/routes/computer-use/e2b-desktop/teardown.d.ts

@@ -1,6 +1,6 @@
 import type { E2BParticipantContext, E2BParticipantState } from "./state.js";
 /**
- * Finish a lane: collect its final geometry and comms evidence, then stop its media and release
+ * Finish a participant: collect its final geometry and comms evidence, then stop its media and release
  * its sandbox. Evidence failures are warnings; the release always runs.
  */
 export declare function finishE2BDesktop(ctx: E2BParticipantContext, state: E2BParticipantState, failed: boolean): Promise<void>;

package/dist/routes/computer-use/e2b-desktop/teardown.js

@@ -1,4 +1,4 @@
-// Teardown for one E2B desktop lane: its final geometry and comms evidence are collected, then the
+// Teardown for one E2B desktop participant: its final geometry and comms evidence are collected, then the
 // recording and speech worker, then the sandbox is released by id (or kept for debugging), with a
 // warning for every outcome that is not a confirmed release.
 import { collectDesktopRecording } from "../../../evidence/desktop-recording-artifact.js";
@@ -7,15 +7,16 @@ import { readE2BRelease } from "../../../substrates/e2b/sandbox.js";
 import { e2bShell } from "../../../substrates/e2b/shell.js";
 import { drainCommsEvidence } from "./comms.js";
 import { finalParticipantGeometry } from "./fidelity.js";
+import { streamEvent } from "../../../lab/run-lab-homes.js";
 /**
- * Each route's own keep flag gates its own lane only: a clone.keep can never leak into a local-tree
- * lane's teardown decision, and vice versa.
+ * Each route's own keep flag gates its own participants only: a clone.keep can never leak into a
+ * local-tree participant's teardown decision, and vice versa.
  */
 function participantKeepReason(deps) {
-    const { config, cloneRoute, localTreeRoute } = deps;
-    if (cloneRoute && config.subject.clone?.keep === true)
+    const { residual, subject } = deps;
+    if (subject.kind === "clone" && residual.subject.clone?.keep === true)
         return "subject.clone.keep";
-    if (localTreeRoute && config.subject.localTree?.keep === true)
+    if (subject.kind === "local-tree" && residual.subject.localTree?.keep === true)
         return "subject.localTree.keep";
     return undefined;
 }
@@ -38,17 +39,18 @@ async function stopParticipantMedia(args) {
     return evidence;
 }
 /**
- * Release the lane's sandbox, or keep it when a keep flag is set and the lane failed. Returns true
- * only when the release is confirmed. A kept or unconfirmed sandbox can still accrue compute cost,
- * which the warnings say.
+ * Release the participant's sandbox, or keep it when a keep flag is set and the participant failed. `released`
+ * is true only when the release is confirmed; otherwise `sandboxRelease` says why. A kept or
+ * unconfirmed sandbox can still accrue compute cost, which the warnings say.
  */
 async function releaseParticipantDesktop(args) {
     const { allocation, keepReason, deps, warnings } = args;
     const keepForDebug = keepReason !== undefined && args.failed;
     const released = await allocation.close({ retainForDebug: keepForDebug });
     if (released.status === "retained") {
-        warnings.push(`Sandbox ${allocation.resourceId} kept for debugging (${keepReason} on failure); reclaim it via E2B or it will be killed on its server-side timeout.`);
-        return false;
+        const warning = `Sandbox ${allocation.resourceId} kept for debugging (${keepReason} on failure); reclaim it via E2B or it will be killed on its server-side timeout.`;
+        warnings.push(warning);
+        return { released: false, sandboxRelease: { state: "retained", warning } };
     }
     const reading = readE2BRelease(released, {
         label: "Sandbox",
@@ -57,10 +59,18 @@ async function releaseParticipantDesktop(args) {
     });
     if (reading.warning)
         warnings.push(reading.warning);
-    return reading.released;
+    if (reading.released)
+        return { released: true };
+    return {
+        released: false,
+        sandboxRelease: {
+            state: "unconfirmed",
+            warning: reading.warning ?? "Sandbox release is unconfirmed.",
+        },
+    };
 }
 /**
- * Finish a lane: collect its final geometry and comms evidence, then stop its media and release
+ * Finish a participant: collect its final geometry and comms evidence, then stop its media and release
  * its sandbox. Evidence failures are warnings; the release always runs.
  */
 export async function finishE2BDesktop(ctx, state, failed) {
@@ -122,27 +132,30 @@ export async function finishE2BDesktop(ctx, state, failed) {
             mediaStop: state.mediaStop,
             warnings,
         });
-        state.released = await releaseParticipantDesktop({
+        const release = await releaseParticipantDesktop({
             allocation,
             keepReason: participantKeepReason(deps),
             failed,
             deps,
             warnings,
         });
+        state.released = release.released;
+        state.sandboxRelease = release.sandboxRelease;
         // Close the observed span. A kept or unconfirmed sandbox can still accrue compute cost; the
         // summary records that remaining lifetime as unknown instead of calling this complete.
         state.sandboxTornDownAtMs = deps.now();
-        // The lane's live stream is now a dead page whichever teardown path ran (released, kept, or
+        // The participant's live stream is now a dead page whichever teardown path ran (released, kept, or
         // release-failed-awaiting-TTL); tell the watch overlay so the tile falls back to recorded
-        // evidence instead of "sandbox not found" (#357). Guarded: a viewer callback must never
+        // evidence instead of "sandbox not found". Guarded: a viewer callback must never
         // break teardown.
         if (state.streamUrl !== undefined) {
             try {
-                await deps.hooks.onRuntimeStreamEnded?.({
-                    laneId: spec.planned.id,
-                    simId: spec.recordId,
+                await deps.onStream(streamEvent({
+                    type: "ended",
+                    participantId: spec.planned.id,
+                    recordId: spec.recordId,
                     streamId: spec.streamId,
-                });
+                }));
             }
             catch {
                 // viewer-side only; nothing to record