humanish 0.106.0 → 0.107.0

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}).`,
             },

package/dist/routes/computer-use/{fanout-lanes.js → fanout-records.js}

@@ -4,6 +4,10 @@ import { participantAssignment } from "../../lab/participant-assignment.js";
 import { participantEvent, participantRecord, participantStream, } from "../../run/participant-records.js";
 import { declaredScreenForRender } from "../../substrates/e2b/desktop-geometry.js";
 import { describeSubjectState, phaseEventIdSuffix, publicSafeAppUrlLabel } from "./bundle-parts.js";
+import { judgedStatus } from "../../run/judge.js";
+import { participantFactsOf } from "./participant-facts.js";
+import { participantSubjectEnv } from "./types.js";
+const describeEnvNames = (names) => names.length > 0 ? names.join(", ") : "none";
 function fanoutParticipantView(args, spec, index) {
     const { outcomes, plan } = args;
     const outcome = outcomes?.[index];
@@ -77,14 +81,15 @@ function fanoutParticipantRecord(args, spec, index, view) {
                     : outcome?.sessionError !== undefined
                         ? `Participant ${spec.planned.id} failed before a terminal session verdict: ${outcome.sessionError}`
                         : `Contract participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}.`,
-        startedAt: args.createdAt,
-        updatedAt: args.createdAt,
+        startedAt: args.run.createdAt,
+        updatedAt: args.run.createdAt,
     });
 }
 function fanoutParticipantStream(args, spec, view) {
     const { plan } = args;
     const { outcome, publicTargetUrl, session, desktopGeometry, screenshots } = view;
     const { lastScreenshot, status, reason, screenshotMode } = view;
+    const judged = outcome === undefined ? undefined : judgedStatus(participantFactsOf(outcome));
     return participantStream(spec, {
         ...(spec.evidenceAssignment === undefined
             ? {}
@@ -101,8 +106,9 @@ function fanoutParticipantStream(args, spec, view) {
         kind: "browser",
         label: `CUA participant ${spec.planned.id}: ${plan.labId}`,
         status,
+        ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
-        updatedAt: args.createdAt,
+        updatedAt: args.run.createdAt,
         embed: lastScreenshot
             ? {
                 kind: "screenshot",
@@ -174,11 +180,11 @@ function fanoutSubjectEvents(ctx, spec, view) {
     const { publicTargetUrl, subject, session } = view;
     const events = [];
     const record = (event) => events.push(participantEvent(spec, event));
-    // Per-lane subject provenance (invariant 5).
-    if (args.cloneRoute && args.publicRepo) {
+    // Per-participant subject provenance (invariant 5).
+    if (args.plan.runner.subject.kind === "clone" && args.publicRepo) {
         record({
             id: nextEventId(`subject-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
