humanish 0.106.1 → 0.107.0

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

@@ -1,6 +1,6 @@
-// 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";
@@ -15,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
@@ -32,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));
@@ -48,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: [],
@@ -66,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,
@@ -88,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) {
@@ -104,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() ?? "";
@@ -124,34 +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");
+    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,
             brain: plan.runner.brain,
-            hooks,
             env,
-            openaiApiKey,
-            e2bApiKey,
-            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;
         }
@@ -165,10 +177,10 @@ export async function admitCuaRun(plan, input, config) {
             config,
             dryRun,
             cwd,
-            hooks,
+            seams,
             streams,
             env,
-            subjectRoute,
+            appUrl,
             fail,
             refuse,
             descriptor,
@@ -184,7 +196,6 @@ export async function admitCuaRun(plan, input, config) {
             knownSecretValues,
             scrubKnownValues,
             publicRepo,
-            hasGithubToken,
             localTreeArchive,
             localTreeArchiveBuffer,
         },
@@ -192,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.
@@ -204,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({
@@ -219,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, {
@@ -229,7 +240,6 @@ export async function startCuaRun(plan, input, admitted, scope) {
     });
     const subjectArgs = {
         plan,
-        subjectRoute: admitted.subjectRoute,
         ...(publicRepo === undefined ? {} : { publicRepo }),
         ...(admitted.localTreeArchive === undefined
             ? {}
@@ -242,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 {
@@ -268,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,
@@ -294,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 { 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,
         brain: plan.runner.brain,
-        cloneRoute,
-        desktopCliRoute,
-        localTreeRoute,
-        ...(serve === undefined ? {} : { serve }),
-        ...(subjectRepo === undefined ? {} : { subjectRepo }),
-        subjectEnvNames,
-        hasGithubToken,
+        subject: plan.runner.subject,
         ...(localTreeArchiveBuffer === undefined ? {} : { localTreeArchiveBuffer }),
         env,
         openaiApiKey,
@@ -336,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
             ? {}
@@ -349,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() {

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

@@ -3,8 +3,7 @@ import type { SubjectPhaseEvent } from "../../subject/steps.js";
 import type { DesktopBrowserEvidence } from "../../substrates/e2b/desktop-browser.js";
 import type { ActorPersonaRef } from "../../actors/contract.js";
 import type { CuaLoopResult } from "../../actors/computer-use/loop.js";
-import { type RunLabProvenance } from "../../run/status.js";
-import { type RunBundle, type RunFeedbackCandidate, type RunProviderResource } from "../../run/bundle.js";
+import { type BundleRun, type RunBundle, type RunFeedbackCandidate, type RunProviderResource } from "../../run/bundle.js";
 import { type RunDesktopGeometry, type RunStream } from "../../run/streams.js";
 import { type Verdict } from "../../run/judge.js";
 import { type DesktopUsage } from "../../run/cost-summary.js";
@@ -17,8 +16,8 @@ export declare function buildSingleParticipantBundle(args: {
     /** The run's verdict, from the judge. */
     verdict: Verdict;
     realEmail?: boolean;
-    /** Lab provenance for the bundle's own `lab` field (#455). */
-    lab?: RunLabProvenance;
+    /** The run this bundle belongs to; the bundle head reads its id, mode, start and lab. */
+    run: BundleRun;
     actorId: string;
     appUrl: string;
     /** The participant's plan id, saved as the stream's laneId ("lane-01" when absent). */
@@ -26,7 +25,6 @@ export declare function buildSingleParticipantBundle(args: {
     actorType?: string;
     surface?: string;
     caseGroup?: string;
-    createdAt: string;
     dryRun: boolean;
     labId: string;
     labTitle?: string;
@@ -44,7 +42,6 @@ export declare function buildSingleParticipantBundle(args: {
     /** Device-preset touch metadata echoed on the measured stream viewport (a prompt signal on
      *  this route, never a rendered claim); the measured width/height/DPR stay authoritative. */
     isMobile?: boolean;
-    runId: string;
     screenshots: string[];
     /** Relative run-dir path of the digest-only comms-thread evidence artifact (humanish.comms-thread.v1),
      *  when a comms lab captured mail; registered as a "log" stream artifact. */
@@ -59,10 +56,10 @@ export declare function buildSingleParticipantBundle(args: {
     session?: CuaLoopResult;
     sessionError?: string;
     /**
-     * The lane's own credibility read of a goal_satisfied session (#476). The actor's status is
-     * evidence of what it CLAIMED; whether the harness counts the claim is decided by the lane
+     * The route's own credibility read of a goal_satisfied session (#476). The actor's status is
+     * evidence of what it CLAIMED; whether the harness counts the claim is decided by the route
      * (zero engagement, a final message that describes a blocker). The review has to say the same
-     * thing the lane's exit code says, or the durable bundle reports a participant reaching the
+     * thing the participant's exit code says, or the durable bundle reports a participant reaching the
      * goal on a run the harness refused to count.
      */
     credibility?: {
@@ -80,7 +77,7 @@ export declare function buildSingleParticipantBundle(args: {
      * declared honestly as caller-provisioned/unpinned with no E2B. Absent: a plain app-url entry.
      */
     entryKind?: "local-app";
-    /** The custom E2B desktop template (image) this lane launched on, when configured (provenance). */
+    /** The custom E2B desktop template (image) this participant launched on, when configured (provenance). */
     desktopTemplate?: string;
     /** The configured browser choice and the command that opened, when explicitly configured. */
     desktopBrowser?: DesktopBrowserEvidence;
@@ -90,7 +87,7 @@ export declare function buildSingleParticipantBundle(args: {
     /** Completed subject-phase records (clone/upload/extract/install/build/ready/state groups)
      *  to fold into bundle.events, so run.json carries real phase timing after the fact. */
     phaseEvents?: SubjectPhaseEvent[];
-    /** Host-side E2B desktop billed span for this lane, in minutes (from ParticipantRunOutcome
+    /** Host-side E2B desktop billed span for this participant, in minutes (from ParticipantRunOutcome
      *  desktopDurationMs). Absent when no sandbox ran (in-process/dry-run) → no desktop cost line. */
     desktopMinutes?: number;
     desktopUsage?: DesktopUsage;

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

@@ -1,6 +1,5 @@
 import { participantAssignment } from "../../lab/participant-assignment.js";
 import { redactText } from "../../evidence/redaction.js";
-import {} from "../../run/status.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
 import {} from "../../run/streams.js";
 import { aggregateTaskFunnels, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
@@ -94,8 +93,8 @@ function singleSimulation(args, view) {
                 : args.sessionError !== undefined
                     ? `Computer-use lab failed before a terminal session verdict: ${args.sessionError}`
                     : `Contract participant for the computer-use actor (${args.actorId}) against ${publicAppUrl}.`,
-        startedAt: args.createdAt,
-        updatedAt: args.createdAt,
+        startedAt: args.run.createdAt,
+        updatedAt: args.run.createdAt,
     });
 }
 function singleStream(args, view) {
@@ -111,7 +110,7 @@ function singleStream(args, view) {
         label: `CUA browser — ${args.labId}`,
         status,
         transport: "snapshot",
-        updatedAt: args.createdAt,
+        updatedAt: args.run.createdAt,
         embed: lastScreenshot
             ? { kind: "screenshot", url: lastScreenshot, title: `CUA desktop (${screenshotMode})` }
             : { kind: "placeholder", title: "CUA desktop" },
@@ -162,7 +161,7 @@ function singleEvents(args, view) {
     const events = [
         {
             id: "event-000-created",
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "info",
             type: "cua-lab.run.created",
             message: `Created computer-use lab run for ${args.labId} (actor ${args.actorId}).`,
@@ -170,7 +169,7 @@ function singleEvents(args, view) {
         args.subjectProvenance
             ? participantEvent(SINGLE, {
                 id: "event-001-subject",
-                at: args.createdAt,
+                at: args.run.createdAt,
                 level: "info",
                 type: "cua-lab.subject.provenance",
                 // HONEST WORDING: claim "cloned/packed and served" only when it actually happened.
@@ -178,7 +177,7 @@ function singleEvents(args, view) {
             })
             : participantEvent(SINGLE, {
                 id: "event-001-subject",
-                at: args.createdAt,
+                at: args.run.createdAt,
                 level: "info",
                 type: "cua-lab.subject.declared",
                 // Invariant 5: declare what the subject WAS, including the ABSENCE of a pin. A
@@ -195,7 +194,7 @@ function singleEvents(args, view) {
         args.session
             ? participantEvent(SINGLE, {
                 id: "event-002-session",
-                at: args.createdAt,
+                at: args.run.createdAt,
                 level: args.session.status === "passed" ? "info" : "warn",
                 type: `cua-lab.session.${args.session.completionReason}`,
                 message: `${args.session.status}: ${args.session.reason}`,
@@ -203,7 +202,7 @@ function singleEvents(args, view) {
             : args.inProgress === true
                 ? participantEvent(SINGLE, {
                     id: "event-002-running",
-                    at: args.createdAt,
+                    at: args.run.createdAt,
                     level: "info",
                     type: "cua-lab.session.running",
                     message: "Live computer-use session is running; terminal evidence has not been written yet.",
@@ -211,14 +210,14 @@ function singleEvents(args, view) {
                 : args.sessionError !== undefined
                     ? participantEvent(SINGLE, {
                         id: "event-002-session",
-                        at: args.createdAt,
+                        at: args.run.createdAt,
                         level: "error",
                         type: "cua-lab.session.error",
                         message: args.sessionError,
                     })
                     : participantEvent(SINGLE, {
                         id: "event-002-contract",
-                        at: args.createdAt,
+                        at: args.run.createdAt,
                         level: "info",
                         type: "cua-lab.contract.ready",
                         message: "Dry-run contract bundle ready; switch scenario.mode to live for a real desktop session.",
@@ -242,7 +241,7 @@ function singleEvents(args, view) {
     for (const warning of desktopGeometry?.warnings ?? []) {
         record({
             id: `event-${String(phaseEventSeq++).padStart(3, "0")}-geometry-warning`,
-            at: args.createdAt,
+            at: args.run.createdAt,
             level: "warn",
             type: "cua-lab.geometry.warning",
             message: warning,
@@ -254,12 +253,12 @@ function singleReview(args, view, stream) {
     const { reason } = view;
     // A funnel with a denominator of one is still the funnel — and its absence stays honest: no
     // declared protocol (or a dry run) means no `tasks` field, never an empty one.
-    const singleStudyTasks = args.inProgress !== true && args.session?.trace.taskFunnel !== undefined
+    const singleRunTasks = args.inProgress !== true && args.session?.trace.taskFunnel !== undefined
         ? aggregateTaskFunnels([args.session.trace.taskFunnel])
         : undefined;
-    // What happened to the participant, as the LANE judged it — the same rule the fan-out roll-up
+    // What happened to the participant, as the route judged it — the same rule the fan-out roll-up
     // applies (participantStatusForOutcome). Before #476 this read the actor's own status, so a
-    // run the lane refused as "not a credible pass" was written up as verdict pass, 1/1 reached
+    // run the route refused as "not a credible pass" was written up as verdict pass, 1/1 reached
     // the goal, and every projection of the bundle (Observer tally, `runs`, the status index)
     // repeated it. Found on a real drawDB run whose participant wrote "Blocked after partial
     // completion".
@@ -274,14 +273,14 @@ function singleReview(args, view, stream) {
     const review = withCuaReviewProvenance({
         schema: REVIEW_SCHEMA,
         verdict: args.verdict,
-        // One lane is still a study with a denominator of one, and saying so keeps a single-lane
-        // result from being read as though it generalized.
+        // One participant is still a study with a denominator of one, and saying so keeps a
+        // single-participant result from being read as though it generalized.
         ...(participantStatus !== undefined && args.inProgress !== true
             ? {
                 participants: tallyParticipantOutcomes([participantStatus], [args.credibility?.reportedFriction === true]),
             }
             : {}),
-        ...(singleStudyTasks === undefined ? {} : { tasks: singleStudyTasks }),
+        ...(singleRunTasks === undefined ? {} : { tasks: singleRunTasks }),
         summary: credibilityNote === undefined ? reason : `${credibilityNote} ${reason}`,
         gaps: args.session || args.sessionError !== undefined
             ? []
@@ -305,15 +304,11 @@ export function buildSingleParticipantBundle(args) {
     const events = singleEvents(args, view);
     const review = singleReview(args, view, stream);
     return {
-        ...bundleHead({
+        ...bundleHead(args.run, {
             ...(args.realEmail && !args.dryRun
                 ? { publication: { restrictions: ["real-communications"] } }
                 : {}),
-            runId: args.runId,
-            mode: args.dryRun ? "dry-run" : "live",
             participants: 1,
-            createdAt: args.createdAt,
-            ...(args.lab === undefined ? {} : { lab: args.lab }),
             source: args.source,
         }),
         persona: {
@@ -331,7 +326,7 @@ export function buildSingleParticipantBundle(args) {
         },
         lifecycle: [
             {
-                at: args.createdAt,
+                at: args.run.createdAt,
                 event: "cua-lab.run.created",
                 message: `Created computer-use lab run with one participant in a desktop browser (actor ${args.actorId}).`,
             },
@@ -356,7 +351,7 @@ export function buildSingleParticipantBundle(args) {
         feedbackCandidates: args.dryRun || args.inProgress === true
             ? []
             : participantFeedbackCandidates({
-                runId: args.runId,
+                runId: args.run.runId,
                 scenarioId: `cua-${args.labId}`,
                 adapterId: args.labId,
                 goal: redactText(args.mission),

package/dist/routes/computer-use/subject-projection.d.ts

@@ -2,16 +2,14 @@ import type { ComputerUsePlan } from "../../lab/plan-types.js";
 import type { LabSubjectState } from "../../lab/types.js";
 import { type RunSubjectProvenance, type RunSubjectStateStepRecord } from "../../run/bundle.js";
 import { type LocalTreeArchive } from "../../subject/local-tree-archive.js";
-import { type CuaSubjectRoute } from "./plan.js";
 import { type DesktopParticipantRun, type CuaSubjectProjection, type CuaSubjectProvenanceArg, type ParticipantRunOutcome } from "./types.js";
 /**
- * Each lane's subject projection. A lane's outcome adds the subject commit it resolved and the
+ * Each participant's subject projection. A participant's outcome adds the subject commit it resolved and the
  * state steps it executed; without outcomes (dry run, or a run still in progress) the declared
  * state is projected as not yet run.
  */
 export declare function projectParticipantSubjects(args: {
     plan: ComputerUsePlan;
-    subjectRoute: CuaSubjectRoute;
     publicRepo?: string;
     localTreeArchive?: LocalTreeArchive;
     runs: readonly DesktopParticipantRun[];
@@ -35,10 +33,10 @@ export declare function resolveSubjectState(args: {
  *  default branch that builder already handles). */
 export declare function subjectProvenanceArg(subject: CuaSubjectProjection, publicRepo: string | undefined, subjectEnvNames: string[]): CuaSubjectProvenanceArg | undefined;
 /**
- * The run-level subject for the top level and the bundle. Local-tree lanes all pack from the same
- * once-per-run archive, so every lane already carries the identical archiveSha256/commit/dirty and
- * the first lane's projection is the aggregate. Clone lanes each resolve their own commit; the
- * aggregate carries it only when every lane agrees, and warns when they diverge.
+ * The run-level subject for the top level and the bundle. Local-tree participants all pack from the
+ * same once-per-run archive, so every participant already carries the identical archiveSha256/commit/dirty and
+ * the first participant's projection is the aggregate. Clone participants each resolve their own
+ * commit; the aggregate carries it only when every participant agrees, and warns when they diverge.
  */
 export declare function aggregateCuaSubject(args: {
     subjects: readonly CuaSubjectProjection[];