humanish 0.106.1 → 0.107.0

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;

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

@@ -1,30 +1,36 @@
-// The model side of one computer-use lane: the provider a local agent brings, the session options
+// The model side of one computer-use participant: the provider a local agent brings, the session options
 // the loop runs with, the study's shared spend ledger, the provider cleanup, and the checks on the
-// finished session. The desktop side stays with the lane runner.
+// finished session. The desktop side stays with the participant runner.
 import { startClaudeSession } from "../../actors/local-agent/claude-session.js";
 import { createLocalAgentProvider } from "../../actors/local-agent/cli.js";
 import { pricedModel } from "../../lab/plan-base.js";
 import { estimateActorCostForExecution, round6 } from "../../run/pricing.js";
 import { redactText } from "../../evidence/redaction.js";
-import { createRestrictedCodexParticipant } from "../../actors/codex/restricted-participant.js";
+import { createRestrictedCodexParticipant, } from "../../actors/codex/restricted-participant.js";
 import { writeContainedOutputFile } from "../../run/contained-output.js";
 import { withInboxMission } from "./participant-prompt.js";
 import { resolveSelfReportedBlocker, resolveSelfReportedFriction, sessionEnding, } from "./self-report.js";
 import { hollowCompletion } from "../../run/judge.js";
-import { legacyHookSpecOf } from "./legacy-lane-spec.js";
-/** Starts the lane's model: a caller's provider, the operator's Codex, a Claude session, or none. */
+// Caller providers backed by a native Codex session (the local study's), with their close report.
+const closeReports = new WeakMap();
+/**
+ * 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 function withCloseReport(provider, report) {
+    closeReports.set(provider, report);
+    return provider;
+}
+/** Starts the participant's model: a caller's provider, the operator's Codex, a Claude session, or none. */
 export async function startParticipantModel(spec, deps, executor) {
-    const { config, env, brain } = deps;
-    if (deps.hooks.buildProvider) {
-        return {
-            provider: await deps.hooks.buildProvider({
-                config,
-                actor: deps.descriptor,
-                lane: legacyHookSpecOf(spec),
-                laneCount: deps.participantCount,
-                executor,
-            }),
+    const { env, brain } = deps;
+    if (deps.createProvider) {
+        const participant = {
+            id: spec.planned.id,
+            index: spec.planned.index,
+            count: deps.participantCount,
         };
+        return { provider: await deps.createProvider(participant, executor) };
     }
     const localAgent = brain.kind === "local-agent" ? brain.agent : undefined;
     if (localAgent === "codex") {
@@ -73,16 +79,15 @@ export async function startParticipantModel(spec, deps, executor) {
     }
     return {};
 }
-/** The options the lane's session runs with: prompt, model settings, spend caps and callbacks. */
+/** The options the participant's session runs with: prompt, model settings, spend caps and callbacks. */
 export function participantSessionOptions(spec, deps, ready, provider, writeScreenshot) {
-    const { config } = deps;
     const { executor, inbox } = ready;
     // The FAIL-CLOSED spend cap (execution.caps.maxUsd) is wired into the loop as maxUsd + an
     // injected pure per-turn estimator keyed on the resolved model. Preflight already refused a
     // cap on an unpriced model, so the estimate is measurable whenever a cap is in force. The
     // model id here matches provider.version (openai-responses-cu resolves the default when unset).
     const capModelId = pricedModel(deps.brain);
-    const maxUsd = config.execution?.caps?.maxUsd;
+    const maxUsd = deps.caps.maxUsd;
     return {
         instructions: inbox
             ? withInboxMission(spec, inbox.url, inbox.address, inbox.receiving).instructions
@@ -96,7 +101,8 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         openai: {
             apiKey: deps.openaiApiKey,
             ...(deps.brain.declaredModel ? { model: deps.brain.declaredModel } : {}),
-            // Per-LANE, not per-actor: two lanes at different efforts is the control this exists for.
+            // Per-participant, not per-actor: two participants at different efforts is the control this
+            // exists for.
             ...(spec.planned.limits.reasoningEffort === undefined
                 ? {}
                 : { reasoningEffort: spec.planned.limits.reasoningEffort }),
@@ -123,8 +129,9 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
             : { stopWhen: spec.planned.limits.stopWhen }),
         ...(spec.planned.limits.dwell === undefined ? {} : { dwell: spec.planned.limits.dwell }),
         ...(spec.planned.tasks === undefined ? {} : { tasks: spec.planned.tasks }),
-        // The STUDY budget (#299): this lane notes its own running estimate on the shared ledger
-        // and stops when the RUN total crosses the cap — independent of the per-lane maxUsd above.
+        // The STUDY budget (#299): this participant notes its own running estimate on the shared
+        // ledger and stops when the RUN total crosses the cap — independent of the per-participant
+        // maxUsd above.
         ...(deps.runBudget === undefined
             ? {}
             : {
@@ -142,18 +149,19 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         ...(deps.onTrace === undefined
             ? {}
             : {
-                // Forwards the RUNNING usage as well: the lane is where both are known, and usage
+                // Forwards the RUNNING usage as well: the participant runner is where both are known, and usage
                 // without it never reaches the flush — which is how the live cost stayed unknown.
                 onTrace: (items, usage, metadata) => deps.onTrace?.(spec.planned.id, items, usage, metadata),
             }),
     };
 }
 /**
- * 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 async function closeParticipantModel(model, warnings) {
     let unconfirmed = false;
+    let refusal;
     try {
         if (model.codexParticipant === undefined)
             await model.provider?.close?.();
@@ -164,6 +172,8 @@ export async function closeParticipantModel(model, warnings) {
     }
     try {
         const cleanup = await model.codexParticipant?.close();
+        warnings.push(...(cleanup?.warnings ?? []));
+        refusal = cleanup?.refusal;
         if (cleanup?.status === "unconfirmed") {
             warnings.push("Model provider cleanup is unconfirmed.");
             unconfirmed = true;
@@ -173,17 +183,31 @@ export async function closeParticipantModel(model, warnings) {
         warnings.push("Model provider cleanup is unconfirmed.");
         unconfirmed = true;
     }
+    const report = model.codexParticipant === undefined && model.provider !== undefined
+        ? closeReports.get(model.provider)
+        : undefined;
+    if (report) {
+        // The provider's own close reported cleanup above; this reads what its session found.
+        try {
+            const found = await report();
+            warnings.push(...(found.warnings ?? []));
+            refusal ??= found.refusal;
+        }
+        catch {
+            /* Cleanup was already reported through the provider's close. */
+        }
+    }
     try {
         await model.claudeSession?.close();
     }
     catch {
         warnings.push("Claude session cleanup failed; desktop cleanup will still run.");
     }
-    return unconfirmed;
+    return { unconfirmed, refusal };
 }
 /** Prices the finished session's tokens onto its trace, writes the trace, and warns on raw screenshots. */
 export async function recordParticipantTrace(spec, deps, session, warnings) {
-    // Per-lane model-token cost ESTIMATE, attached to the trace before it is persisted (the model
+    // Per-participant model-token cost ESTIMATE, attached to the trace before it is persisted (the model
     // id is authoritative here — provider.version). Kept at the lab boundary so the pure loop
     // never depends on the operator rate table. estimateActorCost declares absent (null) for an
     // unknown rate / missing usage rather than guessing.

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

@@ -15,8 +15,8 @@ export declare const DEFAULT_MISSION = "You are testing a web application. The b
 export declare const CLOSING_LINE_DIRECTIVE: string;
 /** The persona id a computer-use participant gets when neither it nor its actor names one. */
 export declare const FALLBACK_PERSONA_ID = "cua-operator";
-/** Compose one lane's actor prompt: persona line + device line + mission + per-lane steer.
- *  At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
+/** Compose one participant's actor prompt: persona line + device line + mission + per-participant
+ *  steer. At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
 export declare function composeParticipantInstructions(args: {
     mission: string;
     persona?: string;
@@ -46,7 +46,7 @@ export declare function composeParticipantInstructions(args: {
     instructions: string;
     persona: ActorPersonaRef;
 };
-/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
+/** Runtime-inject the persona inbox instruction into a participant's prompt (#297 slice B). The inbox URL is a
  *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
  *  augments only the instructions the model receives; the authored prompt + its digest are unchanged.
  *  Returns a new spec (never mutates). Shared by the CUA + concurrent shared-world routes. */

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

@@ -19,8 +19,8 @@ export const CLOSING_LINE_DIRECTIVE = "When you stop, make the FIRST line of you
     "Then, from the next line, say what you did, what confused you, and where you hesitated.";
 /** The persona id a computer-use participant gets when neither it nor its actor names one. */
 export const FALLBACK_PERSONA_ID = "cua-operator";
-/** Compose one lane's actor prompt: persona line + device line + mission + per-lane steer.
- *  At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
+/** Compose one participant's actor prompt: persona line + device line + mission + per-participant
+ *  steer. At N=1 (homogeneous, no roster) this reproduces the prior composeInstructions byte-for-byte. */
 export function composeParticipantInstructions(args) {
     const { name, preset } = args.device;
     const deviceLine = preset.isMobile
@@ -31,7 +31,7 @@ export function composeParticipantInstructions(args) {
     // be measured optimizes for the measurement instead of using the product (src/lab/tasks.ts).
     const taskLines = renderTaskPrompt(args.tasks ?? []);
     // A resolved persona contributes its compiled directives (friction tolerance, skill bias,
-    // accessibility behavior, constraints) through the SAME persona.ts compiler the terminal lane
+    // accessibility behavior, constraints) through the SAME persona.ts compiler the terminal route
     // uses, so one persona file means one behavior across every route.
     const personaLine = args.resolvedPersona
         ? renderPersonaPromptSection(args.resolvedPersona)
@@ -64,7 +64,7 @@ export function composeParticipantInstructions(args) {
         },
     };
 }
-/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
+/** Runtime-inject the persona inbox instruction into a participant's prompt (#297 slice B). The inbox URL is a
  *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
  *  augments only the instructions the model receives; the authored prompt + its digest are unchanged.
  *  Returns a new spec (never mutates). Shared by the CUA + concurrent shared-world routes. */