humanish 0.107.0 → 0.108.0

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

@@ -41,7 +41,7 @@ function fanoutParticipantView(args, spec, index) {
         : (outcome?.skippedReason ??
             session?.reason ??
             outcome?.sessionError ??
-            "Contract bundle only: dry-run produced the evidence shape without launching a desktop or spending provider tokens.");
+            "Dry run: the evidence shape was written without launching a desktop or spending provider tokens.");
     const traceScreenshotMode = session?.trace.redaction.screenshots;
     const screenshotMode = traceScreenshotMode === "raw" || traceScreenshotMode === "blurred"
         ? traceScreenshotMode
@@ -80,13 +80,12 @@ function fanoutParticipantRecord(args, spec, index, view) {
                     ? `Participant ${spec.planned.id} ${outcome.skippedReason}.`
                     : outcome?.sessionError !== undefined
                         ? `Participant ${spec.planned.id} failed before a terminal session verdict: ${outcome.sessionError}`
-                        : `Contract participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}.`,
+                        : `Participant ${spec.planned.id} (${spec.persona.id}/${spec.planned.device.name}) for ${args.descriptor.id} against ${publicTargetUrl}; no session ran.`,
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
     });
 }
 function fanoutParticipantStream(args, spec, view) {
-    const { plan } = args;
     const { outcome, publicTargetUrl, session, desktopGeometry, screenshots } = view;
     const { lastScreenshot, status, reason, screenshotMode } = view;
     const judged = outcome === undefined ? undefined : judgedStatus(participantFactsOf(outcome));
@@ -104,7 +103,7 @@ function fanoutParticipantStream(args, spec, view) {
             ? {}
             : { caseGroup: spec.planned.labels.caseGroup }),
         kind: "browser",
-        label: `CUA participant ${spec.planned.id}: ${plan.labId}`,
+        label: `${spec.planned.id} · browser`,
         status,
         ...(judged === undefined ? {} : { judgedStatus: judged }),
         transport: "snapshot",
@@ -113,9 +112,9 @@ function fanoutParticipantStream(args, spec, view) {
             ? {
                 kind: "screenshot",
                 url: lastScreenshot,
-                title: `CUA desktop ${spec.planned.id} (${screenshotMode})`,
+                title: `Desktop (${screenshotMode})`,
             }
-            : { kind: "placeholder", title: `CUA desktop ${spec.planned.id}` },
+            : { kind: "placeholder", title: "Desktop" },
         ...(desktopGeometry.viewport === undefined
             ? {}
             : {
@@ -180,7 +179,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
     const { publicTargetUrl, subject, session } = view;
     const events = [];
     const record = (event) => events.push(participantEvent(spec, event));
-    // Per-participant subject provenance (invariant 5).
+    // Per-participant subject provenance.
     if (args.plan.runner.subject.kind === "clone" && args.publicRepo) {
         record({
             id: nextEventId(`subject-${spec.planned.id}`),
@@ -188,7 +187,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
-                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing cloned)`
+                ? `subject declared: clone of ${args.publicRepo}, served at ${publicTargetUrl} in-sandbox (dry run; nothing cloned)`
                 : subject.commit
                     ? session
                         ? `subject cloned from ${args.publicRepo}@${subject.commit} and served at ${publicTargetUrl} in-sandbox`
@@ -203,7 +202,7 @@ function fanoutSubjectEvents(ctx, spec, view) {
             level: "info",
             type: "cua-lab.subject.provenance",
             message: `Participant ${spec.planned.id}: ${args.dryRun
-                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry-run contract; nothing packed)`
+                ? `subject declared: local working tree, to be packed and served at ${publicTargetUrl} in-sandbox (dry run; nothing packed)`
                 : subject.archiveSha256
                     ? session
                         ? `subject packed (archiveSha256 ${subject.archiveSha256}${subject.dirty === true ? ", dirty working tree" : subject.dirty === false ? ", clean working tree" : ""}) and served at ${publicTargetUrl} in-sandbox`
@@ -270,7 +269,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
             at: args.run.createdAt,
             level: "info",
             type: "cua-lab.contract.ready",
-            message: `Participant ${spec.planned.id}: dry-run contract participant ready; switch scenario.mode to live for a real desktop session.`,
+            message: `Participant ${spec.planned.id}: dry-run participant ready; switch scenario.mode to live for a real desktop session.`,
         });
     }
     for (const warning of desktopGeometry.warnings ?? []) {
@@ -282,7 +281,7 @@ function fanoutOutcomeEvents(ctx, spec, view) {
             message: warning,
         });
     }
-    // Persisted per-participant phase trail (real boot timing): one RunEvent per COMPLETED phase
+    // Persisted per-participant phase trail (real boot timing): one RunEvent per completed phase
     // boundary this participant recorded (started events never persist here; they carry no durationMs).
     for (const phase of outcome?.phaseRecords ?? []) {
         record({

package/dist/routes/computer-use/live-flush.d.ts

@@ -12,7 +12,7 @@ export interface LiveTraceFlush {
     stop: () => Promise<void>;
 }
 /**
- * Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+ * Incremental live flush: as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses

package/dist/routes/computer-use/live-flush.js

@@ -1,7 +1,7 @@
 import { attachObserverRuntimeStreamUrls } from "../../observer/render.js";
 import {} from "../../observer/run-routes.js";
 /**
- * Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+ * Incremental live flush: as each participant's loop reports its recorded-so-far items,
  * rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
  * Observer's 5s poll sees the timeline grow. Throttled (one write per interval, trailing
  * write guaranteed). `write` is the run's `writeSnapshot`, which serializes writes and refuses
@@ -42,9 +42,9 @@ export function startLiveTraceFlush(args) {
                             liveActor: {
                                 schema: "humanish.live-actor.v1",
                                 updatedAt,
-                                // WHO this participant is, carried while the run is live. Without it a
-                                // surface watching a live run can only name the participant id, and "CUA browser — observer-live-
-                                // check" is the harness talking about itself where the participant should be.
+                                // Who this participant is, carried while the run is live. Without it a
+                                // surface watching a live run can only name the participant id and the stream
+                                // label (`<participant id> · browser`), which describe the harness, not the participant.
                                 ...(personaByStream.get(stream.id) === undefined
                                     ? {}
                                     : { persona: { id: personaByStream.get(stream.id) } }),
@@ -125,8 +125,8 @@ export function trackRuntimeStreams(onStream) {
             await onStream?.(event);
             if (event.type === "ready")
                 urls.push({ streamId: event.streamId, url: event.url });
-            // Mark, never remove: the tile needs to KNOW the live view ended (and say so) rather than
-            // have the stream silently vanish from the overlay (#357).
+            // Mark, never remove: the tile needs to know the live view ended (and say so) rather than
+            // have the stream silently vanish from the overlay.
             else
                 for (const entry of urls)
                     if (entry.streamId === event.streamId)

package/dist/routes/computer-use/live-phase.d.ts

@@ -10,10 +10,12 @@ export declare function runLabParticipants(setup: CuaRunSetup, participants: Cua
     result: {
         automaticAnalysis?: import("../../analysis/job.js").AutomaticAnalysisOutcome;
         automaticAnalysisTrigger?: "default" | "explicit";
-        schema: typeof import("./types.js").CUA_ACTOR_LAB_SCHEMA;
+        schema: typeof import("../../run/study-result.js").STUDY_RESULT_SCHEMA;
+        route: "computer-use";
+        studyId: string;
+        labId: string;
         ok: boolean;
         cwd: string;
-        labId: string;
         actor: string;
         appUrl: string;
         dryRun: boolean;

package/dist/routes/computer-use/live-phase.js

@@ -20,10 +20,10 @@ export async function runLabParticipants(setup, participants) {
     const inProcess = plan.runner.desktop === "in-process";
     const subjectEnvNames = [...participantSubjectEnv(plan.runner.subject)];
     const { runId, paths: runPaths } = run;
-    // A live run writes what it is doing AS IT DOES IT, whether or not anyone is currently watching.
-    // This used to be gated on `options.onObserverReady` — the interactive Observer callback — so a
-    // run launched by an agent (`lab run --json`), detached, or from the terminal surface recorded
-    // nothing at all until it completed, and anything asking "what is this participant doing right
+    // A live run writes what it is doing as it does it, whether or not anyone is currently watching.
+    // This is not gated on `options.onObserverReady` (the interactive Observer callback): gated, a
+    // run launched by an agent (`lab run --json`), detached, or from the terminal surface records
+    // nothing at all until it completes, and anything asking "what is this participant doing right
     // now" got silence for the whole run. Who reads the evidence is not the run's business; the
     // callback below stays conditional, the writing does not.
     if (!dryRun) {
@@ -47,7 +47,7 @@ export async function runLabParticipants(setup, participants) {
         streams.showIn(liveObserver);
         if (input.onObserverReady)
             await input.onObserverReady(liveObserver);
-        // Incremental live flush (#441): as each participant's loop reports its recorded-so-far items,
+        // Incremental live flush: as each participant's loop reports its recorded-so-far items,
         // rewrite the in-progress bundle with per-stream `liveActor` partials so the attached
         // Observer's 5s poll sees the timeline grow. The run refuses any snapshot once the final
         // write began; the route stops the flush timer on every exit below.
@@ -91,7 +91,7 @@ export async function runLabParticipants(setup, participants) {
             return {
                 ok: false,
                 result: {
-                    ...fail("HUMANISH_CUA_LAB_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
+                    ...fail("HUMANISH_COMPUTER_USE_SUBJECT_INVALID", "Real email setup failed before desktop allocation. Run humanish comms check --online and humanish comms recover to inspect authentication and pending cleanup.", descriptor.id),
                     runId,
                 },
             };

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

@@ -26,7 +26,7 @@ function guestAssets(options, account, needsMedia) {
         if (account) {
             const readiness = await checkRestrictedCodexAnalysisReadiness({ timeoutMs: 5000 });
             if (!readiness.ready)
-                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --lab <lab> before starting a local study.`);
+                throw new Error(`Codex account is not ready (${readiness.errorCode}). Run humanish doctor --study <study> before starting a local study.`);
         }
         return (options.assets ??
             (await prepareLocalRuntime({

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

@@ -38,11 +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 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,
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. 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 participant has a declared comms recipient WITH an address, so the drain can actually match the
+/** 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. */
+ *  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,13 +1,13 @@
 import { recipientParticipantId } from "../../lab/parse/comms.js";
-/** 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,
+/** The participant's addressed comms recipient, when one exists: the gate and the address source for the
+ *  inbox instruction. 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 participant has a declared comms recipient WITH an address, so the drain can actually match the
+/** 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. */
+ *  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/participant-execution.d.ts

@@ -11,12 +11,12 @@ export declare function makeParticipantWriteScreenshot(artifactRoot: PreparedOut
 export declare function runCuaParticipant(spec: DesktopParticipantRun, deps: CuaParticipantDeps): Promise<ParticipantRunOutcome>;
 /**
  * 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
+ * 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.
+ * 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 participant
- * 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 declare function runCuaParticipants(runs: DesktopParticipantRun[], deps: Omit<CuaParticipantDeps, "signalProvisioned">, concurrency: number, runParticipant?: typeof runCuaParticipant): Promise<{

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

@@ -132,12 +132,12 @@ export async function runCuaParticipant(spec, deps) {
 }
 /**
  * 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
+ * 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.
+ * 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 participant
- * 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) {
@@ -164,10 +164,10 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
         if (failFast.tripped) {
             return skippedOutcome(spec, `skipped: ${failFast.reason}`);
         }
-        // The participant runner is TOTAL (#342): every exit path returns a recorded outcome. Without this
+        // 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, {
@@ -187,7 +187,7 @@ export async function runCuaParticipants(runs, deps, concurrency, runParticipant
             });
         }
         catch (error) {
-            // The first participant 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?.();
@@ -247,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;
@@ -299,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."

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

@@ -1,4 +1,5 @@
 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, type ParticipantProviderCloseResult } from "../../actors/codex/restricted-participant.js";
@@ -29,6 +30,11 @@ export declare function closeParticipantModel(model: ParticipantModel, warnings:
 }>;
 /** Prices the finished session's tokens onto its trace, writes the trace, and warns on raw screenshots. */
 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: ParticipantModelDeps, warnings: string[]): {
     noEngagement: boolean;

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

@@ -49,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 &&
@@ -82,7 +82,7 @@ export async function startParticipantModel(spec, deps, executor) {
 /** The options the participant's session runs with: prompt, model settings, spend caps and callbacks. */
 export function participantSessionOptions(spec, deps, ready, provider, writeScreenshot) {
     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).
@@ -95,7 +95,7 @@ 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: {
@@ -129,8 +129,8 @@ 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 participant notes its own running estimate on the shared
-        // ledger and stops when the RUN total crosses the cap — independent of the per-participant
+        // 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
             ? {}
@@ -149,8 +149,8 @@ export function participantSessionOptions(spec, deps, ready, provider, writeScre
         ...(deps.onTrace === undefined
             ? {}
             : {
-                // 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.
+                // 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),
             }),
     };
@@ -207,27 +207,45 @@ export async function closeParticipantModel(model, warnings) {
 }
 /** 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-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
+    // 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
@@ -21,24 +21,24 @@ 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 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
+/** 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
@@ -26,12 +26,12 @@ export function composeParticipantInstructions(args) {
     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 route
+    // 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 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
+/** 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) {

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

@@ -13,17 +13,17 @@ export declare function defaultSessionTimeoutMs(config: LabConfig): number;
  *  costs the same wall-clock room either way. */
 export declare function resolveParticipantSandboxMs(config: LabConfig): number;
 /**
- * The in-flight participant bound a lab declares. Defaults to the participant count — every
+ * The in-flight participant bound a lab declares. Defaults to the participant count: every
  * declared participant runs at once, because a throttle nobody asked for silently turns "N actors
- * live" into waves (#350); total session count and spend are the same either way, only wall-clock
- * and simultaneity differ. A declared execution.concurrency is a CAP, clamped to [1, participants].
+ * live" into waves; total session count and spend are the same either way, only wall-clock
+ * and simultaneity differ. A declared execution.concurrency is a cap, clamped to [1, participants].
  * The planner records it; the route may only lower it from the environment.
  */
 export declare function boundedConcurrency(declared: number | undefined, participantCount: number): number;
 /**
- * Pure pre-flight plan resolver (runs in dry-run AND live). Returns the participant table, the
+ * Pure pre-flight plan resolver (runs in dry-run and live). Returns the participant table, the
  * effective concurrency, the wave count, the per-participant session budget, and the worst-case total
- * sandbox-minutes — BEFORE any sandbox or provider call. The same plan appears in dry-run,
+ * sandbox-minutes, before any sandbox or provider call. The same plan appears in dry-run,
  * marked $0 (dryRun: true).
  */
 export declare function resolveCuaParticipantPlan(config: LabConfig, opts?: {
@@ -32,8 +32,8 @@ export declare function resolveCuaParticipantPlan(config: LabConfig, opts?: {
     dryRun?: boolean;
     personas?: Map<string, ResolvedPersona>;
 }): CuaParticipantPlan;
-/** Print the participant plan to stderr BEFORE any sandbox/provider call (public-safe: ids, devices,
- *  digests, and budgets only — no prompt text, no secrets). */
+/** Print the participant plan to stderr before any sandbox/provider call (public-safe: ids, devices,
+ *  digests, and budgets only; no prompt text, no secrets). */
 export declare function emitPreflightPlan(participantPlan: CuaParticipantPlan, labId: string): void;
 export declare function formatParticipantPlanEntry(entry: CuaParticipantPlanEntry): string;
 /**