@@ -187,13 +193,13 @@ function fanoutSubjectEvents(ctx, spec, view) {
                     ? session
                         ? `subject cloned from ${args.publicRepo}@${subject.commit} and served at ${publicTargetUrl} in-sandbox`
                         : `subject cloned from ${args.publicRepo}@${subject.commit}; serving did not complete (see session error)`
-                    : `subject clone attempted from ${args.publicRepo}; commit unresolved`} (subject env names: ${args.subjectEnvNames.length > 0 ? args.subjectEnvNames.join(", ") : "none"}; values never persisted); state: ${describeSubjectState(subject.state, args.dryRun)}.`,
+                    : `subject clone attempted from ${args.publicRepo}; commit unresolved`} (subject env names: ${describeEnvNames(participantSubjectEnv(args.plan.runner.subject))}; values never persisted); state: ${describeSubjectState(subject.state, args.dryRun)}.`,
         });
     }
     else if (subject.source === "local-tree") {
         record({
             id: nextEventId(`subject-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
@@ -202,13 +208,13 @@ function fanoutSubjectEvents(ctx, spec, view) {
                     ? session
                         ? `subject packed (archiveSha256 ${subject.archiveSha256}${subject.dirty === true ? ", dirty working tree" : subject.dirty === false ? ", clean working tree" : ""}) and served at ${publicTargetUrl} in-sandbox`
                         : `subject packed (archiveSha256 ${subject.archiveSha256}); serving did not complete (see session error)`
-                    : "subject local-tree packing attempted; archive digest unresolved"} (subject env names: ${args.subjectEnvNames.length > 0 ? args.subjectEnvNames.join(", ") : "none"}; values never persisted); state: ${describeSubjectState(subject.state, args.dryRun)}.`,
+                    : "subject local-tree packing attempted; archive digest unresolved"} (subject env names: ${describeEnvNames(participantSubjectEnv(args.plan.runner.subject))}; values never persisted); state: ${describeSubjectState(subject.state, args.dryRun)}.`,
         });
     }
     else {
         record({
             id: nextEventId(`subject-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.subject.declared",
             message: `Participant ${spec.planned.id}: subject app declared at ${publicTargetUrl} (loopback inside the participant's own desktop sandbox).`,
@@ -221,11 +227,11 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     const { outcome, session, desktopGeometry } = view;
     const events = [];
     const record = (event) => events.push(participantEvent(spec, event));
-    // Per-lane session event.
+    // Per-participant session event.
     if (session) {
         record({
             id: nextEventId(`session-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: session.status === "passed" ? "info" : "warn",
             type: `cua-lab.session.${session.completionReason}`,
             message: `Participant ${spec.planned.id} ${session.status}: ${session.reason}`,
@@ -234,7 +240,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     else if (args.inProgress === true && outcome === undefined) {
         record({
             id: nextEventId(`running-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.session.running",
             message: `Participant ${spec.planned.id}: live computer-use session is running; terminal evidence has not been written yet.`,
@@ -243,7 +249,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     else if (outcome?.skippedReason !== undefined) {
         record({
             id: nextEventId(`blocked-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "warn",
             type: "cua-lab.session.blocked",
             message: `Participant ${spec.planned.id} ${outcome.skippedReason}.`,
@@ -252,7 +258,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     else if (outcome?.sessionError !== undefined) {
         record({
             id: nextEventId(`session-error-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "error",
             type: "cua-lab.session.error",
             message: `Participant ${spec.planned.id}: ${outcome.sessionError}`,
@@ -261,7 +267,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     else {
         record({
             id: nextEventId(`contract-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.contract.ready",
             message: `Participant ${spec.planned.id}: dry-run contract participant ready; switch scenario.mode to live for a real desktop session.`,
@@ -270,14 +276,14 @@ function fanoutOutcomeEvents(ctx, spec, view) {
     for (const warning of desktopGeometry.warnings ?? []) {
         record({
             id: nextEventId(`geometry-warning-${spec.planned.id}`),
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "warn",
             type: "cua-lab.geometry.warning",
             message: warning,
         });
     }
-    // Persisted per-lane phase trail (real boot timing): one RunEvent per COMPLETED phase
-    // boundary this lane recorded (started events never persist here; they carry no durationMs).
+    // Persisted per-participant phase trail (real boot timing): one RunEvent per COMPLETED phase
+    // boundary this participant recorded (started events never persist here; they carry no durationMs).
     for (const phase of outcome?.phaseRecords ?? []) {
         record({
             id: nextEventId(`phase-${spec.planned.id}-${phaseEventIdSuffix(phase.type)}`),

package/dist/routes/computer-use/in-process-desktop.d.ts

@@ -1,14 +1,7 @@
-import type { CuaActorDescriptor } from "../../actors/registry.js";
-import type { LabConfig } from "../../lab/types.js";
 import type { ParticipantDesktop } from "./participant-desktop.js";
-import type { CuaActorLabHooks } from "./types.js";
-/** What an in-process desktop reads: the caller's executor hook and the arguments it receives. */
-interface InProcessDesktopDeps {
-    config: LabConfig;
-    descriptor: CuaActorDescriptor;
-    appUrl: string;
-    hooks: Pick<CuaActorLabHooks, "buildExecutor">;
-}
+import type { CuaParticipantDeps } from "./types.js";
+/** What an in-process desktop reads: the caller's executor and the app it drives. */
+type InProcessDesktopDeps = Pick<CuaParticipantDeps, "appUrl" | "inProcessExecutor">;
 /**
  * The caller's executor as a participant desktop. prepare acquires nothing; openSession builds the
  * executor once; finalize is idempotent and has nothing to release; snapshot records no sandbox.

package/dist/routes/computer-use/in-process-desktop.js

@@ -19,15 +19,9 @@ export function createInProcessDesktop(deps) {
             if (!preparationStarted || opened || finalization)
                 throw new Error("The participant desktop must be prepared and may only be opened once, before finalization.");
             opened = true;
-            const buildExecutor = deps.hooks.buildExecutor;
-            if (buildExecutor === undefined)
-                throw new Error("The in-process route needs hooks.buildExecutor.");
-            const executor = await buildExecutor({
-                config: deps.config,
-                actor: deps.descriptor,
-                appUrl: deps.appUrl,
-            });
-            return { executor };
+            if (deps.inProcessExecutor === undefined)
+                throw new Error("The in-process route needs RunLabOptions.inProcess.");
+            return { executor: await deps.inProcessExecutor(deps.appUrl) };
         },
         finalize() {
             return (finalization ??= Promise.resolve());

package/dist/routes/computer-use/live-flush.d.ts

@@ -2,7 +2,8 @@ import type { ActorTokenUsage, ActorTraceItem } from "../../actors/contract.js";
 import type { CuaLiveMetadata } from "../../actors/computer-use/loop.js";
 import { type ObserverResult } from "../../observer/render.js";
 import type { RunBundle } from "../../run/bundle.js";
-import type { CuaActorLabHooks, DesktopParticipantRun } from "./types.js";
+import type { RunLabHomes } from "../../lab/run-lab-homes.js";
+import type { DesktopParticipantRun } from "./types.js";
 export interface LiveTraceFlush {
     /** Record a participant's recorded-so-far items; the bundle rewrite follows on the flush
      *  schedule. */
@@ -11,7 +12,7 @@ export interface LiveTraceFlush {
     stop: () => Promise<void>;
 }
 /**
- * Incremental live flush (#441): as each lane's loop reports its recorded-so-far items,
+ * Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses
@@ -27,12 +28,13 @@ export declare function startLiveTraceFlush(args: {
     write: (bundle: RunBundle) => Promise<void>;
 }): LiveTraceFlush;
 /**
- * The live desktop views (runtime stream URLs) lanes report, attached to whichever Observer shows
+ * The live desktop views (runtime stream URLs) participants report, attached to whichever Observer shows
  * the run. The URLs carry auth, so they live in memory and on the Observer result, never in run
  * artifacts.
  */
-export declare function trackRuntimeStreams(hooks: CuaActorLabHooks): {
-    hooks: CuaActorLabHooks;
+export declare function trackRuntimeStreams(onStream: RunLabHomes["onStream"] | undefined): {
+    /** Records each stream for the Observer, after the caller's onStream. */
+    onStream: NonNullable<RunLabHomes["onStream"]>;
     /** From now on, keep this live Observer's stream list current. */
     showIn: (observer: ObserverResult & {
         ok: true;

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

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

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

@@ -1,23 +1,24 @@
 // The computer-use run's live phase: the in-progress bundle and its live-trace flush, email
-// receiving, the lanes themselves, and the drain of an operator-hosted inbox.
+// receiving, the participants themselves, and the drain of an operator-hosted inbox.
 import { prepareReceivingRun } from "../../comms/receiving-runtime.js";
 import { liveObserverResult } from "../../observer/live.js";
-import { DEFAULT_OPENAI_CU_MODEL } from "../../actors/computer-use/openai-provider.js";
-import { runAllCuaParticipants } from "./lanes.js";
+import { pricedModel } from "../../lab/plan-base.js";
+import { runAllCuaParticipants } from "./participant-execution.js";
 import { startLiveTraceFlush } from "./live-flush.js";
 import { drainExternalComms } from "./external-comms.js";
 import { buildCuaRunBundle, judgeComputerUseRun } from "./bundle.js";
-import {} from "./types.js";
+import { participantSubjectEnv } from "./types.js";
 /**
  * Runs the participants (a dry run runs none). Returns the refusal when real email setup fails, or
  * the participant outcomes and the warnings the finish records.
  */
 export async function runLabParticipants(setup, participants) {
-    const { plan, input, config, cwd, streams, descriptor, subjectRoute, run } = setup;
-    const { participantRuns, participantPlan, scrubKnownValues, bundleBase } = setup;
+    const { plan, input, cwd, streams, descriptor, run } = setup;
+    const { participantRuns, participantPlan, bundleBase } = setup;
     const { env, knownSecretValues, deps, liveTrace, externalComms, inProgress, fail } = participants;
     const { dryRun } = plan;
-    const { inProcessRoute, subjectEnvNames } = subjectRoute;
+    const inProcess = plan.runner.desktop === "in-process";
+    const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId, paths: runPaths } = run;
     // A live run writes what it is doing AS IT DOES IT, whether or not anyone is currently watching.
     // This used to be gated on `options.onObserverReady` — the interactive Observer callback — so a
@@ -46,14 +47,14 @@ export async function runLabParticipants(setup, participants) {
         streams.showIn(liveObserver);
         if (input.onObserverReady)
             await input.onObserverReady(liveObserver);
-        // Incremental live flush (#441): as each lane's loop reports its recorded-so-far items,
+        // Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
         // rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
         // Observer's 5s poll sees the timeline grow. The run refuses any snapshot once the final
         // write began; the route stops the flush timer on every exit below.
         const liveFlush = startLiveTraceFlush({
             bundle: inProgressBundle,
             participantRuns: participantRuns,
-            model: config.actors[0]?.model ?? DEFAULT_OPENAI_CU_MODEL,
+            model: pricedModel(plan.runner.brain),
             write: (bundle) => run.writeSnapshot(bundle),
         });
         liveTrace.flush = liveFlush.flush;
@@ -96,12 +97,12 @@ export async function runLabParticipants(setup, participants) {
             };
         }
     }
-    // Run lanes (dry-run runs none). In-process is always one lane.
+    // Run the participants (dry-run runs none). In-process is always one.
     let outcomes;
     let failFastReason;
     try {
         if (!dryRun)
-            ({ outcomes, failFastReason } = await runAllCuaParticipants(participantRuns, deps, participantPlan, inProcessRoute));
+            ({ outcomes, failFastReason } = await runAllCuaParticipants(participantRuns, deps, participantPlan, inProcess));
     }
     finally {
         try {
@@ -110,7 +111,7 @@ export async function runLabParticipants(setup, participants) {
         catch {
             receivingWarnings.push("Email finalization could not complete. Inspect humanish comms recover; provider cleanup remains unresolved.");
         }
-        // Stop the flush timer on every exit, including a throw from the lanes.
+        // Stop the flush timer on every exit, including a throw from the participants.
         await liveTrace.stop?.();
     }
     const externalCommsWarnings = !dryRun && externalComms && outcomes !== undefined
@@ -121,7 +122,7 @@ export async function runLabParticipants(setup, participants) {
             runPaths,
             participantRuns: participantRuns,
             outcomes,
-            scrubKnownValues,
+            knownSecretValues,
         })
         : [];
     return {

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

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

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

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