humanish 0.106.1 → 0.107.0

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,6 +1,6 @@
-// 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";
@@ -10,7 +10,7 @@ import { applyParticipantMobileFidelity, mobileLaunchFlags } from "./fidelity.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 +20,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 +43,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);
+        await openDesktopTerminal(desktop, deps.requestTimeoutMs, subject.product.workdir);
         await desktop.wait(DESKTOP_SETTLE_MS).catch(() => undefined);
         return;
     }
-    const requestedMedia = config.execution?.desktop?.media;
+    const requestedMedia = residual.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.
+    // 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,
             };
@@ -77,7 +77,7 @@ export async function openParticipantSurface(ctx, state, desktop) {
     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.
+    // that cannot be applied fails the participant closed.
     state.fidelity = await applyParticipantMobileFidelity({
         desktop,
         spec,
@@ -90,14 +90,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
+ * 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; the reads this wait now guards used to 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 +132,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 +156,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,8 +168,9 @@ 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({
+                type: "ready",
+                participantId: spec.planned.id,
                 sandboxId: desktop.sandboxId,
                 simId: spec.recordId,
                 streamId: spec.streamId,
@@ -184,7 +185,7 @@ 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";

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";
@@ -8,14 +8,14 @@ import { e2bShell } from "../../../substrates/e2b/shell.js";
 import { drainCommsEvidence } from "./comms.js";
 import { finalParticipantGeometry } from "./fidelity.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 +38,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 +58,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,24 +131,27 @@ 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
         // break teardown.
         if (state.streamUrl !== undefined) {
             try {
-                await deps.hooks.onRuntimeStreamEnded?.({
-                    laneId: spec.planned.id,
+                await deps.onStream({
+                    type: "ended",
+                    participantId: spec.planned.id,
                     simId: spec.recordId,
                     streamId: spec.streamId,
                 });

package/dist/routes/computer-use/external-comms.d.ts

@@ -2,12 +2,12 @@ import type { LabCommsEmail, LabCommsExternal } from "../../lab/types.js";
 import type { PreparedRunArtifactPaths } from "../../run/paths.js";
 import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
 /**
- * Adopter-hosted drain (#380): once per RUN, after every lane finished — the catch is one
+ * Adopter-hosted drain (#380): once per RUN, after every participant finished — the catch is one
  * shared external endpoint, not a per-sandbox file. Same routing and digest-only artifact as
- * the in-sandbox drain; the artifact is registered on every lane that declared a recipient
+ * the in-sandbox drain; the artifact is registered on every participant that declared a recipient
  * address, since the thread carries each inbox's mail. A drain failure never fails the run.
  *
- * Returns the warnings the drain produced; lanes that received mail get `commsArtifactPath`.
+ * Returns the warnings the drain produced; participants that received mail get `commsArtifactPath`.
  */
 export declare function drainExternalComms(args: {
     externalCommsConfig: LabCommsExternal;
@@ -16,5 +16,5 @@ export declare function drainExternalComms(args: {
     runPaths: PreparedRunArtifactPaths;
     participantRuns: readonly DesktopParticipantRun[];
     outcomes: ParticipantRunOutcome[];
-    scrubKnownValues: (text: string) => string;
+    knownSecretValues: readonly string[];
 }): Promise<string[]>;

package/dist/routes/computer-use/external-comms.js

@@ -1,55 +1,31 @@
-import { FakeInbox } from "../../comms/fake-inbox.js";
-import { collectExternalCommsThread } from "../../comms/sandbox-catch.js";
-import { redactText, toErrorMessage } from "../../evidence/redaction.js";
-import { writeContainedOutputFile } from "../../run/contained-output.js";
+import { collectExternalCommsEvidence } from "../../comms/external-evidence.js";
 import { participantHasInboxRecipient } from "./participant-desktop.js";
-import { addressedRecipients } from "../../lab/parse/comms.js";
 /**
- * Adopter-hosted drain (#380): once per RUN, after every lane finished — the catch is one
+ * Adopter-hosted drain (#380): once per RUN, after every participant finished — the catch is one
  * shared external endpoint, not a per-sandbox file. Same routing and digest-only artifact as
- * the in-sandbox drain; the artifact is registered on every lane that declared a recipient
+ * the in-sandbox drain; the artifact is registered on every participant that declared a recipient
  * address, since the thread carries each inbox's mail. A drain failure never fails the run.
  *
- * Returns the warnings the drain produced; lanes that received mail get `commsArtifactPath`.
+ * Returns the warnings the drain produced; participants that received mail get `commsArtifactPath`.
  */
 export async function drainExternalComms(args) {
-    const { externalCommsConfig, externalCommsEmail, env, runPaths, participantRuns, outcomes, scrubKnownValues, } = args;
-    const warnings = [];
-    try {
-        const commsChannel = new FakeInbox();
-        const commsInboxes = [];
-        for (const recipient of addressedRecipients(externalCommsEmail)) {
-            commsInboxes.push(await commsChannel.provisionAddress(recipient.participantId, recipient.address));
-        }
-        const authToken = externalCommsConfig.authTokenEnv === undefined
-            ? undefined
-            : env[externalCommsConfig.authTokenEnv];
-        const collected = await collectExternalCommsThread({
-            external: { ...externalCommsConfig, ...(authToken === undefined ? {} : { authToken }) },
-            channel: commsChannel,
-            inboxes: commsInboxes,
-        });
-        if (collected.artifact) {
-            const commsPath = "comms/thread.json";
-            await writeContainedOutputFile(runPaths, commsPath, `${JSON.stringify(collected.artifact, null, 2)}\n`, "utf8");
-            for (const [index, outcome] of outcomes.entries()) {
-                const participantId = participantRuns[index]?.planned.id;
-                if (participantId !== undefined &&
-                    outcome.commsArtifactPath === undefined &&
-                    participantHasInboxRecipient(externalCommsEmail, participantId)) {
-                    outcome.commsArtifactPath = commsPath;
-                }
+    const { externalCommsEmail, participantRuns, outcomes } = args;
+    const { path: commsPath, warnings } = await collectExternalCommsEvidence({
+        external: args.externalCommsConfig,
+        email: externalCommsEmail,
+        env: args.env,
+        runPaths: args.runPaths,
+        knownSecretValues: args.knownSecretValues,
+    });
+    if (commsPath !== undefined) {
+        for (const [index, outcome] of outcomes.entries()) {
+            const participantId = participantRuns[index]?.planned.id;
+            if (participantId !== undefined &&
+                outcome.commsArtifactPath === undefined &&
+                participantHasInboxRecipient(externalCommsEmail, participantId)) {
+                outcome.commsArtifactPath = commsPath;
             }
         }
-        else if (collected.captured > 0) {
-            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.`);
-        }
-        else {
-            warnings.push(`Comms catch captured ZERO email sends — your app never delivered mail through the catch at ${externalCommsConfig.catchBaseUrl}. Verify the app's email-API base URL points at it and that the flow reached an email step.`);
-        }
-    }
-    catch (error) {
-        warnings.push(`Comms evidence collection failed against the adopter-hosted catch (run continues): ${redactText(scrubKnownValues(toErrorMessage(error)))}`);
     }
     return warnings;
 }

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

@@ -1,10 +1,10 @@
 import { type RunBundle } from "../../run/bundle.js";
 import type { CuaFanoutBundleArgs } from "./types.js";
 /**
- * Project N>1 fan-out lanes into a humanish.run-bundle.v1 (the evidence schema is unchanged; this
- * is a new producer for the multi-stream shape). One sim + one stream per lane; per-lane
+ * Project N>1 fan-out participants into a humanish.run-bundle.v1 (the evidence schema is unchanged; this
+ * is a new producer for the multi-stream shape). One sim + one stream per participant; per-participant
  * provenance/session events; a recorded `cua-lab.fanout.plan` event (and a `cua-lab.fanout.fail-fast`
- * event when a harness error skipped queued lanes). N-ary verify/Observer already handle multiple
+ * event when a harness error skipped queued participants). N-ary verify/Observer already handle multiple
  * streams. A single-participant run without a rerun never reaches here: buildCuaRunBundle
  * (bundle.ts) sends it to buildSingleParticipantBundle (single-bundle.ts).
  */

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

@@ -3,27 +3,27 @@ import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { actorEnding } from "../../actors/stop-cause.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { aggregateTaskFunnels, formatParticipantOutcomes, formatStudyTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { participantFeedbackCandidates, providerResourcesForOutcome } from "./bundle-parts.js";
 import { participantFactsOf } from "./participant-facts.js";
 import { participantPassed, participantStatus } from "../../run/judge.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { formatParticipantPlanEntry } from "./participant-runs.js";
-import { fanoutParticipantRecords } from "./fanout-lanes.js";
+import { fanoutParticipantRecords } from "./fanout-records.js";
 /** The run's first two events: its creation and the fan-out plan. */
 function fanoutPlanEvents(args) {
     const { specs, plan } = args;
     const events = [];
     events.push({
         id: "event-000-created",
-        at: args.createdAt,
+        at: args.run.createdAt,
         level: "info",
         type: "cua-lab.run.created",
         message: `Created computer-use fan-out run for ${plan.labId} (actor ${args.descriptor.id}, ${specs.length} participants, one world each).`,
     });
     events.push({
         id: "event-001-fanout-plan",
-        at: args.createdAt,
+        at: args.run.createdAt,
         level: "info",
         type: "cua-lab.fanout.plan",
         message: `Fan-out plan: ${args.participantPlan.laneCount} participant(s) (${args.participantPlan.strategy}), concurrency ${args.participantPlan.concurrency}, ${args.participantPlan.waves} wave(s); session budget ${Math.round(args.participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${args.participantPlan.worstCaseSandboxMinutes} sandbox-minutes${args.dryRun ? " (dry-run: $0)" : ""}. Participants: ${args.participantPlan.lanes.map(formatParticipantPlanEntry).join(", ")}.`,
@@ -32,7 +32,7 @@ function fanoutPlanEvents(args) {
 }
 function fanoutReview(args, streams) {
     const { specs, outcomes } = args;
-    // The judge's verdict: live fan-out must prove every lane (judgeParticipants).
+    // The judge's verdict: live fan-out must prove every participant (judgeParticipants).
     const verdict = args.verdict;
     const passedParticipants = (outcomes ?? []).filter((outcome) => participantPassed(participantFactsOf(outcome))).length;
     // What happened to the PARTICIPANTS, with the denominator attached. The verdict above has to
@@ -40,10 +40,10 @@ function fanoutReview(args, streams) {
     const terminalOutcomes = (outcomes ?? []).filter((outcome) => outcome?.session?.status !== undefined);
     const participants = terminalOutcomes.length > 0
         ? tallyParticipantOutcomes(
-        // A NO-ENGAGEMENT lane is not a participant who reached the goal. It said "done" having
+        // A NO-ENGAGEMENT participant is not one who reached the goal. It said "done" having
         // taken zero actions and said nothing, and `passedParticipants` above already refuses to
         // count it — but `reachedGoal` was reading the trace status directly, so one run could be both
-        // "not a passed lane" AND "1/1 reached the goal". The headline number a researcher reads
+        // "not a passed participant" AND "1/1 reached the goal". The headline number a researcher reads
         // first was the dishonest one. Found by a provider bug that ended a study on turn one.
         terminalOutcomes.map((outcome) => participantStatus(outcome.session.status, {
             noEngagement: outcome.noEngagement === true,
@@ -58,7 +58,7 @@ function fanoutReview(args, streams) {
     const participantFunnels = (outcomes ?? [])
         .map((outcome) => outcome?.session?.trace.taskFunnel)
         .filter((funnel) => funnel !== undefined);
-    const studyTasks = args.inProgress === true ? undefined : aggregateTaskFunnels(participantFunnels);
+    const runTasks = args.inProgress === true ? undefined : aggregateTaskFunnels(participantFunnels);
     const participantEndings = terminalOutcomes.map((outcome) => {
         const ending = actorEnding(outcome.session.trace);
         return {
@@ -70,12 +70,12 @@ function fanoutReview(args, streams) {
         schema: REVIEW_SCHEMA,
         verdict,
         ...(participants === undefined ? {} : { participants }),
-        ...(studyTasks === undefined ? {} : { tasks: studyTasks }),
+        ...(runTasks === undefined ? {} : { tasks: runTasks }),
         summary: args.inProgress === true
             ? `Live computer-use fan-out is running (${specs.length} participants, one world each); terminal participant evidence has not been written yet.`
             : args.dryRun
                 ? `${args.rerun ? `Rerun contract from ${args.rerun.sourceRunId}: ` : ""}Dry-run fan-out contract: ${specs.length} participants composed for ${args.descriptor.id} against ${args.appUrl}, one world each; no desktops launched, $0 spend.`
-                : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${specs.length} participant(s) reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${studyTasks ? `; tasks: ${formatStudyTaskFunnel(studyTasks)}` : ""}.`,
+                : `${args.rerun ? `Rerun from ${args.rerun.sourceRunId}: ` : ""}Computer-use fan-out (${specs.length} participants, one world each): ${passedParticipants}/${specs.length} participant(s) reached a terminal, engaged verdict${participants ? `: ${formatParticipantOutcomes(participants, participantEndings)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
         gaps: args.inProgress === true
             ? ["Live fan-out session is still running."]
             : args.dryRun
@@ -93,7 +93,7 @@ function fanoutReview(args, streams) {
     }, streams);
     return review;
 }
-/** The configured browser and, when every lane resolved the same one, that browser. */
+/** The configured browser and, when every participant resolved the same one, that browser. */
 function fanoutDesktopBrowser(args) {
     const { outcomes, plan } = args;
     const configuredBrowser = plan.residual.execution?.desktop?.browser;
@@ -112,9 +112,9 @@ function fanoutDesktopBrowser(args) {
 }
 function fanoutCost(args) {
     const { specs, outcomes } = args;
-    // Run-level cost ESTIMATE: one model-token line per lane that ran a session (from its persisted
+    // Run-level cost ESTIMATE: one model-token line per participant that ran a session (from its persisted
     // trace.estimatedCost) + a desktop line per owned allocation, priced at its observed resources.
-    // Per-lane worlds have no shared provisioning to double-count. Omitted on a pure dry-run.
+    // `per-lane-worlds` participants have no shared provisioning to double-count. Omitted on a pure dry-run.
     const costTraces = specs
         .map((spec, index) => ({ participantId: spec.planned.id, outcome: outcomes?.[index] }))
         .filter((entry) => entry.outcome?.session !== undefined)
@@ -135,7 +135,7 @@ function fanoutFeedbackCandidates(args) {
     return args.dryRun || args.inProgress === true
         ? []
         : participantFeedbackCandidates({
-            runId: args.runId,
+            runId: args.run.runId,
             scenarioId: `cua-${plan.labId}`,
             adapterId: plan.labId,
             goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
@@ -159,10 +159,10 @@ function fanoutFeedbackCandidates(args) {
         });
 }
 /**
- * Project N>1 fan-out lanes into a humanish.run-bundle.v1 (the evidence schema is unchanged; this
- * is a new producer for the multi-stream shape). One sim + one stream per lane; per-lane
+ * Project N>1 fan-out participants into a humanish.run-bundle.v1 (the evidence schema is unchanged; this
+ * is a new producer for the multi-stream shape). One sim + one stream per participant; per-participant
  * provenance/session events; a recorded `cua-lab.fanout.plan` event (and a `cua-lab.fanout.fail-fast`
- * event when a harness error skipped queued lanes). N-ary verify/Observer already handle multiple
+ * event when a harness error skipped queued participants). N-ary verify/Observer already handle multiple
  * streams. A single-participant run without a rerun never reaches here: buildCuaRunBundle
  * (bundle.ts) sends it to buildSingleParticipantBundle (single-bundle.ts).
  */
@@ -176,7 +176,7 @@ export function buildCuaFanoutBundle(args) {
     if (args.rerun) {
         events.push({
             id: nextEventId("fanout-rerun"),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.fanout.rerun",
             message: `Rerun selected ${args.rerun.selectedLaneIds.length} participant(s) from ${args.rerun.sourceRunId}: ${args.rerun.previous.map((prior) => `${prior.laneId} was ${prior.status}${prior.completionReason ? `/${prior.completionReason}` : ""}`).join(", ")}. This is a new linked run; the source run verdict is unchanged.`,
@@ -191,7 +191,7 @@ export function buildCuaFanoutBundle(args) {
     if (args.failFastReason) {
         events.push({
             id: nextEventId("fanout-fail-fast"),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "warn",
             type: "cua-lab.fanout.fail-fast",
             message: `Fan-out fail-fast: ${args.failFastReason}. In-flight participants finished; queued participants were skipped (blocked); completed evidence is retained.`,
@@ -204,19 +204,15 @@ export function buildCuaFanoutBundle(args) {
     const desktopBrowser = fanoutDesktopBrowser(args);
     const providerResources = (outcomes ?? []).flatMap((outcome) => providerResourcesForOutcome({
         outcome,
-        createdAt: args.createdAt,
+        createdAt: args.run.createdAt,
         ids: outcome.spec,
         participantId: outcome.spec.planned.id,
     }));
     const cost = fanoutCost(args);
     return {
-        ...bundleHead({
+        ...bundleHead(args.run, {
             ...receivingPublication(args.plan.residual, args.dryRun),
-            runId: args.runId,
-            mode: args.dryRun ? "dry-run" : "live",
             participants: specs.length,
-            createdAt: args.createdAt,
-            ...(args.lab === undefined ? {} : { lab: args.lab }),
             source: args.source,
         }),
         persona: {
@@ -228,9 +224,9 @@ export function buildCuaFanoutBundle(args) {
         scenario: {
             id: `cua-${plan.labId}`,
             title: plan.title ?? `Computer-use fan-out: ${plan.labId}`,
-            // Redacted at WRITE time, like every other raw-text surface in the bundle. Lane records are
-            // digest-only by design, but scenario.goal keeps one lane's composed instructions verbatim —
-            // and an adopter whose authored lane text must name a runtime world URL (an inbox on a route
+            // Redacted at WRITE time, like every other raw-text surface in the bundle. Participant records are
+            // digest-only by design, but scenario.goal keeps one participant's composed instructions verbatim —
+            // and an adopter whose authored participant text must name a runtime world URL (an inbox on a route
             // where the harness does not inject one) put an *.e2b.app address in it. That landed raw here
             // and in observer-data.json, the sensitive-text scanner matched it, and verify failed a bundle
             // this writer produced. The only adopter-side workaround was scanner evasion (#412).
@@ -242,7 +238,7 @@ export function buildCuaFanoutBundle(args) {
         },
         lifecycle: [
             {
-                at: args.createdAt,
+                at: args.run.createdAt,
                 event: "cua-lab.run.created",
                 message: `Created computer-use fan-out run with ${specs.length} participants, each in its own desktop browser (actor ${args.descriptor.id}).`,
             },