humanish 0.106.0 → 0.107.0

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

@@ -26,10 +26,11 @@ import path from "node:path";
 import { completeAutomaticAnalysis } from "../../analysis/automatic-completion.js";
 import { runScope } from "../../run/run.js";
 import { resolveAutomaticAnalysis } from "../../analysis/automatic-config.js";
-import { computerUseInputWithScorer } from "../../lab/route-inputs.js";
-import { planComputerUseLab } from "./plan.js";
+import { browserRouteScorer } from "../../lab/adapter-scorer-loader.js";
+import { withLateScorer } from "../../lab/route-inputs.js";
+import { callerDrivingOf, planComputerUseLab } from "./plan.js";
 import { finishCuaRun } from "./result.js";
-import { runLabParticipants } from "./run-lanes.js";
+import { runLabParticipants } from "./live-phase.js";
 import { admitCuaRun, refuseCuaLab, startCuaRun } from "./setup.js";
 import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
 /**
@@ -38,12 +39,12 @@ import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
  * run and its analysis.
  */
 export async function runCuaActorLab(options) {
-    const { config, dryRun, lab, ...input } = options;
+    const { config, dryRun, ...input } = options;
     // planComputerUseLab makes every configuration refusal, in the order this route always has.
     const planned = planComputerUseLab(config, {
         dryRun,
-        ...(lab === undefined ? {} : { lab }),
-        ...(input.hooks === undefined ? {} : { hooks: input.hooks }),
+        hasRunSession: input.deps?.runSession !== undefined,
+        driving: callerDrivingOf(input),
         ...(input.countOverride === undefined ? {} : { countOverride: input.countOverride }),
         ...(input.rerun === undefined ? {} : { rerun: input.rerun }),
     });
@@ -53,7 +54,7 @@ export async function runCuaActorLab(options) {
 }
 /**
  * A refused computer-use lab's result, at the refusal's stage: a before-scope refusal has its own
- * envelope and no analysis record; the others come after the cwd checks, and the lane cap after
+ * envelope and no analysis record; the others come after the cwd checks, and the participant cap after
  * the personas are read.
  */
 export async function computerUseLabRefusal(options, refusal) {
@@ -72,9 +73,9 @@ export async function computerUseLabRefusal(options, refusal) {
             warnings: [],
             error: { code: refusal.code, message: refusal.message },
         };
-    // The other refusals come after the cwd checks, and the lane cap after the personas are read.
+    // The other refusals come after the cwd checks, and the participant cap after the personas are read.
     const analysis = resolveAutomaticAnalysis(config.review?.analysis);
-    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options.automaticAnalysis, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
+    return completeAutomaticAnalysis(await refuseCuaLab(options, refusal), undefined, analysis.ok ? analysis.config : undefined, options, { trigger: config.review?.analysis === undefined ? "default" : "explicit" });
 }
 /**
  * runLab's step for a computer-use plan. It runs the plan's local checks (admitCuaRun: the
@@ -92,24 +93,22 @@ export async function admitComputerUsePlan(plan, input, config) {
     return {
         ok: true,
         run: async (scorer) => {
-            const running = computerUseInputWithScorer(input, scorer);
-            // The scorer's hooks wrap the admitted bag, so the runSession, provider and desktop the
-            // checks admitted stay the ones the run uses.
-            const admitted = { ...admission.admitted, hooks: running.hooks ?? admission.admitted.hooks };
-            return cuaOutcome(await runAdmittedCuaRun(plan, running, admitted));
+            // The scorer joins the input only; the runSession, provider and desktop the checks admitted
+            // stay the ones the run uses.
+            const running = withLateScorer(input, scorer, browserRouteScorer);
+            return cuaOutcome(await runAdmittedCuaRun(plan, running, admission.admitted));
         },
     };
 }
 function cuaOutcome(result) {
-    return { route: "computer-use", backend: "cua", result };
+    return { route: "computer-use", result };
 }
 /**
  * Run a computer-use plan: its local checks, then the run. The run scope in runAdmittedCuaRun
  * finalizes any status record the run opened, on every exit, so a test or library caller does not
  * leave the 5 s status cadence writing into a directory something else is deleting (an unrelated
- * ENOTEMPTY). Participants come from the plan. `config` is still read for values the plan does not
- * carry yet (the actor's model and local agent, persona ids, comms settings, the per-participant
- * cap) and by the compatibility hooks, which take the whole config.
+ * ENOTEMPTY). Participants, the brain, the subject, the caps and the residual config come from the
+ * plan. `config` is what the caller's createProvider and inProcess executor receive.
  */
 export async function runComputerUsePlan(plan, input, config) {
     const admission = await admitCuaRun(plan, input, config);
@@ -129,9 +128,12 @@ function runAdmittedCuaRun(plan, input, admitted) {
     });
 }
 function completeCuaAnalysis(plan, input, result, finished) {
-    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input.automaticAnalysis, {
+    // A local VM study whose cleanup is unconfirmed records a skip instead of analyzing.
+    const refusal = input.localVm?.analysisRefusal;
+    return completeAutomaticAnalysis(result, finished, plan.analysis?.config, input, {
         ...(plan.analysis === undefined ? {} : { trigger: plan.analysis.trigger }),
         preferLargerOutput: plan.analysis?.preferLargerOutput === true,
+        ...(refusal === undefined ? {} : { refusal }),
     });
 }
 async function runPlanInScope(plan, input, admitted, scope) {

package/dist/routes/computer-use/self-report.d.ts

@@ -1,12 +1,12 @@
 import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
 import { type SessionEnding } from "../../run/judge.js";
 /**
- * A goal_satisfied lane counts as a self-reported blocker ONLY when its final narrative contradicts
+ * A goal_satisfied participant counts as a self-reported blocker ONLY when its final narrative contradicts
  * the goal AND the run's own stop predicate did NOT fire. A matched stopWhen is independent,
  * structured completion evidence, so it overrides a text scan of the free-form narrative — which can
  * otherwise trip on the subject app's OWN quoted copy (e.g. a relayed "cannot be undone" banner).
  * Resolved-arc segments never block the verdict (#453). Returns the offending reason, or undefined
- * when the lane is a clean pass. Exported for testing.
+ * when the participant is a clean pass. Exported for testing.
  */
 export declare function resolveSelfReportedBlocker(session: CuaLoopResult | undefined): string | undefined;
 /** A session's ending, reduced to what the judge's engagement and blocker rules read. */

package/dist/routes/computer-use/self-report.js

@@ -20,7 +20,7 @@ function hasBlockerLanguage(text) {
 // Report-shaped language: what a participant writes when it finished AND has something to say.
 // Every one of the day's eleven drawDB reports (2026-09-01) opened a section "What confused me"
 // or "Accessibility defects:"; none contained a blocker word, so none became a feedback candidate
-// and a lane that had just replicated a keyboard-accessibility defect three times drafted "Live
+// and a participant that had just replicated a keyboard-accessibility defect three times drafted "Live
 // study completed without a participant-reported finding". Friction is the INCLUSIVE scan; a
 // false positive here adds a candidate a person then reads, which is the cheap direction.
 const REPORTED_DEFECT_LANGUAGE = /\b(defects?|bugs?|accessibilit(y|ies)|inaccessible|not (keyboard|screen.?reader)[- ]?accessible|confus(ed|ing)|hesitat(ed|ion)|unexpected(ly)?|unclear|hard to (find|tell|see|read|reach)|no (visible )?focus|overlap(ped|ping|s)?|truncat(ed|es|ion)|cut off|did nothing|nothing happened|no effect)\b/;
@@ -94,7 +94,7 @@ function completionReasonBlocksVerdict(reason) {
 // with a parser error. A simpler SQL import succeeded."). The lookahead demands the retry flavor
 // on purpose: unrelated praise ("Separately, the search box worked") must never launder an
 // unresolved failure. "Login failed so I gave up" has no recovery anywhere and stays a blocker.
-// (#453 — the run-1 false negative: a defect report after demonstrated success failed the lane,
+// (#453 — the run-1 false negative: a defect report after demonstrated success failed the participant,
 // an incentive inversion against exactly the participant behavior a study wants most.)
 const RESOLUTION_TERMS = /\b(succeed(?:ed|s)?|success(?:ful|fully)?|worked|works around|then worked|now works?|resolved|fixed|recovered|got it working|went through)\b/;
 const RETRY_RESOLUTION = /\b(simpler|simplified|retry(?:ing)?|retried|second (?:attempt|try)|another (?:attempt|try|approach)|different (?:approach|way|route)|instead|then|eventually|after that)\b[^.!?\n]{0,80}\b(succeed(?:ed|s)?|success(?:ful|fully)?|worked|went through|completed|passed)\b/;
@@ -152,12 +152,12 @@ function traceHasStopWhenMatch(session) {
         (item.title.startsWith("stopWhen matched") || item.title === "dwell window complete"));
 }
 /**
- * A goal_satisfied lane counts as a self-reported blocker ONLY when its final narrative contradicts
+ * A goal_satisfied participant counts as a self-reported blocker ONLY when its final narrative contradicts
  * the goal AND the run's own stop predicate did NOT fire. A matched stopWhen is independent,
  * structured completion evidence, so it overrides a text scan of the free-form narrative — which can
  * otherwise trip on the subject app's OWN quoted copy (e.g. a relayed "cannot be undone" banner).
  * Resolved-arc segments never block the verdict (#453). Returns the offending reason, or undefined
- * when the lane is a clean pass. Exported for testing.
+ * when the participant is a clean pass. Exported for testing.
  */
 export function resolveSelfReportedBlocker(session) {
     return session !== undefined && selfReportedBlocker(blockerFacts(session))

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

@@ -1,18 +1,17 @@
 import { type RunScope } from "../../run/run.js";
-import { type LocalAgentId } from "../../actors/local-agent/cli.js";
 import type { CuaActorDescriptor } from "../../actors/registry.js";
 import type { LabCommsEmail, LabCommsExternal, LabConfig } from "../../lab/types.js";
 import { type RunRerunLineage } from "../../run/bundle.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
-import { type ComputerUseRefusal, type CuaSubjectRoute } from "./plan.js";
+import { type ComputerUseRefusal } from "./plan.js";
 import type { ComputerUsePlan } from "../../lab/plan-types.js";
 import { trackRuntimeStreams, type LiveTraceFlush } from "./live-flush.js";
 import { type CuaRunBundleBase } from "./bundle.js";
 import { projectParticipantSubjects } from "./subject-projection.js";
-import { type CuaActorLabErrorCode, type CuaActorLabHooks, type CuaActorLabResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorLabOptions } from "./types.js";
+import { type CuaActorLabErrorCode, type CuaActorLabResult, type CuaParticipantDeps, type CuaParticipantPlan, type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ComputerUseRunInput, type RunCuaActorLabOptions } from "./types.js";
 /**
- * The envelope of a refusal the plan left for after the cwd checks. The lane cap and in-process
- * fan-out refusals come after the committed personas are read, so a persona-file error still wins.
+ * The envelope of a refusal the plan left for after the cwd checks. The participant cap and
+ * in-process fan-out refusals come after the committed personas are read, so a persona-file error still wins.
  */
 export declare function refuseCuaLab(options: RunCuaActorLabOptions, refusal: ComputerUseRefusal): Promise<CuaActorLabResult>;
 export type AdmittedCuaRun = Extract<Awaited<ReturnType<typeof admitCuaRun>>, {
@@ -25,13 +24,9 @@ type StartedRun = Extract<Awaited<ReturnType<RunScope["startRun"]>>, {
 export interface CuaRunSetup {
     plan: ComputerUsePlan;
     input: ComputerUseRunInput;
-    /** Read for values the plan does not carry yet, and by the compatibility hooks, which take the
-     *  whole config. Participants come from the plan. */
-    config: LabConfig;
     /** The physical project root. */
     cwd: string;
     descriptor: CuaActorDescriptor;
-    subjectRoute: CuaSubjectRoute;
     run: StartedRun;
     streams: ReturnType<typeof trackRuntimeStreams>;
     participantRuns: DesktopParticipantRun[];
@@ -67,7 +62,6 @@ export interface CuaParticipantsSetup {
 }
 /** What only finishCuaRun reads besides the participants' outcomes. */
 export interface CuaFinishFacts {
-    hooks: CuaActorLabHooks;
     rerunLineage: RunRerunLineage | undefined;
     publicRepo: string | undefined;
     subjectArgs: Omit<Parameters<typeof projectParticipantSubjects>[0], "outcomes" | "dryRun">;
@@ -96,16 +90,16 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         config: LabConfig;
         dryRun: boolean;
         cwd: string;
-        hooks: CuaActorLabHooks;
+        seams: import("../../lab/lab-deps.js").LabDeps;
         streams: {
-            hooks: CuaActorLabHooks;
+            onStream: NonNullable<import("../../lab/run-lab-homes.js").RunLabHomes["onStream"]>;
             showIn: (observer: import("../../index.js").ObserverResult & {
                 ok: true;
             }) => void;
             attachFinal: (observer: import("../../index.js").ObserverResult) => void;
         };
-        env: NodeJS.ProcessEnv;
-        subjectRoute: CuaSubjectRoute;
+        env: Record<string, string | undefined>;
+        appUrl: string;
         fail: (code: CuaActorLabErrorCode, message: string, actorLabel?: string) => CuaActorLabResult;
         refuse: (code: CuaActorLabErrorCode, message: string, actorLabel?: string | undefined) => {
             ok: false;
@@ -124,9 +118,6 @@ export declare function admitCuaRun(plan: ComputerUsePlan, input: ComputerUseRun
         knownSecretValues: string[];
         scrubKnownValues: (text: string) => string;
         publicRepo: string | undefined;
-        hasGithubToken: boolean;
-        localAgentRoute: boolean;
-        preferredLocalAgent: LocalAgentId;
         localTreeArchive: LocalTreeArchive | undefined;
         localTreeArchiveBuffer: ArrayBuffer | undefined;
     };

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

@@ -1,12 +1,11 @@
-// The computer-use run's setup: resolve the project and route, plan the lanes, make the live
-// checks that need no sandbox, pack a local tree, then start the run and build the lane deps and
-// bundle base that the lanes and the finish share.
+// The computer-use run's setup: resolve the project and route, plan the participants, make the
+// live checks that need no sandbox, pack a local tree, then start the run and build the
+// participant deps and bundle base that the participants and the finish share.
 import { randomBytes } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import path from "node:path";
 import {} from "../../run/run.js";
 import { externalInboxUrl } from "../../comms/sandbox-catch.js";
-import {} from "../../actors/local-agent/cli.js";
 import { redactText, scrubLiterals, toErrorMessage } from "../../evidence/redaction.js";
 import { buildRunSource } from "../../run/bundle.js";
 import { assertPreparedSelectedOutputDirectory, prepareContainedOutputDirectory, prepareSelectedOutputDirectory, } from "../../run/contained-output.js";
@@ -16,14 +15,15 @@ import { emitPreflightPlan, compileParticipantPersonas, loadCuaParticipants, san
 import { makeCuaRunBudget } from "./participant-model.js";
 import { e2bRequestTimeoutMs } from "../../substrates/e2b/lifetime.js";
 import { liveCuaRejection } from "./preflight.js";
-import { cuaDescriptorOf, cuaSubjectRoute, cuaSubjectRouteOf, } from "./plan.js";
+import { cuaDescriptorOf, declaredAppUrl, plannedAppUrl } from "./plan.js";
 import { trackRuntimeStreams } from "./live-flush.js";
+import { participantOf, phaseEvent, planEvent } from "../../lab/run-lab-events.js";
+import { defaultSubjectPhaseSink } from "../../subject/steps.js";
 import {} from "./bundle.js";
 import { packRunLocalTree } from "./local-tree-pack.js";
 import { projectParticipantSubjects, subjectProvenanceArg } from "./subject-projection.js";
-import { CUA_ACTOR_LAB_SCHEMA, } from "./types.js";
+import { CUA_ACTOR_LAB_SCHEMA, participantSubjectEnv, } from "./types.js";
 import { labPersonaIds } from "../../lab/persona-resolve.js";
-import { participantDesktopOf } from "./participant-desktop.js";
 /** The physical project, bound before any caller hook runs. */
 async function bindProject(cwd) {
     // Capture the physical project before reading or invoking any caller hook. A supported
@@ -33,13 +33,12 @@ async function bindProject(cwd) {
     return prepareSelectedOutputDirectory(path.dirname(physicalCwd), physicalCwd);
 }
 /**
- * The envelope of a refusal the plan left for after the cwd checks. The lane cap and in-process
- * fan-out refusals come after the committed personas are read, so a persona-file error still wins.
+ * The envelope of a refusal the plan left for after the cwd checks. The participant cap and
+ * in-process fan-out refusals come after the committed personas are read, so a persona-file error still wins.
  */
 export async function refuseCuaLab(options, refusal) {
     const { config, dryRun } = options;
     const projectRoot = await bindProject(options.cwd);
-    const hooks = options.hooks ?? {};
     // The committed personas are read before the refusal returns, so a persona-file error wins.
     if (refusal.stage === "after-personas")
         await compileParticipantPersonas(projectRoot, labPersonaIds(config));
@@ -49,7 +48,7 @@ export async function refuseCuaLab(options, refusal) {
         cwd: projectRoot.physicalPath,
         labId: config.id,
         actor: refusal.actor ?? config.actors[0]?.type ?? "",
-        appUrl: cuaSubjectRoute(config, hooks).appUrl,
+        appUrl: declaredAppUrl(config),
         dryRun,
         runId: options.runId ?? "not-created",
         lanes: [],
@@ -67,11 +66,13 @@ export async function admitCuaRun(plan, input, config) {
     const { dryRun } = plan;
     const projectRoot = await bindProject(input.cwd);
     const cwd = projectRoot.physicalPath;
-    const hooks = input.hooks ?? {};
-    const streams = trackRuntimeStreams(hooks);
-    const env = hooks.env ?? process.env;
-    const subjectRoute = cuaSubjectRouteOf(plan);
-    const { cloneRoute, localTreeRoute, inProcessRoute, appUrl, subjectRepo, subjectEnvNames } = subjectRoute;
+    const seams = input.deps ?? {};
+    const streams = trackRuntimeStreams(input.onStream);
+    const env = input.env ?? process.env;
+    const { subject, desktop } = plan.runner;
+    const inProcess = desktop === "in-process";
+    const appUrl = plannedAppUrl(subject);
+    const subjectEnvNames = [...participantSubjectEnv(subject)];
     const fail = (code, message, actorLabel) => ({
         schema: CUA_ACTOR_LAB_SCHEMA,
         ok: false,
@@ -89,15 +90,29 @@ export async function admitCuaRun(plan, input, config) {
         ok: false,
         result: fail(...args),
     });
+    // runLab's local VM study supplies a local-target app-url lab's desktop; a direct route call or
+    // an in-process executor on the same lab has none. It reads the declared source, as the planner
+    // did: a library config the parser never saw can plan to an app-url subject from another source.
+    if (config.subject.source === "app-url" &&
+        config.execution?.target === "local" &&
+        input.localVm === undefined)
+        return refuse("HUMANISH_CUA_LAB_LOCAL_DESKTOP_MISSING", "An app-url lab with execution.target: local needs a local desktop. runLab starts one; a direct route call or an in-process executor does not.");
     const descriptor = cuaDescriptorOf(plan.actor);
-    const runSession = hooks.runSession ?? descriptor.runSession;
+    const baseRunSession = seams.runSession ?? descriptor.runSession;
+    // A local VM study's sessions abort on its signal.
+    const localVmSignal = input.localVm?.signal;
+    const runSession = localVmSignal === undefined
+        ? baseRunSession
+        : (options) => baseRunSession({ ...options, signal: localVmSignal });
     // Adopter-hosted comms plane on the app-url route (#380): humanish provisions no subject here,
     // so it cannot host a catch — the OPERATOR runs one, and humanish still does every other part
     // of the funnel: tells each persona its address and inbox URL, drains the catch over HTTP after
-    // the lanes, and writes the same digest-only evidence. Declaring `external` previously did
+    // the participants, and writes the same digest-only evidence. Declaring `external` previously did
     // nothing on this route (and, per #387, on every other) while its docs said otherwise.
     const comms = plan.residual.comms;
-    const externalCommsConfig = !cloneRoute && !localTreeRoute && !inProcessRoute ? comms?.email?.external : undefined;
+    const externalCommsConfig = subject.kind !== "clone" && subject.kind !== "local-tree" && !inProcess
+        ? comms?.email?.external
+        : undefined;
     const externalCommsEmail = externalCommsConfig ? comms?.email : undefined;
     const participants = await loadCuaParticipants({ plan, cwd, projectRoot, env });
     if (!participants.ok) {
@@ -105,13 +120,13 @@ export async function admitCuaRun(plan, input, config) {
     }
     const { participantRuns, participantPlan, rerunLineage } = participants;
     const participantCount = participantRuns.length;
-    // Pre-flight plan: BEFORE any sandbox or provider call (dry-run AND live). The hook fires for
-    // every N (observable + testable); the stderr table prints for fan-out (N>1) so single-lane
-    // runs stay as quiet as they always were.
+    // Pre-flight plan: BEFORE any sandbox or provider call (dry-run AND live). onEvent gets it for
+    // every N; the stderr table prints for fan-out (N>1) so single-participant runs stay as quiet as they
+    // always were.
     if (participantCount > 1) {
         emitPreflightPlan(participantPlan, plan.labId);
     }
-    hooks.onPreflight?.(participantPlan);
+    input.emit?.(planEvent(participantPlan));
     await assertPreparedSelectedOutputDirectory(projectRoot);
     // Read keys once into locals (names only; values never logged or persisted).
     const openaiApiKey = env.OPENAI_API_KEY?.trim() ?? "";
@@ -125,43 +140,30 @@ export async function admitCuaRun(plan, input, config) {
     const scrubKnownValues = scrubLiterals(knownSecretValues);
     sanitizeParticipantRuns(participantRuns, scrubKnownValues);
     const redactRepoLabel = plan.residual.policies?.redactRepos ?? subjectEnvNames.includes("GITHUB_TOKEN");
-    const publicRepo = cloneRoute && subjectRepo ? (redactRepoLabel ? "repo-01" : subjectRepo) : undefined;
-    const hasGithubToken = subjectEnvNames.includes("GITHUB_TOKEN");
-    // The operator's own signed-in coding agent is the brain, so there is no provider key to ask
-    // for — the entire point of the actor. E2B is still required: the persona needs a machine.
-    const localAgentRoute = descriptor.id === "local-agent";
-    // Which local CLI, from its OWN field: `model` means the model, so that "Claude Code running
-    // Opus" is sayable. Preflight below refuses when the chosen one is missing or signed out — that
-    // news is worthless after a sandbox is paid for.
-    const preferredLocalAgent = config.actors[0]?.localAgent ?? "codex";
+    const publicRepo = subject.kind === "clone" ? (redactRepoLabel ? "repo-01" : subject.repo) : undefined;
     // Key-gating is route-aware: the in-process route uses the caller's OWN model + executor, and
     // the local-agent route uses a CLI the operator has already signed in to.
-    if (!dryRun && !inProcessRoute) {
+    if (!dryRun && !inProcess) {
         const rejection = await liveCuaRejection({
             caps: plan.caps,
-            model: config.actors[0]?.model,
-            hooks,
+            brain: plan.runner.brain,
             env,
-            openaiApiKey,
-            e2bApiKey,
-            localAgentRoute,
-            preferredLocalAgent,
-            subjectEnvNames,
+            requirements: plan.requirements,
             externalCommsConfig,
         });
         if (rejection)
             return refuse(rejection.code, rejection.message, descriptor.id);
     }
     // Pack the working tree ONCE per run, on the host, BEFORE any sandbox or provider call: every
-    // fan-out lane below uploads this SAME archive, so one archiveSha256 describes every lane's
-    // digest. Dry-run packs nothing (no fs side effects; the contract bundle carries no
+    // fan-out participant below uploads this SAME archive, so one archiveSha256 describes every
+    // participant's digest. Dry-run packs nothing (no fs side effects; the contract bundle carries no
     // archiveSha256). A packing failure fails the run closed here, before any sandbox is
     // created and before the run directory exists.
     let localTreeArchive;
     let localTreeArchiveBuffer;
-    if (localTreeRoute && !dryRun) {
+    if (subject.kind === "local-tree" && !dryRun) {
         try {
-            const packed = await packRunLocalTree(hooks, plan.residual, cwd);
+            const packed = await packRunLocalTree(seams, plan.residual, cwd);
             localTreeArchive = packed.archive;
             localTreeArchiveBuffer = packed.buffer;
         }
@@ -175,10 +177,10 @@ export async function admitCuaRun(plan, input, config) {
             config,
             dryRun,
             cwd,
-            hooks,
+            seams,
             streams,
             env,
-            subjectRoute,
+            appUrl,
             fail,
             refuse,
             descriptor,
@@ -194,9 +196,6 @@ export async function admitCuaRun(plan, input, config) {
             knownSecretValues,
             scrubKnownValues,
             publicRepo,
-            hasGithubToken,
-            localAgentRoute,
-            preferredLocalAgent,
             localTreeArchive,
             localTreeArchiveBuffer,
         },
@@ -204,8 +203,8 @@ export async function admitCuaRun(plan, input, config) {
 }
 /** Starts the run and builds what the participants and the finish read: the deps and the bundle base. */
 export async function startCuaRun(plan, input, admitted, scope) {
-    const { config, dryRun, cwd, hooks, descriptor, participantRuns, participantPlan, publicRepo } = admitted;
-    const { appUrl, inProcessRoute, localAppSubject, cloneRoute, localTreeRoute, subjectEnvNames } = admitted.subjectRoute;
+    const { dryRun, cwd, seams, descriptor, participantRuns, participantPlan, publicRepo } = admitted;
+    const { appUrl } = admitted;
     // The run's status record exists from here on, so anything watching the runs directory can
     // tell which lab this is and that it is alive. The fail-closed returns below leave it finished
     // with no outcome when the scope closes; a crash leaves it stale, which reads as interrupted.
@@ -216,12 +215,12 @@ export async function startCuaRun(plan, input, admitted, scope) {
         mode: dryRun ? "dry-run" : "live",
         lab: plan.lab,
         renderReview: renderCuaReviewMarkdown,
-        observer: { open: input.open === true, render: hooks.renderObserverFn },
+        observer: { open: input.open === true, render: seams.renderObserver },
     });
     if (!started.ok)
         return admitted.refuse(started.code, started.message, descriptor.id);
     const { run } = started;
-    const { runId, createdAt, paths: runPaths } = run;
+    const { createdAt, paths: runPaths } = run;
     const redactScreenshots = plan.residual.policies?.redactScreenshots === true;
     await prepareContainedOutputDirectory(runPaths, "screenshots");
     const source = await buildRunSource({
@@ -231,7 +230,7 @@ export async function startCuaRun(plan, input, admitted, scope) {
         packageName: "humanish",
     });
     // Live-trace flush seam (#441): runLabParticipants fills it when a live run has an in-progress bundle
-    // to grow; lanes call it through deps.onTrace. It exists before deps so deps can reference it as
+    // to grow; participants call it through deps.onTrace. It exists before deps so deps can reference it as
     // a stable indirection.
     const liveTrace = {};
     const deps = cuaParticipantDeps(plan, input, admitted, {
@@ -241,7 +240,6 @@ export async function startCuaRun(plan, input, admitted, scope) {
     });
     const subjectArgs = {
         plan,
-        subjectRoute: admitted.subjectRoute,
         ...(publicRepo === undefined ? {} : { publicRepo }),
         ...(admitted.localTreeArchive === undefined
             ? {}
@@ -254,25 +252,20 @@ export async function startCuaRun(plan, input, admitted, scope) {
         dryRun: false,
     });
     const inProgressAggregateSubject = inProgressSubjects[0];
-    const inProgressProvenance = subjectProvenanceArg(inProgressAggregateSubject, publicRepo, subjectEnvNames);
+    const inProgressProvenance = subjectProvenanceArg(inProgressAggregateSubject, publicRepo, [
+        ...participantSubjectEnv(plan.runner.subject),
+    ]);
     const bundleBase = {
-        ...(plan.lab === undefined ? {} : { lab: plan.lab }),
+        run,
         participantRuns,
         descriptor,
         appUrl,
-        createdAt,
         plan,
-        runId,
         source,
         participantPlan,
         ...(admitted.rerunLineage === undefined ? {} : { rerun: admitted.rerunLineage }),
         redactScreenshots,
-        inProcessRoute,
-        localAppSubject,
-        cloneRoute,
-        localTreeRoute,
         ...(publicRepo === undefined ? {} : { publicRepo }),
-        subjectEnvNames,
     };
     const { externalCommsConfig, externalCommsEmail } = admitted;
     return {
@@ -280,10 +273,8 @@ export async function startCuaRun(plan, input, admitted, scope) {
         setup: {
             plan,
             input,
-            config,
             cwd,
             descriptor,
-            subjectRoute: admitted.subjectRoute,
             run,
             streams: admitted.streams,
             participantRuns,
@@ -306,35 +297,30 @@ export async function startCuaRun(plan, input, admitted, scope) {
             },
             fail: admitted.fail,
         },
-        finish: { hooks, rerunLineage: admitted.rerunLineage, publicRepo, subjectArgs },
+        finish: { rerunLineage: admitted.rerunLineage, publicRepo, subjectArgs },
     };
 }
-/** The lane deps every lane reads: the route, keys, timeouts, scrubber, budget and hooks. */
+/** The participant deps every participant reads: the route, keys, timeouts, scrubber, budget and seams. */
 function cuaParticipantDeps(plan, input, admitted, run) {
-    const { config, dryRun, hooks, streams, env, descriptor, runSession, participantCount } = admitted;
-    const { localAgentRoute, preferredLocalAgent, hasGithubToken, localTreeArchiveBuffer } = admitted;
+    const { config, dryRun, seams, streams, env, runSession, participantCount } = admitted;
+    const { localTreeArchiveBuffer } = admitted;
     const { openaiApiKey, e2bApiKey, scrubKnownValues } = admitted;
     const { externalCommsConfig, externalCommsEmail } = admitted;
-    const { appUrl, cloneRoute, desktopCliRoute, localTreeRoute, serve, subjectRepo } = admitted.subjectRoute;
-    const { subjectEnvNames } = admitted.subjectRoute;
+    const { appUrl } = admitted;
     const { runPaths, redactScreenshots, liveTrace } = run;
-    const createDesktop = participantDesktopOf(hooks);
+    const createDesktop = input.localVm?.desktop;
     const timeoutMs = plan.sessionBudgetMs;
     const requestTimeoutMs = e2bRequestTimeoutMs(env);
     return {
         ...(createDesktop === undefined ? {} : { createDesktop }),
         onTrace: (participantId, items, usage, metadata) => liveTrace.flush?.(participantId, items, usage, metadata),
-        config,
-        descriptor,
+        ...callerDriving(input, config),
+        residual: plan.residual,
+        labId: plan.labId,
+        caps: plan.caps,
         appUrl,
-        ...(localAgentRoute ? { localAgent: preferredLocalAgent } : {}),
-        cloneRoute,
-        desktopCliRoute,
-        localTreeRoute,
-        ...(serve === undefined ? {} : { serve }),
-        ...(subjectRepo === undefined ? {} : { subjectRepo }),
-        subjectEnvNames,
-        hasGithubToken,
+        brain: plan.runner.brain,
+        subject: plan.runner.subject,
         ...(localTreeArchiveBuffer === undefined ? {} : { localTreeArchiveBuffer }),
         env,
         openaiApiKey,
@@ -348,7 +334,7 @@ function cuaParticipantDeps(plan, input, admitted, run) {
         redactScreenshots,
         scrubKnownValues,
         runSession,
-        // The study-level ledger exists once per RUN, shared by every lane (#299). Dry runs never
+        // The study-level ledger exists once per RUN, shared by every participant (#299). Dry runs never
         // spend, so they carry none.
         ...(dryRun || plan.caps.maxTotalUsd === undefined
             ? {}
@@ -361,8 +347,34 @@ function cuaParticipantDeps(plan, input, admitted, run) {
                     inboxUrl: externalInboxUrl(externalCommsConfig),
                 },
             }),
-        now: hooks.now ?? Date.now,
-        hooks: streams.hooks,
+        now: seams.now ?? Date.now,
+        ...(seams.desktopModule === undefined ? {} : { desktopModule: seams.desktopModule }),
+        ...(input.prepareDesktop === undefined ? {} : { prepareDesktop: input.prepareDesktop }),
+        ...(seams.detachedTimers === undefined ? {} : { detachedTimers: seams.detachedTimers }),
+        onStream: streams.onStream,
+        reportSubjectPhase: subjectPhaseReporter(input),
+    };
+}
+/** The caller's createProvider and inProcess executor, with the run's config bound. */
+function callerDriving(input, config) {
+    const { createProvider, inProcess } = input;
+    return {
+        ...(createProvider === undefined
+            ? {}
+            : {
+                createProvider: (participant, executor) => createProvider({ config, participant, executor }),
+            }),
+        ...(inProcess === undefined
+            ? {}
+            : { inProcessExecutor: (appUrl) => inProcess.executor({ config, appUrl }) }),
+    };
+}
+/** Each subject phase goes to the phase sink, stderr by default, and to onEvent. */
+function subjectPhaseReporter(input) {
+    const sink = input.deps?.subjectPhaseSink ?? defaultSubjectPhaseSink;
+    return (event, participant) => {
+        sink(event, participant);
+        input.emit?.(phaseEvent(event, { kind: "participant", participant: participantOf(participant) }));
     };
 }
 function makeCuaRunId() {