humanish 0.106.1 → 0.107.0

package/dist/routes/computer-use/bundle.d.ts

@@ -1,32 +1,25 @@
 import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { ComputerUsePlan } from "../../lab/plan-types.js";
-import type { RunBundle, RunRerunLineage } from "../../run/bundle.js";
-import type { RunLabProvenance } from "../../run/status.js";
+import type { BundleRun, RunBundle, RunRerunLineage } from "../../run/bundle.js";
 import { type Judgment } from "../../run/judge.js";
 import type { CuaParticipantPlan, DesktopParticipantRun, CuaSubjectProjection, CuaSubjectProvenanceArg, ParticipantRunOutcome } from "./types.js";
 /** What every bundle of one run shares, in progress or final. */
 export interface CuaRunBundleBase {
-    lab?: RunLabProvenance;
+    /** The run every bundle of it belongs to. */
+    run: BundleRun;
     participantRuns: DesktopParticipantRun[];
     descriptor: CuaActorDescriptor;
     appUrl: string;
-    createdAt: string;
     plan: ComputerUsePlan;
-    runId: string;
     source: RunBundle["source"];
     participantPlan: CuaParticipantPlan;
     rerun?: RunRerunLineage;
     redactScreenshots: boolean;
-    inProcessRoute: boolean;
-    localAppSubject: boolean;
-    cloneRoute: boolean;
-    localTreeRoute: boolean;
     publicRepo?: string;
-    subjectEnvNames: string[];
 }
 /**
  * The judgment for the current state of a computer-use run, by the rule for its shape: one
- * participant (its tallied status is the verdict) or several (every lane must pass). The bundle's
+ * participant (its tallied status is the verdict) or several (every participant must pass). The bundle's
  * verdict and the lab result's ok both come from it.
  */
 export declare function judgeComputerUseRun(base: Pick<CuaRunBundleBase, "participantRuns" | "rerun">, state: {

package/dist/routes/computer-use/bundle.js

@@ -15,7 +15,7 @@ function isOneParticipantRun(base) {
 }
 /**
  * The judgment for the current state of a computer-use run, by the rule for its shape: one
- * participant (its tallied status is the verdict) or several (every lane must pass). The bundle's
+ * participant (its tallied status is the verdict) or several (every participant must pass). The bundle's
  * verdict and the lab result's ok both come from it.
  */
 export function judgeComputerUseRun(base, state) {
@@ -41,31 +41,25 @@ export function judgeComputerUseRun(base, state) {
  * the participant plan and each participant's subject. Both argument mappings are here.
  */
 export function buildCuaRunBundle(base, state) {
-    const lab = base.lab === undefined ? {} : { lab: base.lab };
     const inProgress = state.inProgress === undefined ? {} : { inProgress: true };
     if (isOneParticipantRun(base))
         return buildSingleParticipantBundle(singleParticipantArgs(base, state));
     return buildCuaFanoutBundle({
         verdict: state.judgment.verdict,
-        ...lab,
+        run: base.run,
         specs: base.participantRuns,
         ...(state.outcomes === undefined ? {} : { outcomes: state.outcomes }),
         subjects: state.subjects,
         aggregateSubject: state.aggregateSubject,
         descriptor: base.descriptor,
         appUrl: base.appUrl,
-        createdAt: base.createdAt,
         dryRun: state.dryRun,
         plan: base.plan,
-        runId: base.runId,
         source: base.source,
         participantPlan: base.participantPlan,
         ...(base.rerun === undefined ? {} : { rerun: base.rerun }),
         ...(state.failFastReason === undefined ? {} : { failFastReason: state.failFastReason }),
-        cloneRoute: base.cloneRoute,
-        localTreeRoute: base.localTreeRoute,
         ...(base.publicRepo === undefined ? {} : { publicRepo: base.publicRepo }),
-        subjectEnvNames: base.subjectEnvNames,
         ...inProgress,
     });
 }
@@ -78,7 +72,7 @@ function singleParticipantArgs(base, state) {
     return {
         verdict: state.judgment.verdict,
         realEmail: plan.residual.comms?.email?.kind === "real",
-        ...(base.lab === undefined ? {} : { lab: base.lab }),
+        run: base.run,
         actorId: base.descriptor.id,
         appUrl: spec.planned.targetUrl ?? base.appUrl,
         participantId: spec.planned.id,
@@ -89,7 +83,6 @@ function singleParticipantArgs(base, state) {
         ...(spec.planned.labels.caseGroup === undefined
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
-        createdAt: base.createdAt,
         dryRun: state.dryRun,
         labId: plan.labId,
         ...(plan.title ? { labTitle: plan.title } : {}),
@@ -97,8 +90,8 @@ function singleParticipantArgs(base, state) {
         ...(spec.evidenceAssignment === undefined ? {} : { assignment: spec.evidenceAssignment }),
         persona: spec.persona,
         resolution: spec.planned.device.resolution,
-        desktopRoute: !base.inProcessRoute,
-        substrate: base.inProcessRoute
+        desktopRoute: base.plan.runner.desktop !== "in-process",
+        substrate: base.plan.runner.desktop === "in-process"
             ? "local-filesystem"
             : plan.residual.execution?.target === "local"
                 ? "local-desktop"
@@ -106,7 +99,6 @@ function singleParticipantArgs(base, state) {
         ...(outcome?.desktopGeometry === undefined ? {} : { desktopGeometry: outcome.desktopGeometry }),
         ...(outcome?.recording === undefined ? {} : { recording: outcome.recording }),
         isMobile: spec.planned.device.preset.isMobile,
-        runId: base.runId,
         screenshots: outcome?.screenshots ?? [],
         captureRedaction: base.redactScreenshots ? "blurred" : "raw",
         ...(outcome?.session ? { session: outcome.session } : {}),
@@ -129,11 +121,13 @@ function singleParticipantArgs(base, state) {
         ...(outcome?.desktopBrowser === undefined ? {} : { desktopBrowser: outcome.desktopBrowser }),
         providerResources: providerResourcesForOutcome({
             outcome,
-            createdAt: base.createdAt,
+            createdAt: base.run.createdAt,
             ids: spec,
             participantId: spec.planned.id,
         }),
-        ...(base.localAppSubject || base.inProcessRoute ? { entryKind: "local-app" } : {}),
+        ...(base.plan.runner.subject.kind === "local-app" || base.plan.runner.desktop === "in-process"
+            ? { entryKind: "local-app" }
+            : {}),
         ...(outcome?.session ? { traceArtifactPath: spec.traceArtifactPath } : {}),
         ...(outcome?.commsArtifactPath === undefined
             ? {}

package/dist/routes/computer-use/diagnostics.d.ts

@@ -23,7 +23,7 @@ export declare function cuaParticipantDiagnostics(input: {
     noEngagement?: boolean;
     session?: SessionEnding;
 }): CuaDiagnostics;
-/** Each lane retains its details. The summary never borrows lane one's ending for other lanes. */
+/** Each participant retains its details. The summary never borrows the first one's ending for the others. */
 export declare function summarizeCuaDiagnostics(input: {
     dryRun: boolean;
     evidenceInvalid: boolean;

package/dist/routes/computer-use/diagnostics.js

@@ -54,7 +54,7 @@ export function cuaParticipantDiagnostics(input) {
         ? { category: "participant_outcome" }
         : { category: "unknown" };
 }
-/** Each lane retains its details. The summary never borrows lane one's ending for other lanes. */
+/** Each participant retains its details. The summary never borrows the first one's ending for the others. */
 export function summarizeCuaDiagnostics(input) {
     if (input.evidenceInvalid)
         return { category: "evidence_invalid" };

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

@@ -3,8 +3,8 @@ import { type DeployedCommsCatch } from "../../../comms/sandbox-catch.js";
 import type { LabCommsEmail, LabConfig } from "../../../lab/types.js";
 import type { Shell } from "../../../substrates/shell.js";
 import type { ReadyParticipantDesktop } from "../participant-desktop.js";
-import type { CuaParticipantDeps, DesktopParticipantRun } from "../types.js";
-/** A lane's captured-email wiring, decided from config before the sandbox exists. */
+import { type E2BDesktopDeps, type DesktopParticipantRun } from "../types.js";
+/** A participant's captured-email wiring, decided from config before the sandbox exists. */
 export interface ParticipantComms {
     readonly email: LabCommsEmail;
     readonly port: number;
@@ -20,9 +20,9 @@ export interface ParticipantComms {
 /**
  * On an in-sandbox subject route, redirect the app's email-API sends into an in-sandbox catch
  * (loopback) so its verification mail is CAPTURED, not sent to the internet. Undefined when the
- * lab declares no fake email, which leaves the lane unchanged.
+ * lab declares no fake email, which leaves the participant unchanged.
  */
-export declare function planParticipantComms(config: LabConfig, targetUrl: string, inSandboxSubject: boolean): ParticipantComms | undefined;
+export declare function planParticipantComms(comms: LabConfig["comms"], serveUrl: string | undefined, targetUrl: string, inSandboxSubject: boolean): ParticipantComms | undefined;
 /** The env the subject app reads to reach the catch, injected at sandbox create so it boots with it. */
 export declare function participantCommsEnv(comms: ParticipantComms | undefined): Record<string, string>;
 /** A started catch and the stop for its inbox-surface loop. */
@@ -37,20 +37,20 @@ export interface RunningCommsCatch {
  * rather than silently sending real mail.
  */
 export declare function startCommsCatch(shell: Shell, comms: ParticipantComms, requestTimeoutMs: number): Promise<RunningCommsCatch>;
-/** Stand up the real-email receiving surface and attach it to the lane; returns the inbox URL. */
-export declare function attachReceivingInbox(shell: Shell, spec: DesktopParticipantRun, deps: CuaParticipantDeps & {
-    receiving: NonNullable<CuaParticipantDeps["receiving"]>;
+/** Stand up the real-email receiving surface and attach it to the participant; returns the inbox URL. */
+export declare function attachReceivingInbox(shell: Shell, spec: DesktopParticipantRun, deps: E2BDesktopDeps & {
+    receiving: NonNullable<E2BDesktopDeps["receiving"]>;
 }, targetUrl: string): Promise<string>;
 /** The inbox the persona is told about: real receiving, the captured catch, or an external inbox. */
 export declare function participantInbox(args: {
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     receivingInboxUrl: string | undefined;
     comms: ParticipantComms | undefined;
     catchReady: boolean;
 }): ReadyParticipantDesktop["inbox"];
 /**
- * Before this lane's sandbox is torn down, drain everything the in-sandbox catch captured, route it
+ * Before this participant's sandbox is torn down, drain everything the in-sandbox catch captured, route it
  * into a host fake inbox addressed to the declared recipients, and write the digest-only thread
  * artifact. Returns the artifact path when one was written. A drain failure is a warning and never
  * breaks teardown: the sandbox must still be killed either way.
@@ -60,6 +60,6 @@ export declare function drainCommsEvidence(args: {
     comms: ParticipantComms;
     deployed: DeployedCommsCatch;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     warnings: string[];
 }): Promise<string | undefined>;

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

@@ -1,4 +1,4 @@
-// Off-app email for one E2B desktop lane (#297): the in-sandbox catch the subject app sends to, the
+// Off-app email for one E2B desktop participant (#297): the in-sandbox catch the subject app sends to, the
 // persona's inbox surface, the real-email receiving surface, and the evidence drained at teardown.
 import { setTimeout as delay } from "node:timers/promises";
 import { buildOriginMap } from "../../../comms/capture-surface.js";
@@ -8,6 +8,7 @@ import { DEFAULT_SANDBOX_CATCH_PORT, collectCommsThread, deployCommsCatch, refre
 import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
 import { writeContainedOutputFile } from "../../../run/contained-output.js";
 import { inboxRecipientFor, participantHasInboxRecipient } from "../participant-desktop.js";
+import { participantServeUrl } from "../types.js";
 import { addressedRecipients } from "../../../lab/parse/comms.js";
 /** Mid-run inbox-surface render cadence (ms). Coarse enough that the per-tick `cat` + file writes stay
  *  cheap; fine enough that a verification email is visible seconds after the app sends it. */
@@ -15,10 +16,10 @@ const INBOX_SURFACE_CADENCE_MS = 2500;
 /**
  * On an in-sandbox subject route, redirect the app's email-API sends into an in-sandbox catch
  * (loopback) so its verification mail is CAPTURED, not sent to the internet. Undefined when the
- * lab declares no fake email, which leaves the lane unchanged.
+ * lab declares no fake email, which leaves the participant unchanged.
  */
-export function planParticipantComms(config, targetUrl, inSandboxSubject) {
-    const email = inSandboxSubject && config.comms?.email?.kind === "fake" ? config.comms.email : undefined;
+export function planParticipantComms(comms, serveUrl, targetUrl, inSandboxSubject) {
+    const email = inSandboxSubject && comms?.email?.kind === "fake" ? comms.email : undefined;
     if (email === undefined)
         return undefined;
     const port = email.port ?? DEFAULT_SANDBOX_CATCH_PORT;
@@ -30,9 +31,7 @@ export function planParticipantComms(config, targetUrl, inSandboxSubject) {
         smtpPort: email.smtp?.port,
         inboxUrl: `http://127.0.0.1:${port}/inbox`,
         originMap: buildOriginMap({
-            ...(config.subject.serve?.url === undefined
-                ? {}
-                : { internalServeUrl: config.subject.serve.url }),
+            ...(serveUrl === undefined ? {} : { internalServeUrl: serveUrl }),
             reachableBaseUrl: targetUrl,
             ...(email.linkOrigin === undefined ? {} : { linkOrigin: email.linkOrigin }),
         }),
@@ -125,22 +124,20 @@ export async function startCommsCatch(shell, comms, requestTimeoutMs) {
         },
     };
 }
-/** Stand up the real-email receiving surface and attach it to the lane; returns the inbox URL. */
+/** Stand up the real-email receiving surface and attach it to the participant; returns the inbox URL. */
 export async function attachReceivingInbox(shell, spec, deps, targetUrl) {
-    const { config } = deps;
+    const serveUrl = participantServeUrl(deps.subject);
     const surface = await deployReceivingInbox(shell, {
         leaseId: spec.streamId,
         requestTimeoutMs: Math.min(deps.requestTimeoutMs, 30_000),
     });
-    const email = config.comms?.email;
+    const email = deps.residual.comms?.email;
     try {
         await deps.receiving.attach(spec.planned.id, {
             surface,
             allowedOrigins: [...new Set([new URL(targetUrl).origin, ...(email?.allowedOrigins ?? [])])],
             originMap: buildOriginMap({
-                ...(config.subject.serve?.url === undefined
-                    ? {}
-                    : { internalServeUrl: config.subject.serve.url }),
+                ...(serveUrl === undefined ? {} : { internalServeUrl: serveUrl }),
                 reachableBaseUrl: targetUrl,
                 ...(email?.linkOrigin === undefined ? {} : { linkOrigin: email.linkOrigin }),
             }),
@@ -177,7 +174,7 @@ export function participantInbox(args) {
     return undefined;
 }
 /**
- * Before this lane's sandbox is torn down, drain everything the in-sandbox catch captured, route it
+ * Before this participant's sandbox is torn down, drain everything the in-sandbox catch captured, route it
  * into a host fake inbox addressed to the declared recipients, and write the digest-only thread
  * artifact. Returns the artifact path when one was written. A drain failure is a warning and never
  * breaks teardown: the sandbox must still be killed either way.

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

@@ -1,3 +1,3 @@
 import type { ParticipantDesktop } from "../participant-desktop.js";
-import type { CuaParticipantDeps, DesktopParticipantRun } from "../types.js";
-export declare function createE2BParticipantDesktop(spec: DesktopParticipantRun, deps: CuaParticipantDeps, warnings: string[]): ParticipantDesktop;
+import { type E2BDesktopDeps, type DesktopParticipantRun } from "../types.js";
+export declare function createE2BParticipantDesktop(spec: DesktopParticipantRun, deps: E2BDesktopDeps, warnings: string[]): ParticipantDesktop;

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

@@ -1,7 +1,3 @@
-// E2B owns provisioning and final evidence; the participant runner only uses the ready port. The
-// lane's steps live in prepare.ts, start.ts and teardown.ts beside this file, and fill the state
-// record in state.ts in the order below.
-import { defaultSubjectPhaseSink } from "../../../subject/steps.js";
 import { createE2BDesktopExecutor } from "../../../substrates/e2b/desktop-executor.js";
 import { participantInbox, planParticipantComms } from "./comms.js";
 import { participantBrowserStateObserver } from "./fidelity.js";
@@ -9,6 +5,7 @@ import { acquireParticipantDesktop, provisionParticipantSubject, verifyParticipa
 import { openParticipantSurface, startParticipantMedia, startParticipantStream } from "./start.js";
 import { desktopEvidenceOf, newParticipantState } from "./state.js";
 import { finishE2BDesktop } from "./teardown.js";
+import { participantServeUrl } from "../types.js";
 export function createE2BParticipantDesktop(spec, deps, warnings) {
     const targetUrl = spec.planned.targetUrl ?? deps.appUrl;
     const state = newParticipantState(spec);
@@ -17,15 +14,15 @@ export function createE2BParticipantDesktop(spec, deps, warnings) {
         deps,
         warnings,
         targetUrl,
-        desktopCliRoute: deps.desktopCliRoute === true,
+        desktopCliRoute: deps.subject.kind === "desktop-cli",
         // Off-app comms (#297): gated entirely on config.comms; no comms declared, no change.
-        comms: planParticipantComms(deps.config, targetUrl, deps.cloneRoute || deps.localTreeRoute === true),
+        comms: planParticipantComms(deps.residual.comms, participantServeUrl(deps.subject), targetUrl, deps.subject.kind === "clone" || deps.subject.kind === "local-tree"),
         // The default or injected sink sees every event, started and completed alike, so an operator
         // watching stderr sees both halves of each phase; the state keeps only completed ones.
         onSubjectPhase: (event) => {
             if (event.ok !== undefined)
                 state.phaseRecords.push(event);
-            (deps.hooks.onPhase ?? defaultSubjectPhaseSink)(event, {
+            deps.reportSubjectPhase(event, {
                 laneId: spec.planned.id,
                 laneIndex: spec.planned.index,
                 laneCount: deps.participantCount,

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

@@ -1,30 +1,30 @@
-import type { LabConfig } from "../../../lab/types.js";
+import type { ResidualConfig } from "../../../lab/plan-types.js";
 import type { RunDesktopGeometry } from "../../../run/streams.js";
 import type { DesktopBrowserFamily, DesktopBrowserLaunchIdentity } from "../../../substrates/e2b/desktop-browser.js";
 import { makeChromeBrowserStateObserver } from "../../../substrates/e2b/desktop-cdp.js";
 import { captureDesktopBrowserGeometry } from "../../../substrates/e2b/desktop-geometry.js";
 import type { E2BDesktopSandbox } from "../../../substrates/e2b/sdk.js";
-import type { CuaParticipantDeps, DesktopParticipantRun } from "../types.js";
+import type { E2BDesktopDeps, DesktopParticipantRun } from "../types.js";
 type BrowserGeometry = Awaited<ReturnType<typeof captureDesktopBrowserGeometry>>;
-/** The mobile emulation a lane applied, updated as later tabs are covered and at teardown. */
+/** The mobile emulation a participant applied, updated as later tabs are covered and at teardown. */
 export interface ParticipantFidelity {
     applied: RunDesktopGeometry["fidelity"] | undefined;
     emulatedTargetId: string | undefined;
     holderName: string | undefined;
 }
-/** Only lanes on a mobile preset are emulated; the flags go on the browser command line. */
-export declare function mobileLaunchFlags(config: LabConfig, spec: DesktopParticipantRun): string[];
+/** Only participants on a mobile preset are emulated; the flags go on the browser command line. */
+export declare function mobileLaunchFlags(residual: Readonly<ResidualConfig>, spec: DesktopParticipantRun): string[];
 /**
  * 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, which is honest.
  */
 export declare function applyParticipantMobileFidelity(args: {
     desktop: E2BDesktopSandbox;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     targetUrl: string;
     browserFamily: DesktopBrowserFamily;
     launchIdentity: DesktopBrowserLaunchIdentity | undefined;
@@ -35,7 +35,7 @@ export declare function applyParticipantMobileFidelity(args: {
 export declare function participantBrowserStateObserver(args: {
     desktop: E2BDesktopSandbox;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     targetUrl: string;
     launchIdentity: DesktopBrowserLaunchIdentity | undefined;
     targetId: string | undefined;
@@ -43,7 +43,7 @@ export declare function participantBrowserStateObserver(args: {
     warnings: string[];
 }): ReturnType<typeof makeChromeBrowserStateObserver>;
 /**
- * The lane's final browser geometry, measured while the sandbox is alive. A final capture that
+ * 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 (honest omission); 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.
@@ -51,7 +51,7 @@ export declare function participantBrowserStateObserver(args: {
 export declare function finalParticipantGeometry(args: {
     desktop: E2BDesktopSandbox;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     targetUrl: string;
     browserFamily: DesktopBrowserFamily;
     launchIdentity: DesktopBrowserLaunchIdentity | undefined;

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
+// Device fidelity for one E2B desktop participant: mobile emulation beyond viewport size (#221), the
 // browser-state observer that watches it for drift (#623), 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,14 @@ 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, which is honest.
  */
 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,7 +62,7 @@ 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
+        // 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 (#514).
         onUnavailable: (reason) => {
             warnings.push(`Browser-state observer unavailable for participant ${spec.planned.id} (${redactText(deps.scrubKnownValues(reason))}); ` +
@@ -94,7 +94,7 @@ export function participantBrowserStateObserver(args) {
     });
 }
 /**
- * The lane's final browser geometry, measured while the sandbox is alive. A final capture that
+ * 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 (honest omission); 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.

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 ?? {};
+    const { residual, env } = deps;
+    const subjectEnvNames = participantSubjectEnv(deps.subject);
+    const subjectEnvValues = residual.subject.envValues ?? {};
     // Off-app comms (#297): 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,7 +38,7 @@ export async function acquireParticipantDesktop(ctx, state) {
             timeoutMs: deps.sandboxMs,
             metadata: {
                 ...CUA_ACTOR_LAB_PROVIDER_METADATA,
-                labId: config.id,
+                labId: deps.labId,
                 simId: spec.recordId,
                 laneId: spec.planned.id,
                 laneIndex: String(spec.planned.index),
@@ -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) {
@@ -135,7 +134,7 @@ export async function verifyParticipantScreen(ctx, state, desktop) {
     }
     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) {
+    if (subject.kind === "desktop-cli") {
         // Prepare the runtime and any declared product install, UNKEYED. 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,
         });
     }
 }