humanish 0.104.3 → 0.106.0

package/dist/routes/computer-use/e2b-desktop/teardown.js

@@ -0,0 +1,152 @@
+// Teardown for one E2B desktop lane: its final geometry and comms evidence are collected, then the
+// recording and speech worker, then the sandbox is released by id (or kept for debugging), with a
+// warning for every outcome that is not a confirmed release.
+import { collectDesktopRecording } from "../../../evidence/desktop-recording-artifact.js";
+import { redactText, toErrorMessage } from "../../../evidence/redaction.js";
+import { readE2BRelease } from "../../../substrates/e2b/sandbox.js";
+import { e2bShell } from "../../../substrates/e2b/shell.js";
+import { drainCommsEvidence } from "./comms.js";
+import { finalParticipantGeometry } from "./fidelity.js";
+/**
+ * Each route's own keep flag gates its own lane only: a clone.keep can never leak into a local-tree
+ * lane's teardown decision, and vice versa.
+ */
+function participantKeepReason(deps) {
+    const { config, cloneRoute, localTreeRoute } = deps;
+    if (cloneRoute && config.subject.clone?.keep === true)
+        return "subject.clone.keep";
+    if (localTreeRoute && config.subject.localTree?.keep === true)
+        return "subject.localTree.keep";
+    return undefined;
+}
+/** Collect the recording and stop the speech worker; failures are warnings. */
+async function stopParticipantMedia(args) {
+    const { deps, warnings, recording } = args;
+    let evidence;
+    if (recording) {
+        try {
+            evidence = await collectDesktopRecording(deps.artifactRoot, args.spec.planned.id, (destination) => recording.finish(destination));
+        }
+        catch (error) {
+            warnings.push(`Desktop recording collection failed: ${redactText(deps.scrubKnownValues(toErrorMessage(error)))}`);
+        }
+    }
+    args.mediaStop.abort();
+    await args.speech?.close().catch(() => {
+        warnings.push("Speech worker cleanup was interrupted; desktop teardown will reclaim it.");
+    });
+    return evidence;
+}
+/**
+ * Release the lane's sandbox, or keep it when a keep flag is set and the lane failed. Returns true
+ * only when the release is confirmed. A kept or unconfirmed sandbox can still accrue compute cost,
+ * which the warnings say.
+ */
+async function releaseParticipantDesktop(args) {
+    const { allocation, keepReason, deps, warnings } = args;
+    const keepForDebug = keepReason !== undefined && args.failed;
+    const released = await allocation.close({ retainForDebug: keepForDebug });
+    if (released.status === "retained") {
+        warnings.push(`Sandbox ${allocation.resourceId} kept for debugging (${keepReason} on failure); reclaim it via E2B or it will be killed on its server-side timeout.`);
+        return false;
+    }
+    const reading = readE2BRelease(released, {
+        label: "Sandbox",
+        scrub: deps.scrubKnownValues,
+        costSpan: true,
+    });
+    if (reading.warning)
+        warnings.push(reading.warning);
+    return reading.released;
+}
+/**
+ * Finish a lane: collect its final geometry and comms evidence, then stop its media and release
+ * its sandbox. Evidence failures are warnings; the release always runs.
+ */
+export async function finishE2BDesktop(ctx, state, failed) {
+    const { spec, deps, warnings } = ctx;
+    // Stop the mid-run inbox-surface loop first, before the evidence drain below, so the two `cat`s
+    // never overlap and the final surface state is deterministic. A surface failure can never block
+    // teardown (the loop body is fully try/caught and this await is on its already-caught promise).
+    await state.commsCatch?.stopSurface();
+    const { desktop, allocation } = state;
+    if (!desktop || !allocation)
+        return;
+    try {
+        if (state.browserLaunched) {
+            state.desktopGeometry = await finalParticipantGeometry({
+                desktop,
+                spec,
+                deps,
+                targetUrl: ctx.targetUrl,
+                browserFamily: state.launchedBrowserFamily,
+                launchIdentity: state.browserLaunchIdentity,
+                windowId: state.browserWindowId,
+                targetId: state.browserTargetId,
+                initial: state.initialBrowserGeometry,
+                geometry: state.desktopGeometry,
+                fidelity: state.fidelity,
+                warnings,
+            });
+        }
+        if (deps.receiving) {
+            try {
+                await deps.receiving.finishParticipant(spec.planned.id);
+            }
+            catch {
+                warnings.push("Real email finalization is incomplete. Inspect communication cleanup with humanish comms recover.");
+            }
+        }
+        if (ctx.comms && state.commsCatch?.deployed.ready) {
+            const drained = await drainCommsEvidence({
+                shell: e2bShell(desktop),
+                comms: ctx.comms,
+                deployed: state.commsCatch.deployed,
+                spec,
+                deps,
+                warnings,
+            });
+            if (drained !== undefined)
+                state.commsArtifactPath = drained;
+        }
+    }
+    catch (error) {
+        warnings.push(`Desktop final evidence collection failed: ${redactText(deps.scrubKnownValues(toErrorMessage(error)))}`);
+    }
+    finally {
+        state.recordingEvidence = await stopParticipantMedia({
+            spec,
+            deps,
+            recording: state.recording,
+            speech: state.speech,
+            mediaStop: state.mediaStop,
+            warnings,
+        });
+        state.released = await releaseParticipantDesktop({
+            allocation,
+            keepReason: participantKeepReason(deps),
+            failed,
+            deps,
+            warnings,
+        });
+        // Close the observed span. A kept or unconfirmed sandbox can still accrue compute cost; the
+        // summary records that remaining lifetime as unknown instead of calling this complete.
+        state.sandboxTornDownAtMs = deps.now();
+        // The lane's live stream is now a dead page whichever teardown path ran (released, kept, or
+        // release-failed-awaiting-TTL); tell the watch overlay so the tile falls back to recorded
+        // evidence instead of "sandbox not found" (#357). Guarded: a viewer callback must never
+        // break teardown.
+        if (state.streamUrl !== undefined) {
+            try {
+                await deps.hooks.onRuntimeStreamEnded?.({
+                    laneId: spec.planned.id,
+                    simId: spec.recordId,
+                    streamId: spec.streamId,
+                });
+            }
+            catch {
+                // viewer-side only; nothing to record
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+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
+ * 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
+ * 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`.
+ */
+export declare function drainExternalComms(args: {
+    externalCommsConfig: LabCommsExternal;
+    externalCommsEmail: LabCommsEmail;
+    env: Record<string, string | undefined>;
+    runPaths: PreparedRunArtifactPaths;
+    participantRuns: readonly DesktopParticipantRun[];
+    outcomes: ParticipantRunOutcome[];
+    scrubKnownValues: (text: string) => string;
+}): Promise<string[]>;

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

@@ -0,0 +1,55 @@
+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 { 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
+ * 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
+ * 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`.
+ */
+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;
+                }
+            }
+        }
+        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

@@ -0,0 +1,11 @@
+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
+ * 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
+ * streams. A single-participant run without a rerun never reaches here: buildCuaRunBundle
+ * (bundle.ts) sends it to buildSingleParticipantBundle (single-bundle.ts).
+ */
+export declare function buildCuaFanoutBundle(args: CuaFanoutBundleArgs): RunBundle;

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

@@ -0,0 +1,274 @@
+import { e2bDesktopTemplate } from "../../substrates/e2b/sandbox.js";
+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 { 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";
+/** 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,
+        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,
+        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(", ")}.`,
+    });
+    return events;
+}
+function fanoutReview(args, streams) {
+    const { specs, outcomes } = args;
+    // The judge's verdict: live fan-out must prove every lane (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
+    // 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
+        // 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
+        // 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
+        // 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.
+    const participantFunnels = (outcomes ?? [])
+        .map((outcome) => outcome?.session?.trace.taskFunnel)
+        .filter((funnel) => funnel !== undefined);
+    const studyTasks = args.inProgress === true ? undefined : aggregateTaskFunnels(participantFunnels);
+    const participantEndings = terminalOutcomes.map((outcome) => {
+        const ending = actorEnding(outcome.session.trace);
+        return {
+            status: outcome.session.status,
+            ...(ending === undefined ? {} : { label: ending.label }),
+        };
+    });
+    const review = withCuaReviewProvenance({
+        schema: REVIEW_SCHEMA,
+        verdict,
+        ...(participants === undefined ? {} : { participants }),
+        ...(studyTasks === undefined ? {} : { tasks: studyTasks }),
+        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)}` : ""}.`,
+        gaps: args.inProgress === true
+            ? ["Live fan-out session is still running."]
+            : args.dryRun
+                ? ["Live fan-out session not yet run (dry-run contract only)."]
+                : specs
+                    .map((spec, index) => ({ spec, outcome: outcomes?.[index] }))
+                    .filter(({ outcome }) => outcome === undefined ||
+                    outcome.skippedReason !== undefined ||
+                    outcome.sessionError !== undefined ||
+                    outcome.noEngagement ||
+                    outcome.selfReportedBlocker ||
+                    outcome.session === undefined ||
+                    outcome.session.status !== "passed")
+                    .map(({ spec, outcome }) => `${spec.planned.id}: ${outcome?.skippedReason ?? outcome?.sessionError ?? outcome?.session?.reason ?? "did not pass"}`),
+    }, streams);
+    return review;
+}
+/** The configured browser and, when every lane resolved the same one, that browser. */
+function fanoutDesktopBrowser(args) {
+    const { outcomes, plan } = args;
+    const configuredBrowser = plan.residual.execution?.desktop?.browser;
+    const resolvedBrowsers = (outcomes ?? [])
+        .map((outcome) => outcome.desktopBrowser?.resolved)
+        .filter((value) => value !== undefined);
+    const unanimousResolvedBrowser = resolvedBrowsers.length > 0 && new Set(resolvedBrowsers).size === 1
+        ? resolvedBrowsers[0]
+        : undefined;
+    return configuredBrowser === undefined
+        ? undefined
+        : {
+            requested: configuredBrowser,
+            ...(unanimousResolvedBrowser === undefined ? {} : { resolved: unanimousResolvedBrowser }),
+        };
+}
+function fanoutCost(args) {
+    const { specs, outcomes } = args;
+    // Run-level cost ESTIMATE: one model-token line per lane 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.
+    const costTraces = specs
+        .map((spec, index) => ({ participantId: spec.planned.id, outcome: outcomes?.[index] }))
+        .filter((entry) => entry.outcome?.session !== undefined)
+        .map((entry) => ({ participantId: entry.participantId, trace: entry.outcome.session.trace }));
+    const desktops = (outcomes ?? [])
+        .filter((outcome) => outcome.sandboxId !== undefined)
+        .map((outcome) => ({
+        participantId: outcome.spec.planned.id,
+        minutes: desktopSpanToMinutes(outcome.desktopDurationMs),
+        observation: outcome.desktopResources,
+        lifetimeComplete: outcome.killed,
+    }));
+    const cost = buildRunCostSummary({ participants: costTraces, desktops });
+    return cost;
+}
+function fanoutFeedbackCandidates(args) {
+    const { specs, outcomes, plan } = args;
+    return args.dryRun || args.inProgress === true
+        ? []
+        : participantFeedbackCandidates({
+            runId: args.runId,
+            scenarioId: `cua-${plan.labId}`,
+            adapterId: plan.labId,
+            goal: redactText(specs[0].evidenceInstructions ?? specs[0].instructions),
+            substrate: plan.residual.execution?.target === "local" ? "local-desktop" : "e2b-desktop",
+            participants: specs.map((spec, index) => {
+                const outcome = outcomes?.[index];
+                return {
+                    participantId: spec.planned.id,
+                    streamId: spec.streamId,
+                    personaId: spec.persona.id,
+                    ...(outcome?.session === undefined ? {} : { session: outcome.session }),
+                    ...(outcome?.session === undefined
+                        ? {}
+                        : { traceArtifactPath: spec.traceArtifactPath }),
+                    screenshots: outcome?.screenshots ?? [],
+                    ...(outcome?.commsArtifactPath === undefined
+                        ? {}
+                        : { commsArtifactPath: outcome.commsArtifactPath }),
+                };
+            }),
+        });
+}
+/**
+ * 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
+ * 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
+ * streams. A single-participant run without a rerun never reaches here: buildCuaRunBundle
+ * (bundle.ts) sends it to buildSingleParticipantBundle (single-bundle.ts).
+ */
+export function buildCuaFanoutBundle(args) {
+    const { specs, outcomes, plan } = args;
+    const simulations = [];
+    const streams = [];
+    const events = fanoutPlanEvents(args);
+    let eventSeq = 2;
+    const nextEventId = (suffix) => `event-${String(eventSeq++).padStart(3, "0")}-${suffix}`;
+    if (args.rerun) {
+        events.push({
+            id: nextEventId("fanout-rerun"),
+            at: args.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.`,
+        });
+    }
+    specs.forEach((spec, index) => {
+        const records = fanoutParticipantRecords({ args, nextEventId }, spec, index);
+        simulations.push(records.simulation);
+        streams.push(records.stream);
+        events.push(...records.events);
+    });
+    if (args.failFastReason) {
+        events.push({
+            id: nextEventId("fanout-fail-fast"),
+            at: args.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.`,
+        });
+    }
+    const review = fanoutReview(args, streams);
+    const anyRaw = (outcomes ?? []).some((outcome) => outcome.session?.trace.redaction.screenshots === "raw");
+    const ranLive = (outcomes ?? []).some((outcome) => outcome.session !== undefined || outcome.sessionError !== undefined);
+    const desktopTemplate = e2bDesktopTemplate(plan.residual);
+    const desktopBrowser = fanoutDesktopBrowser(args);
+    const providerResources = (outcomes ?? []).flatMap((outcome) => providerResourcesForOutcome({
+        outcome,
+        createdAt: args.createdAt,
+        ids: outcome.spec,
+        participantId: outcome.spec.planned.id,
+    }));
+    const cost = fanoutCost(args);
+    return {
+        ...bundleHead({
+            ...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}`,
+            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
+            // 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).
+            //
+            // 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}`,
+            sourceDigest: specs[0].persona.promptDigest,
+        },
+        lifecycle: [
+            {
+                at: args.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}).`,
+            },
+        ],
+        simulations,
+        streams,
+        events,
+        ...(args.rerun === undefined ? {} : { rerun: args.rerun }),
+        redaction: {
+            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 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.",
+        },
+        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.
+        feedbackCandidates: fanoutFeedbackCandidates(args),
+        // Selected hosted image, including the optional speech default; omitted on the stock desktop.
+        ...(desktopTemplate === undefined ? {} : { desktopTemplate }),
+        ...(desktopBrowser === undefined ? {} : { desktopBrowser }),
+        ...(providerResources.length === 0 ? {} : { providerResources }),
+        subject: args.aggregateSubject,
+        ...(cost === undefined ? {} : { cost }),
+    };
+}

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

@@ -0,0 +1,15 @@
+import type { RunEvent, RunSimulation } from "../../run/bundle.js";
+import type { RunStream } from "../../run/streams.js";
+import type { CuaFanoutBundleArgs, DesktopParticipantRun } from "./types.js";
+/** What every participant's records share. */
+export interface FanoutParticipantContext {
+    args: CuaFanoutBundleArgs;
+    /** Numbers events in the order they are pushed. */
+    nextEventId: (suffix: string) => string;
+}
+/** One participant's simulation, stream and events, in the order the bundle records them. */
+export declare function fanoutParticipantRecords(ctx: FanoutParticipantContext, spec: DesktopParticipantRun, index: number): {
+    simulation: RunSimulation;
+    stream: RunStream;
+    events: RunEvent[];
+};