humanish 0.106.1 → 0.108.0

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,13 +131,13 @@ 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
- * THROW (the exact class the guard exists for) without a live sandbox. Production always uses
+ * Exported for the 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.
  */
 export async function runCuaParticipants(runs, deps, concurrency, runParticipant = runCuaParticipant) {
@@ -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,10 +164,10 @@ 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: 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.
+        // nobody would ever record, so the run spent money and then reported nothing.
         let outcome;
         try {
             outcome = await runParticipant(spec, {
@@ -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,
@@ -234,7 +247,7 @@ export function toParticipantResult(spec, outcome, subject, dryRun) {
             ok: false,
             diagnostics: cuaParticipantDiagnostics({ dryRun, skipped: true }),
             skippedReason: outcome.skippedReason,
-            error: { code: "HUMANISH_CUA_LAB_FAILED", message: outcome.skippedReason },
+            error: { code: "HUMANISH_COMPUTER_USE_FAILED", message: outcome.skippedReason },
         };
     }
     const session = outcome.session;
@@ -286,7 +299,7 @@ export function toParticipantResult(spec, outcome, subject, dryRun) {
             ? {}
             : {
                 error: {
-                    code: outcome.failureCode ?? "HUMANISH_CUA_LAB_FAILED",
+                    code: outcome.failureCode ?? "HUMANISH_COMPUTER_USE_FAILED",
                     message: outcome.sessionError ??
                         (outcome.noEngagement
                             ? "Actor took no actions and produced no message (likely a blank/still-loading screen); not a credible goal_satisfied."
@@ -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,42 @@
 import type { CuaExecutor, CuaLoopResult, CuaProvider } from "../../actors/computer-use/loop.js";
+import type { ActorConversation } from "../../actors/contract.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 run warning for a participant whose provider kept no conversation server-side, so humanish
+ * carried it on every request. It says why, and how many early turns became a text summary.
+ */
+export declare function explicitContextWarning(conversation: ActorConversation): string;
 /** 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") {
@@ -43,10 +49,10 @@ export async function startParticipantModel(spec, deps, executor) {
         return { provider: codexParticipant.provider, codexParticipant };
     }
     if (localAgent === "claude") {
-        // One session for the whole run, like the codex thread above (#520). The one-shot
+        // One session for the whole run, like the codex thread above. The one-shot
         // provider (createLocalAgentProvider) spawned `claude -p` per turn, and every turn
         // started with no memory of the last. HUMANISH_LOCAL_AGENT_ONE_SHOT=1 keeps that path
-        // reachable as a MEASUREMENT switch: MemTrapBench (2026-08) reports memory frameworks
+        // reachable as a measurement switch: MemTrapBench (2026-08) reports memory frameworks
         // degrading agent performance by 10-40% on some tasks, so "remembers" has to be measured
         // against "does not" on the same lab, not assumed. The trace records which one ran.
         const oneShot = env.HUMANISH_LOCAL_AGENT_ONE_SHOT !== undefined &&
@@ -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
+    // 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
@@ -90,13 +95,14 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         persona: spec.persona,
         timeoutMs: deps.timeoutMs,
         // The brain is either a keyed API client or a CLI the operator is already signed in to.
-        // Everything below this line — loop, executor, trace, affordances — is identical either
+        // Everything below this line (loop, executor, trace, affordances) is identical either
         // way, which is what makes a local-agent run comparable to an API one.
         ...(provider === undefined ? {} : { provider: provider }),
         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: 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
-                // without it never reaches the flush — which is how the live cost stayed unknown.
+                // 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,37 +183,69 @@ 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
-    // id is authoritative here — provider.version). Kept at the lab boundary so the pure loop
+    // 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.
     session.trace.estimatedCost = estimateActorCostForExecution(session.trace.tokenUsage, session.trace.ids.model, session.trace.executionProfile);
     await writeContainedOutputFile(deps.artifactRoot, spec.traceArtifactPath, `${JSON.stringify(session.trace, null, 2)}\n`, "utf8");
+    const conversation = session.trace.conversation;
+    if (conversation?.mode === "explicit_context")
+        warnings.push(explicitContextWarning(conversation));
     if (session.trace.redaction.screenshots === "raw") {
-        warnings.push("Screenshots are full-fidelity (raw) for local use — the bundle stays in gitignored .humanish and nothing scans these pixels; review them before sharing anywhere. Set policies.redactScreenshots: true to blur a share-as-is bundle.");
+        warnings.push("Screenshots are unblurred for local use: the bundle stays in the gitignored .humanish/ folder and nothing scans these pixels, so review them before sharing. Set policies.redactScreenshots: true to blur screenshots in a bundle you plan to share.");
     }
 }
+/**
+ * The run warning for a participant whose provider kept no conversation server-side, so humanish
+ * carried it on every request. It says why, and how many early turns became a text summary.
+ */
+export function explicitContextWarning(conversation) {
+    const why = conversation.explicitReason === "zdr_rejection"
+        ? `The OpenAI organization rejected server-side conversation state (zero data retention)${conversation.switchedAtRequest === undefined
+            ? ""
+            : ` on request ${conversation.switchedAtRequest}`}`
+        : "zeroDataRetention is set";
+    const summarized = conversation.summarizedTurns === 0
+        ? ""
+        : ` To stay within its token budget it summarized the ${conversation.summarizedTurns} oldest turns as text and dropped their screenshots.`;
+    return `${why}, so humanish carried this participant's conversation itself (explicit_context).${summarized} The trace's conversation record has each request's carried context.`;
+}
 /** The checks that keep a goal_satisfied session from counting as a pass, with their warnings. */
 export function judgeParticipantSession(session, deps, warnings) {
     const noEngagement = session !== undefined && hollowCompletion(sessionEnding(session));
     if (noEngagement) {
-        warnings.push("Actor returned goal_satisfied with ZERO actions and ZERO messages — it likely saw a blank or still-loading screen and stopped without engaging. NOT counted as a pass. Check the screenshot; raise execution.timeoutMs or confirm the subject painted before the first turn.");
+        warnings.push("The participant returned goal_satisfied with no actions and no messages, so it likely saw a blank or loading screen and stopped. This does not count as a pass. Check the screenshot, and raise execution.timeoutMs or confirm the app had rendered before the first turn.");
     }
     const blockerReason = resolveSelfReportedBlocker(session);
     const selfReportedBlocker = blockerReason !== undefined;
     const reportedFriction = resolveSelfReportedFriction(session) !== undefined;
     if (selfReportedBlocker) {
-        warnings.push(`Actor returned goal_satisfied while its final message describes a blocker or asks for missing instructions — NOT counted as a pass: ${redactText(deps.scrubKnownValues(blockerReason))}`);
+        warnings.push(`The participant returned goal_satisfied, but its final message describes a blocker or asks for missing instructions, so this does not count as a pass: ${redactText(deps.scrubKnownValues(blockerReason))}`);
     }
     return { noEngagement, selfReportedBlocker, reportedFriction };
 }

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

@@ -5,7 +5,7 @@ import { type LabTask } from "../../lab/tasks.js";
 import type { DesktopParticipantRun } from "./types.js";
 export declare const DEFAULT_MISSION = "You are testing a web application. The browser is already open at the subject URL. Explore it, accomplish what the scenario asks, and stop when done.";
 /**
- * The participant's outcome as ONE fixed first line of its last message (#570, second half). The
+ * The participant's outcome as one fixed first line of its last message. The
  * free-text computer-use provider has no schema to fill; a fixed line is the next best thing, and
  * the loop reads it into the trace's declaredOutcome. Prompt-only control is weak in general, so
  * adherence is measured (declaredOutcome present or absent on the trace) and the regex over the
@@ -15,30 +15,30 @@ 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;
     instruction?: string;
-    /** The lab's declared protocol (#414). Only the participant-facing `goal` halves are rendered
+    /** The lab's declared protocol. Only the participant-facing `goal` halves are rendered
      *  into the prompt; the `success` criteria never appear here. */
     tasks?: readonly LabTask[];
     device: {
         name: string;
         preset: DevicePreset;
     };
-    /** The COMPILED persona for `args.persona`, when its committed file resolved (#381). Supplying it
-     *  makes the persona shape behavior — its traits become directives in the prompt and land in
-     *  traitsApplied — instead of appearing as a bare `Persona: <id>.` label. Absent (unsafe id,
-     *  no committed file, unparseable YAML) keeps the honest fallback: the bare line and an EMPTY
+    /** The compiled persona for `args.persona`, when its committed file resolved. Supplying it
+     *  makes the persona shape behavior: its traits become directives in the prompt and land in
+     *  traitsApplied, instead of appearing as a bare `Persona: <id>.` label. Absent (unsafe id,
+     *  no committed file, unparseable YAML) keeps the fallback: the bare line and an empty
      *  traitsApplied, never fabricated traits. Resolved by the caller so this stays pure. */
     resolvedPersona?: ResolvedPersona;
     /**
-     * desktop-cli (#495): the surface under study is a terminal window, not a page. Said plainly
-     * because a participant whose every prior world was a browser will look for one — and because a
+     * desktop-cli: the surface under study is a terminal window, not a page. Said plainly
+     * because a participant whose every prior world was a browser will look for one, and because a
      * capability nobody declares is one the recording cannot later be read against. It states that a
-     * terminal is open and NOT what to type in it: naming commands would answer the question the
+     * terminal is open and does not say what to type in it: naming commands would answer the question the
      * study is asking.
      */
     surface?: "desktop-cli";
@@ -46,8 +46,8 @@ 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 loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
+/** Runtime-inject the persona inbox instruction into a participant's prompt. 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. */
 export declare function withInboxMission(spec: DesktopParticipantRun, inboxUrl: string, address?: string, receiving?: boolean): DesktopParticipantRun;

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

@@ -7,7 +7,7 @@ import { personaBrief, personaToDirectives, renderPersonaPromptSection, } from "
 import { renderTaskPrompt } from "../../lab/tasks.js";
 export const DEFAULT_MISSION = "You are testing a web application. The browser is already open at the subject URL. Explore it, accomplish what the scenario asks, and stop when done.";
 /**
- * The participant's outcome as ONE fixed first line of its last message (#570, second half). The
+ * The participant's outcome as one fixed first line of its last message. The
  * free-text computer-use provider has no schema to fill; a fixed line is the next best thing, and
  * the loop reads it into the trace's declaredOutcome. Prompt-only control is weak in general, so
  * adherence is measured (declaredOutcome present or absent on the trace) and the regex over the
@@ -19,19 +19,19 @@ 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
         ? `You are a mobile user on a ${name} device (${preset.width}x${preset.height} @${preset.deviceScaleFactor}x). Expect a mobile/touch layout.`
         : `You are a desktop user (${name}, ${preset.width}x${preset.height}).`;
-    // The protocol as the PARTICIPANT reads it: numbered goals, nothing else. The success criteria
-    // are the researcher's instrument and must never reach this prompt — a persona told how it will
+    // The protocol as the participant reads it: numbered goals, nothing else. The success criteria
+    // are the researcher's instrument and must never reach this prompt: a persona told how it will
     // 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,8 +64,8 @@ export function composeParticipantInstructions(args) {
         },
     };
 }
-/** Runtime-inject the persona inbox instruction into a lane's prompt (#297 slice B). The inbox URL is a
- *  runtime loopback/getHost address (not secret), so — mirroring the lobby-code runtime injection — this
+/** Runtime-inject the persona inbox instruction into a participant's prompt. 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. */
 export function withInboxMission(spec, inboxUrl, address, receiving = false) {