humanish 0.106.1 → 0.108.0

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

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

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

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

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

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

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

@@ -3,27 +3,27 @@ import { receivingPublication } from "../../comms/receiving-runtime.js";
 import { actorEnding } from "../../actors/stop-cause.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { aggregateTaskFunnels, formatParticipantOutcomes, formatStudyTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, tallyParticipantOutcomes, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { participantFeedbackCandidates, providerResourcesForOutcome } from "./bundle-parts.js";
 import { participantFactsOf } from "./participant-facts.js";
 import { participantPassed, participantStatus } from "../../run/judge.js";
 import { buildRunCostSummary, desktopSpanToMinutes } from "../../run/cost-summary.js";
 import { formatParticipantPlanEntry } from "./participant-runs.js";
-import { fanoutParticipantRecords } from "./fanout-lanes.js";
+import { fanoutParticipantRecords } from "./fanout-records.js";
 /** The run's first two events: its creation and the fan-out plan. */
 function fanoutPlanEvents(args) {
     const { specs, plan } = args;
     const events = [];
     events.push({
         id: "event-000-created",
-        at: args.createdAt,
+        at: args.run.createdAt,
         level: "info",
         type: "cua-lab.run.created",
         message: `Created computer-use fan-out run for ${plan.labId} (actor ${args.descriptor.id}, ${specs.length} participants, one world each).`,
     });
     events.push({
         id: "event-001-fanout-plan",
-        at: args.createdAt,
+        at: args.run.createdAt,
         level: "info",
         type: "cua-lab.fanout.plan",
         message: `Fan-out plan: ${args.participantPlan.laneCount} participant(s) (${args.participantPlan.strategy}), concurrency ${args.participantPlan.concurrency}, ${args.participantPlan.waves} wave(s); session budget ${Math.round(args.participantPlan.perLaneSessionBudgetMs / 1000)}s per participant; worst-case ~${args.participantPlan.worstCaseSandboxMinutes} sandbox-minutes${args.dryRun ? " (dry-run: $0)" : ""}. Participants: ${args.participantPlan.lanes.map(formatParticipantPlanEntry).join(", ")}.`,
@@ -32,33 +32,33 @@ 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
+    // What happened to the participants, with the denominator attached. The verdict above has to
     // collapse the run to one word; this does not (docs/principles/three-roles.md).
     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
+        // count it, but `reachedGoal` was reading the trace status directly, so one run could be both
+        // "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,
             selfReportedBlocker: outcome.selfReportedBlocker === true,
         })), 
-        // A participant who reached the goal AND told you the road there was broken is the most
+        // A participant who reached the goal and told you the road there was broken is the most
         // useful result a study produces; reporting only the outcome would bury it.
         terminalOutcomes.map((outcome) => outcome.reportedFriction === true))
         : undefined;
     // The study funnel: per-task completion rates across every session that measured one. This is
-    // "where did people get stuck" as data, next to WHO got stuck (participants) above.
+    // "where did people get stuck" as data, next to who got stuck (participants) above.
     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,16 +70,16 @@ 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}: ` : ""}Dry-run fan-out: ${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)}` : ""}${runTasks ? `; tasks: ${formatRunTaskFunnel(runTasks)}` : ""}.`,
         gaps: args.inProgress === true
             ? ["Live fan-out session is still running."]
             : args.dryRun
-                ? ["Live fan-out session not yet run (dry-run contract only)."]
+                ? ["Live fan-out session not yet run (dry run only)."]
                 : specs
                     .map((spec, index) => ({ spec, outcome: outcomes?.[index] }))
                     .filter(({ outcome }) => outcome === undefined ||
@@ -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,45 +204,41 @@ 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: {
             id: specs[0].persona.id,
             name: `Computer-use fan-out (${specs.length} participants)`,
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.labId}`,
             sourceDigest: specs[0].persona.promptDigest,
         },
         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).
