humanish 0.106.0 → 0.107.0

package/dist/routes/computer-use/local-vm.d.ts

@@ -1,20 +1,23 @@
-import type { RunLabOptions } from "../../run-lab.js";
+import type { InternalRunLabOptions } from "../../run-lab.js";
 import type { LabConfig } from "../../lab/types.js";
+import type { LocalVmInput } from "./types.js";
 import { type LocalFirecrackerAssets } from "../../substrates/local/firecracker-desktop.js";
-type LocalStudyOptions = RunLabOptions & {
+type LocalVmRunOptions = InternalRunLabOptions & {
     config: LabConfig;
     assets?: LocalFirecrackerAssets;
     signal?: AbortSignal;
 };
-/** A local browser study's bindings, and the cleanup of what its lanes started. */
-export interface LocalVmStudy {
-    /** The caller's runLab options with this study's desktop lane, provider and abort signal. */
-    readonly options: RunLabOptions;
+/** A local browser study's bindings, and the cleanup of what its participants started. */
+export interface LocalVmRun {
+    /** The caller's runLab options, with the account provider when the study runs one. */
+    readonly options: InternalRunLabOptions;
+    /** The desktop, the analysis gate and the abort signal the computer-use run takes. */
+    readonly localVm: LocalVmInput;
     close(): Promise<void>;
 }
 /**
  * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run, or on a hook only an E2B desktop calls.
+ * anything starts on a lab the local study cannot run.
  */
-export declare function prepareLocalVmStudy(options: LocalStudyOptions): LocalVmStudy;
+export declare function prepareLocalVmRun(options: LocalVmRunOptions): LocalVmRun;
 export {};

package/dist/routes/computer-use/local-vm.js

@@ -1,30 +1,16 @@
 import { collectDesktopRecording } from "../../evidence/desktop-recording-artifact.js";
 import path from "node:path";
-import { inboxRecipientFor, PARTICIPANT_DESKTOP, } from "./participant-desktop.js";
-import { HOOK_MEMBERS, withHookOverrides } from "../../lab/bag-overrides.js";
-import { runCuaActorSession } from "../../actors/computer-use/actor.js";
+import { inboxRecipientFor, } from "./participant-desktop.js";
 import { createLocalFirecrackerDesktop, } from "../../substrates/local/firecracker-desktop.js";
 import { localBrowserDefaults, localBrowserUnsupportedReason, } from "../../substrates/local/runtime-config.js";
 import { prepareLocalRuntime } from "../../substrates/local/runtime.js";
+import { dockerCommandLine } from "../../substrates/local/runtime-host.js";
 import { checkRestrictedCodexAnalysisReadiness } from "../../analysis/restricted-codex.js";
 import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
+import { withCloseReport } from "./participant-model.js";
 import { guestMediaConfigSchema } from "../../guest/media-config.js";
 import { startLocalCapturedInbox } from "../../substrates/local/captured-inbox.js";
-// These hooks act on an E2B desktop or the local-tree upload to it. The study runs on a
-// Firecracker desktop and never calls them, so a caller relying on one gets an error up front.
-const e2bDesktopHooks = [
-    "prepareDesktop",
-    "loadDesktopModule",
-    "onRuntimeStreamReady",
-    "packLocalTree",
-];
-function refuseE2BDesktopHooks(hooks) {
-    const present = e2bDesktopHooks.filter((name) => hooks?.[name] !== undefined);
-    if (present.length === 0)
-        return;
-    throw new Error(`A local browser study runs on a Firecracker desktop and does not call ${present.map((name) => `cuaHooks.${name}`).join(", ")}. These hooks apply only to E2B desktops.`);
-}
-function studyMedia(config) {
+function guestMedia(config) {
     const declaredMedia = config.execution?.desktop?.media;
     return declaredMedia === undefined
         ? undefined
@@ -34,7 +20,7 @@ function studyMedia(config) {
         });
 }
 /** The runtime image, prepared once per study on first use, after the account check. */
-function studyAssets(options, account, needsMedia) {
+function guestAssets(options, account, needsMedia) {
     let preparing;
     return () => (preparing ??= (async () => {
         if (account) {
@@ -64,7 +50,7 @@ function mediaEvidence(media) {
         },
     };
 }
-/** One lane's Firecracker desktop and optional captured inbox, released in finalize. */
+/** One participant's Firecracker desktop and optional captured inbox, released in finalize. */
 function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
     const { config, media, recording, state } = context;
     let session;
@@ -132,7 +118,14 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
                 }
                 if (!evidence.released) {
                     state.cleanupUnconfirmed = true;
-                    warnings.push("Local desktop cleanup is unconfirmed.");
+                    const warning = "Local desktop cleanup is unconfirmed.";
+                    warnings.push(warning);
+                    // No receipt names a local VM, so the record carries the command that removes it.
+                    evidence.sandboxRelease = {
+                        state: "unconfirmed",
+                        warning,
+                        recovery: `If container ${session.resourceId} is still listed by \`${dockerCommandLine(["ps"])}\`, remove it with \`${dockerCommandLine(["rm", "--force", "--volumes", session.resourceId])}\`.`,
+                    };
                 }
             })());
         },
@@ -141,40 +134,37 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
 }
 /** The Codex account participant, whose unconfirmed cleanup blocks the study's analysis. */
 function accountProvider(state) {
-    return {
-        async buildProvider({ executor }) {
-            const participant = createRestrictedCodexParticipant({
-                speechEnabled: executor?.speechEnabled === true,
-            });
-            state.participants.push(participant);
-            return Object.assign(participant.provider, {
-                async close() {
-                    if ((await participant.close()).status !== "confirmed") {
-                        state.cleanupUnconfirmed = true;
-                        throw new Error("Local participant cleanup is unconfirmed.");
-                    }
-                },
-            });
-        },
+    return async ({ executor }) => {
+        const participant = createRestrictedCodexParticipant({
+            speechEnabled: executor.speechEnabled === true,
+        });
+        state.participants.push(participant);
+        const provider = Object.assign(participant.provider, {
+            async close() {
+                if ((await participant.close()).status !== "confirmed") {
+                    state.cleanupUnconfirmed = true;
+                    throw new Error("Local participant cleanup is unconfirmed.");
+                }
+            },
+        });
+        // The participant runner reads the session's warnings and late refusal from the same, idempotent close.
+        return withCloseReport(provider, () => participant.close());
     };
 }
 /**
  * Local desktop/provider composition: the options the lab is planned and run with. It throws before
- * anything starts on a lab the local study cannot run, or on a hook only an E2B desktop calls.
+ * anything starts on a lab the local study cannot run.
  */
-export function prepareLocalVmStudy(options) {
+export function prepareLocalVmRun(options) {
     const config = localBrowserDefaults(options.config);
     const unsupported = localBrowserUnsupportedReason(config);
     if (unsupported)
         throw new Error(unsupported);
-    refuseE2BDesktopHooks(options.cuaHooks);
     const recording = config.execution?.desktop?.recording;
-    const media = studyMedia(config);
-    const callerHooks = options.cuaHooks;
+    const media = guestMedia(config);
     // A caller-supplied provider replaces the Codex account participant, so the account is
     // neither checked nor used.
-    const account = config.actors[0]?.type === "local-agent" && callerHooks?.buildProvider === undefined;
-    const baseRunSession = callerHooks?.runSession ?? runCuaActorSession;
+    const account = config.actors[0]?.type === "local-agent" && options.createProvider === undefined;
     const state = { sessions: [], participants: [], cleanupUnconfirmed: false };
     const context = {
         config,
@@ -182,33 +172,16 @@ export function prepareLocalVmStudy(options) {
         signal: options.signal,
         media,
         recording,
-        assets: studyAssets(options, account, media !== undefined || recording !== undefined),
+        assets: guestAssets(options, account, media !== undefined || recording !== undefined),
         state,
     };
     const { config: _config, assets: _assets, signal: _signal, ...runOptions } = options;
     return {
-        options: {
-            ...runOptions,
-            // Wrapped rather than spread for the same reason as cuaHooks below.
-            automaticAnalysis: withHookOverrides(options.automaticAnalysis, HOOK_MEMBERS.analysis, {
-                onStart() {
-                    if (state.cleanupUnconfirmed)
-                        throw new Error("Local study cleanup is unconfirmed.");
-                    return options.automaticAnalysis?.onStart?.();
-                },
-            }),
-            // These overrides go over the caller's hooks so this study's desktop always wins:
-            // participantDesktopOf takes [PARTICIPANT_DESKTOP] before a caller's createDesktopLane.
-            // The caller's bag may be a class instance, so it is wrapped rather than spread.
-            cuaHooks: withHookOverrides(callerHooks, HOOK_MEMBERS.cua, {
-                [PARTICIPANT_DESKTOP]: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),
-                ...(account ? accountProvider(state) : {}),
-                ...(options.signal
-                    ? {
-                        runSession: (input) => baseRunSession({ ...input, signal: options.signal }),
-                    }
-                    : {}),
-            }),
+        options: account ? { ...runOptions, createProvider: accountProvider(state) } : runOptions,
+        localVm: {
+            desktop: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),
+            analysisRefusal: () => state.cleanupUnconfirmed ? "AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED" : undefined,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
         },
         async close() {
             await Promise.allSettled(state.participants.map((participant) => participant.close()));

package/dist/routes/computer-use/participant-desktop.d.ts

@@ -1,5 +1,5 @@
 import type { CuaExecutor } from "../../actors/computer-use/loop.js";
-import type { CuaActorLabHooks, DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
+import type { DesktopParticipantRun, ParticipantRunOutcome } from "./types.js";
 import type { LabCommsEmail, LabCommsRecipient } from "../../lab/types.js";
 import type { PreparedOutputRoot } from "../../run/contained-output.js";
 /** A prepared desktop supplies only participant input/observation and its inbox location. */
@@ -13,10 +13,10 @@ export interface ReadyParticipantDesktop {
 }
 /** Existing bundle fields. Provider-specific facts remain optional and must be measured. */
 export type ParticipantDesktopEvidence = {
-    /** The substrate confirmed the desktop was released (an E2B kill or a local VM shutdown). The lane
+    /** The substrate confirmed the desktop was released (an E2B kill or a local VM shutdown). The participant
      *  outcome records it as `killed`. */
     released: boolean;
-} & Pick<ParticipantRunOutcome, "sandboxId" | "desktopDurationMs" | "desktopResources" | "streamUrlPresent" | "subjectCommit" | "desktopBrowser" | "desktopGeometry" | "stateStepRecords" | "phaseRecords" | "failureCode" | "commsArtifactPath" | "recording">;
+} & Pick<ParticipantRunOutcome, "sandboxId" | "sandboxRelease" | "desktopDurationMs" | "desktopResources" | "streamUrlPresent" | "subjectCommit" | "desktopBrowser" | "desktopGeometry" | "stateStepRecords" | "phaseRecords" | "failureCode" | "commsArtifactPath" | "recording">;
 /**
  * The desktop one participant runs on, owned from preparation through final evidence collection.
  * Call methods sequentially: prepare, openSession, then finalize in a finally block.
@@ -38,26 +38,11 @@ export interface ParticipantDesktop {
 }
 /** Builds one participant's desktop. The factory must not acquire anything; prepare does. */
 export type ParticipantDesktopFactory = (run: DesktopParticipantRun, warnings: string[], artifactRoot: PreparedOutputRoot) => ParticipantDesktop;
-/**
- * The hook-bag member a study that owns its desktops (the local VM study) sets to its factory. A
- * symbol keeps it out of the public CuaActorLabHooks, whose deprecated createDesktopLane takes the
- * flat lane record; withHookOverrides forwards it like any other member of the bag.
- */
-export declare const PARTICIPANT_DESKTOP: unique symbol;
-/** A hook bag that may carry a study's own desktop factory. */
-export type HooksWithParticipantDesktop = CuaActorLabHooks & {
-    readonly [PARTICIPANT_DESKTOP]?: ParticipantDesktopFactory;
-};
-/**
- * The desktop factory a run uses: the study's own, else the caller's deprecated createDesktopLane,
- * given the flat view of each run. Undefined means the route provisions its own desktop.
- */
-export declare function participantDesktopOf(hooks: CuaActorLabHooks): ParticipantDesktopFactory | undefined;
-/** The lane's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A lane told to check an inbox it can never receive into would stall,
+/** The participant's addressed comms recipient, when one exists — the gate AND the address source for the
+ *  inbox instruction (#351). A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
 export declare function inboxRecipientFor(commsEmail: LabCommsEmail, participantId: string): LabCommsRecipient | undefined;
-/** True when a lane has a declared comms recipient WITH an address, so the drain can actually match the
- *  mail the persona will be told to read. Gates the inbox instruction to lanes that can receive mail —
- *  a lane told to check an inbox it can never receive into would just stall. */
+/** True when a participant has a declared comms recipient WITH an address, so the drain can actually match the
+ *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
+ *  mail — a participant told to check an inbox it can never receive into would just stall. */
 export declare function participantHasInboxRecipient(commsEmail: LabCommsEmail, participantId: string): boolean;

package/dist/routes/computer-use/participant-desktop.js

@@ -1,33 +1,13 @@
-import { legacyHookSpecOf } from "./legacy-lane-spec.js";
 import { recipientParticipantId } from "../../lab/parse/comms.js";
-/**
- * The hook-bag member a study that owns its desktops (the local VM study) sets to its factory. A
- * symbol keeps it out of the public CuaActorLabHooks, whose deprecated createDesktopLane takes the
- * flat lane record; withHookOverrides forwards it like any other member of the bag.
- */
-export const PARTICIPANT_DESKTOP = Symbol("humanish.participantDesktop");
-/**
- * The desktop factory a run uses: the study's own, else the caller's deprecated createDesktopLane,
- * given the flat view of each run. Undefined means the route provisions its own desktop.
- */
-export function participantDesktopOf(hooks) {
-    const own = hooks[PARTICIPANT_DESKTOP];
-    if (own !== undefined)
-        return own;
-    const caller = hooks.createDesktopLane;
-    return caller === undefined
-        ? undefined
-        : (run, warnings, artifactRoot) => caller(legacyHookSpecOf(run), warnings, artifactRoot);
-}
-/** The lane's addressed comms recipient, when one exists — the gate AND the address source for the
- *  inbox instruction (#351). A lane told to check an inbox it can never receive into would stall,
+/** The participant's addressed comms recipient, when one exists — the gate AND the address source for the
+ *  inbox instruction (#351). A participant told to check an inbox it can never receive into would stall,
  *  so no addressed recipient means no instruction. */
 export function inboxRecipientFor(commsEmail, participantId) {
     return (commsEmail.recipients ?? []).find((recipient) => recipientParticipantId(recipient) === participantId && recipient.address !== undefined);
 }
-/** True when a lane has a declared comms recipient WITH an address, so the drain can actually match the
- *  mail the persona will be told to read. Gates the inbox instruction to lanes that can receive mail —
- *  a lane told to check an inbox it can never receive into would just stall. */
+/** True when a participant has a declared comms recipient WITH an address, so the drain can actually match the
+ *  mail the persona will be told to read. Gates the inbox instruction to participants that can receive
+ *  mail — a participant told to check an inbox it can never receive into would just stall. */
 export function participantHasInboxRecipient(commsEmail, participantId) {
     return inboxRecipientFor(commsEmail, participantId) !== undefined;
 }

package/dist/routes/computer-use/{lanes.d.ts → participant-execution.d.ts}

@@ -1,6 +1,6 @@
 import { type PreparedOutputRoot } from "../../run/contained-output.js";
 import type { CuaParticipantDeps, CuaParticipantPlan, CuaParticipantResult, DesktopParticipantRun, CuaSubjectProjection, ParticipantRunOutcome } from "./types.js";
-/** Build a lane's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
+/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
  *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
  *  at N>1). */
 export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOutputRoot, spec: {
@@ -10,12 +10,12 @@ export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOut
  * evidence and cleanup; this runner owns the model, trace and participant outcome. */
 export declare function runCuaParticipant(spec: DesktopParticipantRun, deps: CuaParticipantDeps): Promise<ParticipantRunOutcome>;
 /**
- * Run N>1 E2B lanes with bounded concurrency, a pipeline gate (lane 1 provisions before the rest
- * start), and session fail-fast on HARNESS errors only (queued lanes become `blocked` with a
- * pinned reason + a fail-fast event; mission verdicts never trip it). Each lane tears down ITS
- * OWN sandbox by id; nothing here ever enumerates.
+ * Run N>1 E2B participants with bounded concurrency, a pipeline gate (the first provisions
+ * before the rest start), and session fail-fast on HARNESS errors only (queued participants
+ * become `blocked` with a pinned reason + a fail-fast event; mission verdicts never trip it).
+ * Each participant tears down ITS OWN sandbox by id; nothing here ever enumerates.
  *
- * Exported for the #342 total-runner tests: the injectable runner lets a test make one lane
+ * Exported for the #342 total-runner tests: the injectable runner lets a test make one participant
  * THROW (the exact class the guard exists for) without a live sandbox. Production always uses
  * the default.
  */
@@ -23,13 +23,13 @@ export declare function runCuaParticipants(runs: DesktopParticipantRun[], deps:
     outcomes: ParticipantRunOutcome[];
     failFastReason?: string;
 }>;
-/** Project one lane outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
+/** Project one participant outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
 export declare function toParticipantResult(spec: DesktopParticipantRun, outcome: ParticipantRunOutcome | undefined, subject: CuaSubjectProjection, dryRun: boolean): CuaParticipantResult;
 /**
- * Run every lane of a live run. The in-process route drives its single lane in this process; one
- * hosted lane runs alone; a fan-out runs at the plan's concurrency and may stop early.
+ * Run every participant of a live run. The in-process route drives its single participant in this
+ * process; one hosted participant runs alone; a fan-out runs at the plan's concurrency and may stop early.
  */
-export declare function runAllCuaParticipants(runs: readonly DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, participantPlan: CuaParticipantPlan, inProcessRoute: boolean): Promise<{
+export declare function runAllCuaParticipants(runs: readonly DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, participantPlan: CuaParticipantPlan, inProcess: boolean): Promise<{
     outcomes: ParticipantRunOutcome[];
     failFastReason: string | undefined;
 }>;

package/dist/routes/computer-use/{lanes.js → participant-execution.js}

@@ -8,7 +8,7 @@ import { redactText, toErrorMessage } from "../../evidence/redaction.js";
 import { assertSafeOutputPathSegment, writeContainedOutputFile, } from "../../run/contained-output.js";
 import { participantOutcomeOk } from "./participant-facts.js";
 import { closeParticipantModel, judgeParticipantSession, participantSessionOptions, recordParticipantTrace, startParticipantModel, } from "./participant-model.js";
-/** Build a lane's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
+/** Build a participant's writeScreenshot closure: writes under screenshots/<screenshotDir>/ and records
  *  the relative path the trace references (screenshots/<name> at N=1; screenshots/<laneId>/<name>
  *  at N>1). */
 export function makeParticipantWriteScreenshot(artifactRoot, spec, screenshots) {
@@ -30,7 +30,7 @@ export function makeParticipantWriteScreenshot(artifactRoot, spec, screenshots)
         return rel;
     };
 }
-/** A blocked lane outcome (pipeline gate / fail-fast skipped it before it ran). */
+/** A blocked participant outcome (pipeline gate / fail-fast skipped it before it ran). */
 function skippedOutcome(spec, reason) {
     return {
         spec,
@@ -57,6 +57,7 @@ export async function runCuaParticipant(spec, deps) {
     let session;
     let sessionError;
     let providerCleanupError;
+    let providerPolicyError;
     let provisioned = false;
     let signaled = false;
     const signal = (ok) => {
@@ -71,7 +72,7 @@ export async function runCuaParticipant(spec, deps) {
         await desktop.prepare();
         const ready = await desktop.openSession();
         model = await startParticipantModel(spec, deps, ready.executor);
-        // World is ready: release the pipeline gate so the remaining lanes may start.
+        // World is ready: release the pipeline gate so the remaining participants may start.
         provisioned = true;
         signal(true);
         session = await deps.runSession(participantSessionOptions(spec, deps, ready, model.provider, writeScreenshot));
@@ -82,25 +83,35 @@ export async function runCuaParticipant(spec, deps) {
     finally {
         // A provider whose cleanup is unconfirmed fails the run as an execution, apart from how the
         // session ended: a session that passed stays a passed participant.
-        if (await closeParticipantModel(model, warnings)) {
+        const closed = await closeParticipantModel(model, warnings);
+        if (closed.unconfirmed)
             providerCleanupError = "Model provider cleanup is unconfirmed.";
-        }
+        // The session's evidence would read clean, so a late refusal fails the run as an execution.
+        if (closed.refusal !== undefined)
+            providerPolicyError = redactText(deps.scrubKnownValues(closed.refusal === "codex_tool_call"
+                ? `Codex reported a disallowed item after the participant's last request (${closed.refusal}).`
+                : `Codex output after the participant's last request could not be checked against the item policy (${closed.refusal}).`));
         try {
             if (!provisioned)
                 signal(false);
         }
         finally {
             await desktop.finalize({
-                failed: sessionError !== undefined || providerCleanupError !== undefined || session === undefined,
+                failed: sessionError !== undefined ||
+                    providerCleanupError !== undefined ||
+                    providerPolicyError !== undefined ||
+                    session === undefined,
             });
         }
     }
     if (session)
         await recordParticipantTrace(spec, deps, session, warnings);
     const { noEngagement, selfReportedBlocker, reportedFriction } = judgeParticipantSession(session, deps, warnings);
-    // A provider-cleanup failure still trips fail-fast and counts in the lane summary's harness errors.
+    // A provider-cleanup or provider-policy failure still trips fail-fast and counts in the
+    // participant summary's harness errors.
     const harnessError = sessionError !== undefined ||
         providerCleanupError !== undefined ||
+        providerPolicyError !== undefined ||
         session?.completionReason === "harness_error";
     const { released, ...desktopEvidence } = desktop.snapshot();
     return {
@@ -108,6 +119,7 @@ export async function runCuaParticipant(spec, deps) {
         ...(session ? { session } : {}),
         ...(sessionError === undefined ? {} : { sessionError }),
         ...(providerCleanupError === undefined ? {} : { providerCleanupError }),
+        ...(providerPolicyError === undefined ? {} : { providerPolicyError }),
         ...desktopEvidence,
         killed: released,
         screenshots,
@@ -119,12 +131,12 @@ export async function runCuaParticipant(spec, deps) {
     };
 }
 /**
- * Run N>1 E2B lanes with bounded concurrency, a pipeline gate (lane 1 provisions before the rest
- * start), and session fail-fast on HARNESS errors only (queued lanes become `blocked` with a
- * pinned reason + a fail-fast event; mission verdicts never trip it). Each lane tears down ITS
- * OWN sandbox by id; nothing here ever enumerates.
+ * Run N>1 E2B participants with bounded concurrency, a pipeline gate (the first provisions
+ * before the rest start), and session fail-fast on HARNESS errors only (queued participants
+ * become `blocked` with a pinned reason + a fail-fast event; mission verdicts never trip it).
+ * Each participant tears down ITS OWN sandbox by id; nothing here ever enumerates.
  *
- * Exported for the #342 total-runner tests: the injectable runner lets a test make one lane
+ * Exported for the #342 total-runner tests: the injectable runner lets a test make one participant
  * THROW (the exact class the guard exists for) without a live sandbox. Production always uses
  * the default.
  */
@@ -136,8 +148,9 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
         resolveGate = resolve;
         rejectGate = () => reject(new Error("gate"));
     });
-    // The gate is rejected on lane-0 provisioning failure; swallow the unhandled rejection if no
-    // later lane ever awaits it (concurrency could let lane 0 finish alone).
+    // The gate is rejected on the first participant's provisioning failure; swallow the unhandled
+    // rejection if no later participant ever awaits it (concurrency could let the first finish
+    // alone).
     gate.catch(() => undefined);
     const outcomes = await mapWithConcurrency(runs, concurrency, async (spec, index) => {
         if (index > 0) {
@@ -151,8 +164,8 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
         if (failFast.tripped) {
             return skippedOutcome(spec, `skipped: ${failFast.reason}`);
         }
-        // The lane runner is TOTAL (#342): every exit path returns a recorded outcome. Without this
-        // guard, one lane's late throw (e.g. its trace write hitting ENOSPC after its own sandbox was
+        // The participant runner is TOTAL (#342): every exit path returns a recorded outcome. Without this
+        // guard, one participant's late throw (e.g. its trace write hitting ENOSPC after its own sandbox was
         // already torn down) rejected the whole map while sibling workers kept launching sandboxes
         // nobody would ever record — the run spent money and then reported nothing.
         let outcome;
@@ -174,7 +187,7 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
             });
         }
         catch (error) {
-            // Lane 0 may have thrown before signaling the provisioning gate — release the followers as
+            // The first participant may have thrown before signaling the provisioning gate — release the followers as
             // blocked rather than leaving them awaiting a gate that will never settle.
             if (index === 0)
                 rejectGate?.();
@@ -202,7 +215,7 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
     });
     return { outcomes, ...(failFast.tripped ? { failFastReason: failFast.reason } : {}) };
 }
-/** Project one lane outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
+/** Project one participant outcome (or a dry-run contract spec) into the public CuaParticipantResult. */
 export function toParticipantResult(spec, outcome, subject, dryRun) {
     const base = {
         id: spec.planned.id,
@@ -302,11 +315,11 @@ export function toParticipantResult(spec, outcome, subject, dryRun) {
     };
 }
 /**
- * Run every lane of a live run. The in-process route drives its single lane in this process; one
- * hosted lane runs alone; a fan-out runs at the plan's concurrency and may stop early.
+ * Run every participant of a live run. The in-process route drives its single participant in this
+ * process; one hosted participant runs alone; a fan-out runs at the plan's concurrency and may stop early.
  */
-export async function runAllCuaParticipants(runs, deps, participantPlan, inProcessRoute) {
-    if (inProcessRoute) {
+export async function runAllCuaParticipants(runs, deps, participantPlan, inProcess) {
+    if (inProcess) {
         // The caller's executor stands in for a desktop, and the shared runner drives the participant.
         const outcome = await runCuaParticipant(runs[0], {
             ...deps,

package/dist/routes/computer-use/participant-facts.d.ts

@@ -1,6 +1,12 @@
-import { type ParticipantFacts } from "../../run/judge.js";
+import { type ExecutionFailure, type ParticipantFacts } from "../../run/judge.js";
 import type { ParticipantRunOutcome } from "./types.js";
 /** A participant outcome's facts for the judge. */
 export declare function participantFactsOf(outcome: ParticipantRunOutcome): ParticipantFacts;
 /** Whether a participant passed. A dry-run participant passes as a contract. */
 export declare function participantOutcomeOk(outcome: ParticipantRunOutcome | undefined, dryRun: boolean): boolean;
+/**
+ * One sandbox-cleanup failure per participant desktop not confirmed released: an E2B sandbox that
+ * was not killed, or a desktop whose release says why (a local VM names its container). A
+ * participant that never acquired a desktop (skipped, in-process) adds none.
+ */
+export declare function unreleasedSandboxFailures(outcomes: readonly ParticipantRunOutcome[] | undefined, runId: string): ExecutionFailure[];

package/dist/routes/computer-use/participant-facts.js

@@ -1,7 +1,7 @@
 // A participant run outcome's facts for the judge (src/run/judge.ts), and the pass check built on
 // them. The bundle builders, the result, the participant runner and shared-world all read these,
 // so they sit in a file that imports only the judge and the types.
-import { participantPassed } from "../../run/judge.js";
+import { participantPassed, sandboxCleanupFailure, } from "../../run/judge.js";
 /** A participant outcome's facts for the judge. */
 export function participantFactsOf(outcome) {
     return {
@@ -20,3 +20,14 @@ export function participantOutcomeOk(outcome, dryRun) {
         return true;
     return outcome !== undefined && participantPassed(participantFactsOf(outcome));
 }
+/**
+ * One sandbox-cleanup failure per participant desktop not confirmed released: an E2B sandbox that
+ * was not killed, or a desktop whose release says why (a local VM names its container). A
+ * participant that never acquired a desktop (skipped, in-process) adds none.
+ */
+export function unreleasedSandboxFailures(outcomes, runId) {
+    return (outcomes ?? [])
+        .filter((outcome) => outcome.sandboxRelease !== undefined ||
+        (outcome.sandboxId !== undefined && !outcome.killed))
+        .map((outcome) => sandboxCleanupFailure(outcome.spec.planned.id, outcome.sandboxRelease?.warning, runId, outcome.sandboxRelease?.recovery));
+}

package/dist/routes/computer-use/participant-model.d.ts

@@ -1,28 +1,36 @@
 import type { CuaExecutor, CuaLoopResult, CuaProvider } from "../../actors/computer-use/loop.js";
 import type { CuaActorSessionOptions } from "../../actors/computer-use/actor.js";
 import { startClaudeSession } from "../../actors/local-agent/claude-session.js";
-import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
-import type { CuaParticipantDeps, CuaRunBudget, DesktopParticipantRun } from "./types.js";
+import { createRestrictedCodexParticipant, type ParticipantProviderCloseResult } from "../../actors/codex/restricted-participant.js";
+import type { ParticipantModelDeps, CuaRunBudget, DesktopParticipantRun } from "./types.js";
 import type { ReadyParticipantDesktop } from "./participant-desktop.js";
-/** The model a lane brings besides the default API client, and the handles its cleanup needs. */
+/**
+ * Registers a caller's provider as backed by a native Codex session: the participant runner reads the session's
+ * run warnings and a refusal no request reported from `report` when it closes the provider.
+ */
+export declare function withCloseReport<T extends CuaProvider>(provider: T, report: () => Promise<ParticipantProviderCloseResult>): T;
+/** The model a participant brings besides the default API client, and the handles its cleanup needs. */
 export interface ParticipantModel {
     provider?: CuaProvider;
     codexParticipant?: ReturnType<typeof createRestrictedCodexParticipant>;
     claudeSession?: Awaited<ReturnType<typeof startClaudeSession>>;
 }
-/** Starts the lane's model: a caller's provider, the operator's Codex, a Claude session, or none. */
-export declare function startParticipantModel(spec: DesktopParticipantRun, deps: CuaParticipantDeps, executor: CuaExecutor): Promise<ParticipantModel>;
-/** The options the lane's session runs with: prompt, model settings, spend caps and callbacks. */
-export declare function participantSessionOptions(spec: DesktopParticipantRun, deps: CuaParticipantDeps, ready: ReadyParticipantDesktop, provider: CuaProvider | undefined, writeScreenshot: NonNullable<CuaActorSessionOptions["writeScreenshot"]>): CuaActorSessionOptions;
+/** Starts the participant's model: a caller's provider, the operator's Codex, a Claude session, or none. */
+export declare function startParticipantModel(spec: DesktopParticipantRun, deps: ParticipantModelDeps, executor: CuaExecutor): Promise<ParticipantModel>;
+/** The options the participant's session runs with: prompt, model settings, spend caps and callbacks. */
+export declare function participantSessionOptions(spec: DesktopParticipantRun, deps: ParticipantModelDeps, ready: ReadyParticipantDesktop, provider: CuaProvider | undefined, writeScreenshot: NonNullable<CuaActorSessionOptions["writeScreenshot"]>): CuaActorSessionOptions;
 /**
- * Closes the lane's model, in the order it was opened. Returns true when a provider's cleanup is
+ * Closes the participant's model, in the order it was opened. Returns true when a provider's cleanup is
  * unconfirmed; each failure also adds a warning.
  */
-export declare function closeParticipantModel(model: ParticipantModel, warnings: string[]): Promise<boolean>;
+export declare function closeParticipantModel(model: ParticipantModel, warnings: string[]): Promise<{
+    unconfirmed: boolean;
+    refusal: string | undefined;
+}>;
 /** Prices the finished session's tokens onto its trace, writes the trace, and warns on raw screenshots. */
-export declare function recordParticipantTrace(spec: DesktopParticipantRun, deps: CuaParticipantDeps, session: CuaLoopResult, warnings: string[]): Promise<void>;
+export declare function recordParticipantTrace(spec: DesktopParticipantRun, deps: ParticipantModelDeps, session: CuaLoopResult, warnings: string[]): Promise<void>;
 /** The checks that keep a goal_satisfied session from counting as a pass, with their warnings. */
-export declare function judgeParticipantSession(session: CuaLoopResult | undefined, deps: CuaParticipantDeps, warnings: string[]): {
+export declare function judgeParticipantSession(session: CuaLoopResult | undefined, deps: ParticipantModelDeps, warnings: string[]): {
     noEngagement: boolean;
     selfReportedBlocker: boolean;
     reportedFriction: boolean;