humanish 0.106.1 → 0.108.0

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

@@ -5,16 +5,16 @@ import { type CuaSubjectProvenanceArg, type ParticipantRunOutcome } from "./type
 /** The human-readable state story appended to the provenance event (and review.md via it). */
 export declare function describeSubjectState(state: RunSubjectProvenance["state"], dryRun: boolean): string;
 /**
- * Feedback candidates derived from what LIVE participants actually reported (#392).
+ * Feedback candidates derived from what live participants actually reported.
  *
- * A live run's feedback draft used to fall through to a dry-run template, because no browser route
- * ever built a candidate. The candidate worth filing is the one the study produced: a participant
+ * A live run's feedback draft comes from these candidates, never from a dry-run template. The
+ * candidate worth filing is the one the study produced: a participant
  * who reported friction on the way (the most valuable thing a run captures), or one who stopped
- * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
- * any falls back to an honest live summary in the draft layer instead of a template.
+ * trying. A clean pass files nothing here: feedback exists to carry findings, and a run without
+ * any falls back to a live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
- * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted (participant messages and `session.reason` pass
+ * through redactNarration in the loop) and passes redactText again here as defense-in-depth.
  */
 export declare function participantFeedbackCandidates(args: {
     runId: string;
@@ -34,8 +34,8 @@ export declare function participantFeedbackCandidates(args: {
         commsArtifactPath?: string;
     }>;
 }): RunFeedbackCandidate[];
-/** Human-readable provenance line for the single-lane subject.provenance event (invariant 5):
- *  claims "cloned/packed and served" ONLY when it actually happened. */
+/** Human-readable provenance line for the single-participant subject.provenance event:
+ *  claims "cloned/packed and served" only when it actually happened. */
 export declare function subjectProvenanceMessage(provenance: CuaSubjectProvenanceArg, publicAppUrl: string, dryRun: boolean, hasSession: boolean): string;
 export declare function providerResourcesForOutcome(args: {
     outcome: ParticipantRunOutcome | undefined;

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

@@ -14,9 +14,9 @@ export function describeSubjectState(state, dryRun) {
         case "seeded":
             return `seeded (${state.seed?.length ?? 0} step(s): ${(state.seed ?? []).map((record) => record.name).join(", ")})`;
         case "unpinned":
-            return `UNPINNED (external: ${(state.externalEnvNames ?? []).join(", ")})`;
+            return `unpinned (external: ${(state.externalEnvNames ?? []).join(", ")})`;
         case "declared-not-run":
-            return `declared, not run (${dryRun ? "dry-run contract" : "provisioning did not complete"})`;
+            return `declared, not run (${dryRun ? "dry run" : "provisioning did not complete"})`;
         case "undeclared":
             return "undeclared";
         case "external-public":
@@ -24,16 +24,16 @@ export function describeSubjectState(state, dryRun) {
     }
 }
 /**
- * Feedback candidates derived from what LIVE participants actually reported (#392).
+ * Feedback candidates derived from what live participants actually reported.
  *
- * A live run's feedback draft used to fall through to a dry-run template, because no browser route
- * ever built a candidate. The candidate worth filing is the one the study produced: a participant
+ * A live run's feedback draft comes from these candidates, never from a dry-run template. The
+ * candidate worth filing is the one the study produced: a participant
  * who reported friction on the way (the most valuable thing a run captures), or one who stopped
- * trying. A clean pass files nothing here — feedback exists to carry findings, and a run without
- * any falls back to an honest live summary in the draft layer instead of a template.
+ * trying. A clean pass files nothing here: feedback exists to carry findings, and a run without
+ * any falls back to a live summary in the draft layer instead of a template.
  *
- * Everything quoted is already scrub+redacted — participant messages and `session.reason` pass
- * through redactNarration in the loop — and passes redactText again here as defense-in-depth.
+ * Everything quoted is already scrub+redacted (participant messages and `session.reason` pass
+ * through redactNarration in the loop) and passes redactText again here as defense-in-depth.
  */
 export function participantFeedbackCandidates(args) {
     const candidates = [];
@@ -59,8 +59,8 @@ export function participantFeedbackCandidates(args) {
             persona_id: participant.personaId,
             actor: "computer-use",
             substrate: args.substrate,
-            // The participant is reporting on the PRODUCT: friction and abandonment are target-app
-            // findings by the three-roles rule. A harness failure never reaches this builder — it is
+            // The participant is reporting on the product: friction and abandonment are target-app
+            // findings by the three-roles rule. A harness failure never reaches this builder; it is
             // not a participant report.
             failure_owner: "target-app",
             summary,
@@ -109,12 +109,12 @@ export function participantFeedbackCandidates(args) {
     }
     return candidates;
 }
-/** Human-readable provenance line for the single-lane subject.provenance event (invariant 5):
- *  claims "cloned/packed and served" ONLY when it actually happened. */
+/** Human-readable provenance line for the single-participant subject.provenance event:
+ *  claims "cloned/packed and served" only when it actually happened. */
 export function subjectProvenanceMessage(provenance, publicAppUrl, dryRun, hasSession) {
     if (provenance.source === "clone") {
         if (dryRun) {
-            return `Subject declared: clone of ${provenance.repo}, to be served at ${publicAppUrl} in-sandbox (dry-run contract; nothing cloned)`;
+            return `Subject declared: clone of ${provenance.repo}, to be served at ${publicAppUrl} in-sandbox (dry run; nothing cloned)`;
         }
         if (provenance.commit) {
             return hasSession
@@ -124,7 +124,7 @@ export function subjectProvenanceMessage(provenance, publicAppUrl, dryRun, hasSe
         return `Subject clone attempted from ${provenance.repo}; commit unresolved (provisioning failed before resolution)`;
     }
     if (dryRun) {
-        return `Subject declared: local working tree, to be packed and served at ${publicAppUrl} in-sandbox (dry-run contract; nothing packed)`;
+        return `Subject declared: local working tree, to be packed and served at ${publicAppUrl} in-sandbox (dry run; nothing packed)`;
     }
     if (provenance.archiveSha256) {
         const dirtyLabel = provenance.dirty === true
@@ -149,14 +149,21 @@ export function providerResourcesForOutcome(args) {
             kind: "sandbox",
             id: args.outcome.sandboxId,
             owner: "humanish",
-            status: args.outcome.killed ? "killed" : "running",
+            // Only a sandbox kept on purpose is known to be running; an unconfirmed release may or may
+            // not have stopped it.
+            status: args.outcome.killed
+                ? "killed"
+                : args.outcome.sandboxRelease?.state === "retained"
+                    ? "running"
+                    : "unknown",
             ...participantResourceIds(args.ids, args.participantId),
             createdAt: args.createdAt,
             cleanup: {
                 killed: args.outcome.killed,
                 reason: args.outcome.killed
                     ? "killed during normal participant teardown"
-                    : "not killed during normal participant teardown; cleanup may reclaim by exact recorded id",
+                    : (args.outcome.sandboxRelease?.warning ??
+                        "not killed during normal participant teardown; cleanup may reclaim by exact recorded id"),
             },
         },
     ];

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

@@ -2,7 +2,7 @@
 // and buildCuaRunBundle sends it to the single-participant or the fan-out builder with that
 // shape's arguments. renderCuaReviewMarkdown writes review.md. shared-world/bundle.ts holds the
 // same for that route.
-import { judgeOneParticipant, judgeParticipants } from "../../run/judge.js";
+import { judgeOneParticipant, judgeParticipants, verdictText, } from "../../run/judge.js";
 import { desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
 import { providerResourcesForOutcome } from "./bundle-parts.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
             ? {}
@@ -163,13 +157,13 @@ export function renderCuaReviewMarkdown(bundle) {
         "",
         `- run: ${bundle.runId}`,
         `- mode: ${bundle.mode}`,
-        `- run gate: ${bundle.review.verdict}`,
+        `- run gate: ${verdictText(bundle.review.verdict, bundle.mode)}`,
         `- summary: ${bundle.review.summary}`,
         ...(provenance ? [`- subject: ${provenance.message}`] : []),
         ...(trace
             ? [
                 `- actor: ${trace.provider} (${trace.lane}/${trace.protocol})`,
-                // Honest count: name the trace's actual screenshot mode ("raw" | "blurred"); say
+                // Name the trace's actual screenshot mode ("raw" | "blurred"); say
                 // nothing when no frames exist ("n/a") rather than claim a redaction that never ran.
                 `- evidence: ${trace.items.length} trace item(s), ${trace.counts.screenshots ?? 0} ${trace.redaction.screenshots === "raw" || trace.redaction.screenshots === "blurred"
                     ? `${trace.redaction.screenshots} screenshot(s)`

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;
@@ -19,10 +19,10 @@ 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.
+ * (loopback) so its verification mail is captured instead of sent to the internet. Undefined when the
+ * 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: 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,17 +8,18 @@ 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. */
 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.
+ * (loopback) so its verification mail is captured instead of sent to the internet. Undefined when the
+ * 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 }),
         }),
@@ -43,7 +42,7 @@ export function planParticipantComms(config, targetUrl, inSandboxSubject) {
 export function participantCommsEnv(comms) {
     if (comms === undefined)
         return {};
-    // injectEnv is absent on an adopter-hosted plane (#328): there is no subject env to inject
+    // injectEnv is absent on an adopter-hosted plane: there is no subject env to inject
     // because the operator points their own app at their own catch.
     const env = comms.email.injectEnv === undefined
         ? {}
@@ -76,23 +75,23 @@ export async function startCommsCatch(shell, comms, requestTimeoutMs) {
     if (!deployed.ready) {
         throw new Error(`comms email catch did not become ready on 127.0.0.1:${comms.port} in the subject sandbox`);
     }
-    // Write the EMPTY inbox once up front so the persona's /inbox always resolves to the "No messages
-    // yet." page — never a bare 404 — the instant it navigates there, even before any mail arrives OR if
+    // Write the empty inbox once up front so the persona's /inbox always resolves to the "No messages
+    // yet." page (never a bare 404) the instant it navigates there, even before any mail arrives or if
     // the app sends to an address no declared recipient matches (the loop only re-renders on new mail).
     await writeInboxSurface(shell, deployed.surfaceDir, [], {
         originMap: comms.originMap,
         requestTimeoutMs,
     });
-    // The surface uses its OWN FakeInbox + cursor, independent of the teardown evidence drain (two
-    // readers of the append-only NDJSON — no double-count).
+    // The surface uses its own FakeInbox + cursor, independent of the teardown evidence drain (two
+    // readers of the append-only NDJSON, so no double-count).
     const stop = new AbortController();
     let renderedCount = 0;
     const loop = (async () => {
         // Render-first (so even a short session gets a populated inbox), then refresh on a cadence. The
-        // cadence uses a REAL timer, NOT the injected instant clock: this loop is unbounded, so an instant
+        // cadence uses a real timer instead of the injected instant clock: this loop is unbounded, so an instant
         // sleep would busy-spin and starve the session's own timers. `stop` interrupts the wait
         // (and clears the timer) so teardown never blocks for a full cadence. Each refresh
-        // is a full, idempotent rebuild; `renderedCount` only advances on a SUCCESSFUL render so a
+        // is a full, idempotent rebuild; `renderedCount` only advances on a successful render so a
         // transient failure retries cleanly (no duplicate emails).
         for (;;) {
             try {
@@ -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.
@@ -203,19 +200,19 @@ export async function drainCommsEvidence(args) {
             return path;
         }
         if (collected.captured > 0) {
-            // Captured mail that matched no declared recipient must not vanish silently (invariant 6:
-            // honest signals): tell the operator to declare comms.email.recipients[].address to match
+            // Captured mail that matched no declared recipient must not vanish silently: tell the
+            // operator to declare comms.email.recipients[].address to match
             // the address the app actually sends to (e.g. the one the persona surface will sign up with).
-            warnings.push(`Comms catch captured ${collected.captured} email send(s) but none matched a declared recipient inbox — no comms evidence written. Declare comms.email.recipients[].address to match the address the app sends to.`);
+            warnings.push(`The email catch captured ${collected.captured} email send(s), but none matched a declared recipient inbox, so no email evidence was written. Set comms.email.recipients[].address to the address the app sends to.`);
         }
         else {
-            // Zero captures is the silent-broken shape (#351): the app never posted to the catch at
+            // Zero captures is the silent-broken shape: the app never posted to the catch at
             // all, so the personas stared at an empty inbox. Most common cause: the app does not
             // actually read the declared injectEnv var for its email API base URL.
             const transportHint = comms.email.smtp
                 ? `Verify the app reads ${comms.email.smtp.hostEnv}/${comms.email.smtp.portEnv} for its SMTP host and port`
                 : `Verify the app reads ${comms.email.injectEnv} for its email API base URL (an SDK that ignores it sends real mail or throws)`;
-            warnings.push(`Comms catch captured ZERO email sends — the app never delivered mail through the catch. ${transportHint} and that the flow reached an email step.`);
+            warnings.push(`The email catch captured no email sends: the app never delivered mail through it. ${transportHint} and that the flow reached an email step.`);
         }
     }
     catch (error) {

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,18 +14,18 @@ export function createE2BParticipantDesktop(spec, deps, warnings) {
         deps,
         warnings,
         targetUrl,
-        desktopCliRoute: deps.desktopCliRoute === true,
-        // Off-app comms (#297): gated entirely on config.comms; no comms declared, no change.
-        comms: planParticipantComms(deps.config, targetUrl, deps.cloneRoute || deps.localTreeRoute === true),
+        desktopCliRoute: deps.subject.kind === "desktop-cli",
+        // Off-app comms: gated entirely on config.comms; no comms declared, no change.
+        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, {
-                laneId: spec.planned.id,
-                laneIndex: spec.planned.index,
-                laneCount: deps.participantCount,
+            deps.reportSubjectPhase(event, {
+                id: spec.planned.id,
+                index: spec.planned.index,
+                count: deps.participantCount,
             });
         },
     };

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

@@ -1,30 +1,31 @@
-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, since nothing was
+ * emulated.
  */
 export declare function applyParticipantMobileFidelity(args: {
     desktop: E2BDesktopSandbox;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     targetUrl: string;
     browserFamily: DesktopBrowserFamily;
     launchIdentity: DesktopBrowserLaunchIdentity | undefined;
@@ -35,7 +36,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,15 +44,15 @@ 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
- * 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 declare function finalParticipantGeometry(args: {
     desktop: E2BDesktopSandbox;
     spec: DesktopParticipantRun;
-    deps: CuaParticipantDeps;
+    deps: E2BDesktopDeps;
     targetUrl: string;
     browserFamily: DesktopBrowserFamily;
     launchIdentity: DesktopBrowserLaunchIdentity | undefined;