+            // this writer produced. The only adopter-side workaround was scanner evasion.
             //
             // The instructions the model actually receives are untouched; only the persisted copy changes.
             goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
-            source: `lab:${plan.labId}`,
+            source: `study:${plan.labId}`,
             sourceDigest: specs[0].persona.promptDigest,
         },
         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}).`,
             },
@@ -255,14 +251,14 @@ export function buildCuaFanoutBundle(args) {
             status: "passed",
             notes: ranLive
                 ? anyRaw
-                    ? "Typed text recorded as length only and reasoning/messages pass through text redaction. Some participants captured FULL-FIDELITY (raw) screenshots, retained for local use and NOT redacted for publishing; set policies.redactScreenshots: true to blur a share-as-is bundle."
+                    ? "Typed text is recorded as its length only, and reasoning and messages pass through text redaction. Some participants captured unblurred screenshots, kept for local use and not redacted for publishing. Set policies.redactScreenshots: true to blur screenshots in a bundle you plan to share."
                     : "Typed text recorded as length only and reasoning/messages pass through text redaction. Screenshots are blurred at capture (policies.redactScreenshots: true) for a share-as-is bundle."
-                : "Dry-run fan-out contract bundle: no desktops launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs.",
+                : "Dry-run fan-out bundle: no desktops launched and no screenshots captured. Typed text is recorded as length only and reasoning/messages pass through text redaction whenever a session runs.",
         },
         artifacts: bundleArtifacts(),
         review,
-        // What the participants reported, when any reported anything (#392). Dry-run and in-progress
-        // bundles carry none — there is no participant yet to quote.
+        // What the participants reported, when any reported anything. Dry-run and in-progress
+        // bundles carry none: there is no participant yet to quote.
         feedbackCandidates: fanoutFeedbackCandidates(args),
         // Selected hosted image, including the optional speech default; omitted on the stock desktop.
         ...(desktopTemplate === undefined ? {} : { desktopTemplate }),

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];
@@ -37,7 +41,7 @@ function fanoutParticipantView(args, spec, index) {
         : (outcome?.skippedReason ??
             session?.reason ??
             outcome?.sessionError ??
-            "Contract bundle only: dry-run produced the evidence shape without launching a desktop or spending provider tokens.");
+            "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     const screenshotMode = traceScreenshotMode === "raw" || traceScreenshotMode === "blurred"
         ? traceScreenshotMode
@@ -76,15 +80,15 @@ function fanoutParticipantRecord(args, spec, index, view) {
                     ? `Participant ${spec.planned.id} ${outcome.skippedReason}.`
                     : 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,
+                        : `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}; no session ran.`,
+        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
             ? {}
@@ -99,17 +103,18 @@ function fanoutParticipantStream(args, spec, view) {
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
         kind: "browser",
-        label: `CUA participant ${spec.planned.id}: ${plan.labId}`,
+        label: `${spec.planned.id} · browser`,
         status,
+        ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
-        updatedAt: args.createdAt,
+        updatedAt: args.run.createdAt,
         embed: lastScreenshot
             ? {
                 kind: "screenshot",
                 url: lastScreenshot,
-                title: `CUA desktop ${spec.planned.id} (${screenshotMode})`,
+                title: `Desktop (${screenshotMode})`,
             }
-            : { kind: "placeholder", title: `CUA desktop ${spec.planned.id}` },
+            : { kind: "placeholder", title: "Desktop" },
         ...(desktopGeometry.viewport === undefined
             ? {}
             : {
@@ -174,41 +179,41 @@ 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.
+    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
-                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing cloned)`
+                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry run; nothing cloned)`
                 : subject.commit
                     ? 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
-                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing packed)`
+                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry run; nothing packed)`
                 : subject.archiveSha256
                     ? 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 +226,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 +239,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 +248,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 +257,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,23 +266,23 @@ 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.`,
+            message: `Participant ${spec.planned.id}: dry-run participant ready; switch scenario.mode to live for a real desktop session.`,
         });
     }
     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: 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;