humanish 0.132.0 → 0.133.0

package/CHANGELOG.md

@@ -8,6 +8,19 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.133.0: An OpenAI participant names how long it waits (2026-10-14)
+
+humanish 0.133.0 lets an OpenAI computer-use participant name how long it waits, with a
+`wait_minutes` tool, and cuts what a participant costs while nothing on its screen changes. A turn of
+only waits is watched, and each further quiet wait in a row lasts twice as long, starting from the
+length the participant named, up to 10 minutes. In live 60-minute runs against 0.132.0, median model
+spend per participant-hour fell 13% on a resident portal, 52% on a support queue, 46% on an issue
+list that shows new issues only on reload, and 78% on a dispatch board, and all 6 participants on
+the issue list reloaded and reported every new issue. verify and analysis also no longer fail on a
+run whose traces together pass 512 MiB.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.133.0)
+
 ## 0.132.0: An OpenAI participant's closing report reads the prompt cache (2026-10-13)
 
 humanish 0.132.0 cuts the cost of an OpenAI computer-use participant's closing report. The closing

package/dist/actors/codex/restricted-participant.d.ts

@@ -22,6 +22,8 @@ export interface RestrictedParticipantOptions {
      * defaults the loop applies without it (resolveWaitSettings).
      */
     maxWaitMs?: number;
+    /** The participant's idleWaitMs, the shortest a call of only waits lasts, stated the same way. */
+    idleWaitMs?: number;
 }
 /** What doctor's hosted-participant check found, before any turn. */
 export interface ParticipantReadiness {

package/dist/actors/codex/restricted-participant.js

@@ -41,7 +41,7 @@ function deferred() {
     return { promise, resolve, reject };
 }
 // prose-check: model prompt (Codex reads this tool description, not a person)
-const toolDescription = (speechEnabled, { maxWaitMs, watchMaxMs }) => `Act on the participant's browser through humanish. Submit one to four UI actions${speechEnabled ? ", including speak when you need to reply aloud," : ""} and a short public comment; never private reasoning. humanish returns a JSON STRING with execution acknowledgments${speechEnabled ? ", speech heard from the actual participant speaker sink," : ""} and a fresh screenshot. In Code Mode use: const r = JSON.parse(await tools.humanish_ui({narration: "...", actions: [...]})); text({acknowledgments: r.acknowledgments${speechEnabled ? ", heardSpeech: r.heardSpeech" : ""}, contextHint: r.contextHint, closing: r.closing}); image(r.imageUrl). Call serially and inspect each returned screenshot${speechEnabled ? " and heardSpeech array" : ""} before deciding what to do next. A call whose actions are only waits returns when the screen changes and holds still${speechEnabled ? ", when speech is heard" : ""}, or after its waits' ms, together at most ${watchMaxMs} ms. While no change on the screen holds still, each further such call in a row waits twice as long as the one before, up to ${watchMaxMs} ms, and contextHint says how long it waited and why it returned. A wait among other actions lasts its ms, at most ${maxWaitMs} ms.${speechEnabled ? " Use speak only after the visible UI shows that you joined the call and your microphone is unmuted; it sends audio into that call." : ""} Acknowledged input does not prove an application outcome. If closing is true, stop calling tools and give your final account.`;
+const toolDescription = (speechEnabled, { maxWaitMs, watchMaxMs, idleWaitMs, }) => `Act on the participant's browser through humanish. Submit one to four UI actions${speechEnabled ? ", including speak when you need to reply aloud," : ""} and a short public comment; never private reasoning. humanish returns a JSON STRING with execution acknowledgments${speechEnabled ? ", speech heard from the actual participant speaker sink," : ""} and a fresh screenshot. In Code Mode use: const r = JSON.parse(await tools.humanish_ui({narration: "...", actions: [...]})); text({acknowledgments: r.acknowledgments${speechEnabled ? ", heardSpeech: r.heardSpeech" : ""}, contextHint: r.contextHint, closing: r.closing}); image(r.imageUrl). Call serially and inspect each returned screenshot${speechEnabled ? " and heardSpeech array" : ""} before deciding what to do next. A call whose actions are only waits and that asks for some wait time asks to wait its waits' ms together; an ask under ${idleWaitMs} ms counts as ${idleWaitMs} ms, and named ms count up to ${watchMaxMs} ms${speechEnabled ? ". It returns when speech is heard" : ""}. contextHint says how long it waited and why it returned. A wait among other actions lasts its ms, at most ${maxWaitMs} ms.${speechEnabled ? " Use speak only after the visible UI shows that you joined the call and your microphone is unmuted; it sends audio into that call." : ""} Acknowledged input does not prove an application outcome. If closing is true, stop calling tools and give your final account.`;
 const participantInstructions = (prompt, speechEnabled) => `${prompt}\n\nYou are the study participant throughout this conversation, including its closing account. Use only the supplied screenshots and humanish_ui tool to interact. The tool returns a JSON string: parse it, inspect acknowledgments${speechEnabled ? " and heardSpeech captured from the actual participant speaker sink" : ""}, and display imageUrl with Code Mode image(). Do not print the image data URL as text. Keep your persona and earlier observations throughout the session.${speechEnabled ? " A speak action plays into the participant microphone; use it only after the visible UI shows that you joined the call and the microphone is unmuted." : ""} Speak publicly about your experience, never reveal private reasoning. Completed inputs do not prove application outcomes; verify on the next screenshot. When the task ends, return only the required final JSON with outcome, summary, frictionReports and impressions. Report observed confusion and recovered mistakes as well as blockers. ${IMPRESSIONS_ASK} Do not invent observations.`;
 /** Turns and failures from the native run, handed in order to the next provider request. */
 class ParticipantEvents {
@@ -192,7 +192,11 @@ function participantSession(options, speechEnabled, effort, call) {
             reasoningEffort: effort,
             tool: {
                 name: "humanish_ui",
-                description: toolDescription(speechEnabled, resolveWaitSettings({ maxWaitMs: options.maxWaitMs, speechEnabled })),
+                description: toolDescription(speechEnabled, resolveWaitSettings({
+                    maxWaitMs: options.maxWaitMs,
+                    idleWaitMs: options.idleWaitMs,
+                    speechEnabled,
+                })),
                 inputSchema: participantToolSchema(speechEnabled),
                 call,
             },

package/dist/actors/computer-use/loop/actions.js

@@ -209,6 +209,7 @@ export async function runActionBatch(session, actions, watched) {
                 ? { coord: { x: action.x, y: action.y } }
                 : {}),
             ...(watched !== undefined && waitIndex === watched.endedOn ? { watch: watched.watch } : {}),
+            ...(requested.kind === "wait" && requested.ms !== undefined ? { namedMs: requested.ms } : {}),
         }));
     }
     return { execution, hint: hint() };

package/dist/actors/computer-use/loop/types.d.ts

@@ -328,12 +328,12 @@ export interface CuaLoopOptions {
     maxWaitMs?: number;
     /**
      * How long a `wait` that names no duration lasts, in ms, when its turn only waits or takes
-     * screenshots: the study's actor.idleWaitMs. It is also how often the loop looks at the screen
-     * while such a turn is watched, at most every 30000 ms when the executor is speechEnabled. After
-     * an action in the same turn such a wait lasts 500 ms. A whole number from 1000 to 600000 and no
-     * longer than an explicit maxWaitMs; any other value throws a RangeError before the session
-     * starts. Default 5000. The session never applies more than its maxWaitMs, and the trace records
-     * the applied lengths as `waitSettings`.
+     * screenshots: the study's actor.idleWaitMs. It is also the shortest such a turn is watched for,
+     * and how often the loop looks at the screen while it is watched, at most every 30000 ms when the
+     * executor is speechEnabled. After an action in the same turn such a wait lasts 500 ms. A whole
+     * number from 1000 to 600000 and no longer than an explicit maxWaitMs; any other value throws a
+     * RangeError before the session starts. Default 5000. The session never applies more than its
+     * maxWaitMs, and the trace records the applied lengths as `waitSettings`.
      */
     idleWaitMs?: number;
     /**

package/dist/actors/computer-use/loop/watch.js

@@ -50,10 +50,13 @@ export class IdleWatcher {
         if (plannedMs === 0)
             return undefined;
         const capMs = Math.max(plannedMs, session.waits.watchMaxMs);
-        // Never shorter than the turn's own planned length, so a long named wait is not cut short.
+        // Never shorter than idleWaitMs, so a participant naming a few milliseconds on a static screen
+        // does not send requests back to back, and never shorter than the turn's own planned length, so
+        // a long named wait is not cut short.
+        const shortestMs = Math.max(plannedMs, session.waits.idleWaitMs);
         const limitMs = this.grownFromMs === undefined
-            ? plannedMs
-            : Math.min(capMs, Math.max(plannedMs, 2 * this.grownFromMs));
+            ? shortestMs
+            : Math.min(capMs, Math.max(shortestMs, 2 * this.grownFromMs));
         const ending = await watchScreen(session, this.observer, turnNumber, reference, limitMs);
         // A small change that held still (a status label, or a counter the rule did not hold back)
         // wakes the participant and keeps the doubling, so a repeating small change cannot keep every
@@ -64,7 +67,7 @@ export class IdleWatcher {
             wake: ending.wake,
             ...(ending.observation === undefined ? {} : { observation: ending.observation }),
             ...(ending.stop === undefined ? {} : { stop: ending.stop }),
-            hint: hintFor(ending, grows && limitMs < capMs ? capMs : undefined),
+            hint: hintFor(ending),
             waits: {
                 ...splitWatch(lengths, limitMs, ending.ms),
                 sessionEnded: ending.stop !== undefined,
@@ -215,21 +218,18 @@ function splitWatch(lengths, limitMs, ms) {
     };
 }
 /**
- * The next request's note. A clock ending says nothing: the clock text that follows says it. A
+ * The next request's note. A clock ending says only how long the wait lasted. A
  * small change is named by its place, so a participant is not told the screen changed when what
- * changed was a counter or a timestamp. `growsToMs` adds the growth sentence when the next watch
- * doubles.
+ * changed was a counter or a timestamp. The note says nothing of the next wait's length: a
+ * participant told it names that length and keeps waiting.
  */
-function hintFor(ending, growsToMs) {
+function hintFor(ending) {
     const lasted = `Your wait lasted ${duration(ending.ms)}`;
-    const grows = growsToMs === undefined
-        ? ""
-        : ` A wait right after it can last twice as long, at most ${duration(growsToMs)}.`;
     const { seen } = ending;
     switch (ending.wake) {
         case "changed":
             return seen?.verdict === "settled" && seen.small
-                ? `${lasted} and ended when a small part of the screen changed and then stayed the same for over a minute, ${place(seen.area)}.${grows}`
+                ? `${lasted} and ended when a small part of the screen changed and then stayed the same for over a minute, ${place(seen.area)}.`
                 : `${lasted} and ended when the screen changed.`;
         case "speech":
             return `${lasted} and ended when you heard speech.`;
@@ -239,13 +239,15 @@ function hintFor(ending, growsToMs) {
         // never says the screen stayed the same.
         case "limit":
             if (seen?.verdict === "changing" && seen.lookSoon)
-                return `${lasted}; a large part of the screen was changing at its last check.${grows}`;
+                return `${lasted}; a large part of the screen was changing at its last check.`;
             if (seen?.verdict !== "settled" && seen?.held !== undefined)
-                return `${lasted}; a small part of the screen changed and stayed the same, ${place(seen.held)}. A small change does not end a wait.${grows}`;
-            return `${lasted}; no change on the screen held still long enough to end it.${grows}`;
+                return `${lasted}; a small part of the screen changed and stayed the same, ${place(seen.held)}. A small change does not end a wait.`;
+            return `${lasted}; no change on the screen held still long enough to end it.`;
         case "stalled":
             return `${lasted}; the screen could not be checked during it.`;
+        // The clock text that follows says why the wait ended.
         case "clock":
+            return `${lasted}.`;
         case "stopped":
             return undefined;
     }

package/dist/actors/computer-use/openai-context.js

@@ -4,16 +4,17 @@ import { asArray, asRecord, inputMessage, openAiActionToCua } from "./openai-wir
 // provider still threads on previous_response_id feed it too, so a switch partway through a
 // session keeps everything before the switch.
 //
-// The Responses API pairs items: every computer_call needs its computer_call_output, and a
-// reasoning item travels with the item it preceded. The conversation is therefore cut only at
-// exchange boundaries: one reply's output items together with the items that answered them.
-// When the estimate passes the budget, the conversation is cut down to half the budget in one
-// step: the opening screenshot goes first, then the oldest exchanges become lines of a progress
-// note that keeps their reasoning summaries, messages and actions, and the text that answered
-// them, such as a note that an action was not run. The note is an assistant message, so text the
-// model wrote (which can quote a web page) keeps the trust it had when the model wrote it. The newest MIN_KEPT_EXCHANGES exchanges are never collapsed, so a
-// request passes the budget when they alone exceed it; the trace's per-request estimate shows when
-// that happens.
+// The Responses API pairs items: every computer_call needs its computer_call_output, every
+// function_call (wait_minutes) its function_call_output, and a reasoning item travels with the
+// item it preceded. The conversation is therefore cut only at exchange boundaries: one reply's
+// output items together with the items that answered them. When the estimate passes the budget, the
+// conversation is cut down to half the budget in one step: the opening screenshot goes first, then
+// the oldest exchanges become lines of a progress note that keeps their reasoning summaries,
+// messages, actions and function calls, and the text that answered them, such as a note that an
+// action was not run or how a wait ended. The note is an assistant message, so text the model wrote
+// (which can quote a web page) keeps the trust it had when the model wrote it. The newest
+// MIN_KEPT_EXCHANGES exchanges are never collapsed, so a request passes the budget when they alone
+// exceed it; the trace's per-request estimate shows when that happens.
 //
 // A cut rewrites the start of the prompt, so the provider's prompt cache misses on the request
 // after it. Between cuts nothing already sent changes: each request starts with the whole of the
@@ -156,12 +157,15 @@ function describeExchange(exchange) {
     const said = [];
     const did = [];
     const told = [];
-    // The answers are the call outputs, whose content is a screenshot, and hint messages.
+    // The answers are the computer_call outputs, whose content is a screenshot, the function call
+    // outputs, which say how a wait ended as text beside any screenshot, and hint messages.
     for (const raw of exchange.answers) {
         const item = asRecord(raw);
         if (item.type === "computer_call_output")
             continue;
-        for (const entry of asArray(item.content)) {
+        if (typeof item.output === "string" && item.output.length > 0)
+            told.push(item.output);
+        for (const entry of [...asArray(item.content), ...asArray(item.output)]) {
             const text = asRecord(entry).text;
             if (typeof text === "string" && text.length > 0)
                 told.push(text);
@@ -189,6 +193,11 @@ function describeExchange(exchange) {
                     did.push(describeAction(mapped));
             }
         }
+        // A function call is noted as it was made, such as wait_minutes {"minutes":3}.
+        if (item.type === "function_call" && typeof item.name === "string")
+            did.push(typeof item.arguments === "string"
+                ? `${item.name} ${clip(item.arguments, 120)}`
+                : item.name);
     }
     const lead = `Turn ${exchange.turn}: `;
     const before = [
@@ -224,14 +233,17 @@ function clip(text, limit) {
     const flat = text.replace(/\s+/g, " ").trim();
     return flat.length <= limit ? flat : `${flat.slice(0, limit - 3)}...`;
 }
-/** The data URLs of the images an input item carries. */
+/**
+ * The data URLs of the images an input item carries: a computer_call output's screenshot, and the
+ * image parts of a message's content or a function call output's output.
+ */
 function imagesOf(item) {
     const record = asRecord(item);
     const output = asRecord(record.output);
     const urls = [];
     if (typeof output.image_url === "string")
         urls.push(output.image_url);
-    for (const part of asArray(record.content)) {
+    for (const part of [...asArray(record.content), ...asArray(record.output)]) {
         const url = asRecord(part).image_url;
         if (typeof url === "string")
             urls.push(url);

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -40,6 +40,10 @@ export declare class OpenAiConversation {
     private lastResponseId;
     /** computer_call ids the next request owes an output for. */
     private pendingCallIds;
+    /** The function calls the next request owes an output for. */
+    private pendingFunctionCalls;
+    /** Whether the latest reply acted, so its waits went to the desktop and were not watched. */
+    private pendingActed;
     /** Accepted replies so far; the next request is number `replies + 1`. */
     private replies;
     /** The whole conversation, which explicit-context requests carry within its token budget. */
@@ -53,7 +57,7 @@ export declare class OpenAiConversation {
     constructor(settings: OpenAiConversationSettings);
     /**
      * The next participant turn's request, carrying `req`'s screen: the opening request, or the
-     * outputs the latest reply's computer calls are owed.
+     * outputs the latest reply's computer and function calls are owed.
      */
     request(req: CuaTurnRequest): ConversationRequest;
     /**
@@ -79,9 +83,20 @@ export declare class OpenAiConversation {
     record(): ActorConversation;
     /**
      * The items a request adds to the conversation: the opening message with the first screen, or
-     * an output for each pending computer_call with the latest screenshot and any hint.
+     * an output for each pending call with the latest screenshot, and any hint. Each computer_call
+     * output carries the screenshot. Function call outputs follow in reply order: with no
+     * computer_call the first carries the screenshot, and every other one carries text only, so the
+     * screenshot is sent once. A turn's hint goes into the first function call output, so it reads
+     * as how the wait ended; a closing request's hint asks for the closing account and stays a user
+     * message. A call to a tool that does not exist gets an output that says so (callNote).
      */
     private newItems;
+    /**
+     * What a call's output says when no note does, so every reply says how the wait went: a wait
+     * among actions ran for its length (a shortened or unsent one has a note), and a further call in
+     * a reply of only waits was part of the one watch the first call's output reports.
+     */
+    private waitOutcome;
     private context;
     /**
      * A participant request: the opening request, or a continuation carrying `sent`. A threaded

package/dist/actors/computer-use/openai-conversation.js

@@ -1,6 +1,7 @@
 import { closingReportSchema, impressionsReplySchema, strictOutputSchema, } from "../closing-report.js";
+import { isIdleTurn } from "./loop/actions.js";
 import { CarriedConversation, estimateTokens } from "./openai-context.js";
-import { asArray, asRecord, buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, inputMessage, openingMessage, parseOpenAiResponse, } from "./openai-wire.js";
+import { asArray, asRecord, buildCallOutput, buildContinuationRequest, buildFunctionOutput, buildInitialRequest, hintItems, inputMessage, openingMessage, parseOpenAiResponse, WAIT_TOOL_NAME, } from "./openai-wire.js";
 /**
  * The closing request's output limit: its own cap, or the declared limit when that is lower. It
  * counts reasoning too, and leaves room for six impressions after the summary and friction reports.
@@ -25,6 +26,10 @@ export class OpenAiConversation {
     lastResponseId;
     /** computer_call ids the next request owes an output for. */
     pendingCallIds = [];
+    /** The function calls the next request owes an output for. */
+    pendingFunctionCalls = [];
+    /** Whether the latest reply acted, so its waits went to the desktop and were not watched. */
+    pendingActed = false;
     /** Accepted replies so far; the next request is number `replies + 1`. */
     replies = 0;
     /** The whole conversation, which explicit-context requests carry within its token budget. */
@@ -43,7 +48,7 @@ export class OpenAiConversation {
     }
     /**
      * The next participant turn's request, carrying `req`'s screen: the opening request, or the
-     * outputs the latest reply's computer calls are owed.
+     * outputs the latest reply's computer and function calls are owed.
      */
     request(req) {
         const sent = this.newItems(req);
@@ -63,7 +68,7 @@ export class OpenAiConversation {
         const strict = this.openClosing !== undefined;
         // Before any accepted reply the request is the opening one, which carries no hint of its own.
         const ask = this.replies === 0 ? hintItems(req.contextHint) : [];
-        const sent = this.openClosing ?? [...this.newItems(req), ...ask, replyForm(closing)];
+        const sent = this.openClosing ?? [...this.newItems(req, closing), ...ask, replyForm(closing)];
         this.openClosing = undefined;
         const reply = await send(this.closingBody(req, sent, closing, strict));
         // Recorded before the reply is accepted, as a participant turn is.
@@ -108,16 +113,43 @@ export class OpenAiConversation {
     }
     /**
      * The items a request adds to the conversation: the opening message with the first screen, or
-     * an output for each pending computer_call with the latest screenshot and any hint.
+     * an output for each pending call with the latest screenshot, and any hint. Each computer_call
+     * output carries the screenshot. Function call outputs follow in reply order: with no
+     * computer_call the first carries the screenshot, and every other one carries text only, so the
+     * screenshot is sent once. A turn's hint goes into the first function call output, so it reads
+     * as how the wait ended; a closing request's hint asks for the closing account and stays a user
+     * message. A call to a tool that does not exist gets an output that says so (callNote).
      */
-    newItems(req) {
+    newItems(req, closing) {
         if (this.replies === 0)
             return [openingMessage(req.instructions, req.observation.screenshot)];
+        const { screenshot } = req.observation;
+        const calls = this.pendingFunctionCalls;
+        const hintInCall = closing === undefined && calls.length > 0;
         return [
-            ...this.pendingCallIds.map((id) => buildCallOutput(id, req.observation.screenshot, req.acknowledgedSafetyChecks)),
-            ...hintItems(req.contextHint),
+            ...this.pendingCallIds.map((id) => buildCallOutput(id, screenshot, req.acknowledgedSafetyChecks)),
+            ...calls.map((call, index) => {
+                const withScreen = index === 0 && this.pendingCallIds.length === 0;
+                const text = [callNote(call), index === 0 && hintInCall ? req.contextHint : undefined]
+                    .filter((part) => part !== undefined && part !== "")
+                    .join(" ");
+                return withScreen
+                    ? buildFunctionOutput(call.callId, text, screenshot)
+                    : buildFunctionOutput(call.callId, text || this.waitOutcome(), null);
+            }),
+            ...(hintInCall ? [] : hintItems(req.contextHint)),
         ];
     }
+    /**
+     * What a call's output says when no note does, so every reply says how the wait went: a wait
+     * among actions ran for its length (a shortened or unsent one has a note), and a further call in
+     * a reply of only waits was part of the one watch the first call's output reports.
+     */
+    waitOutcome() {
+        return this.pendingActed
+            ? "The wait ran for its length with your other actions."
+            : "This wait was watched together with the first one in the reply.";
+    }
     context(instructions) {
         const { settings } = this;
         return {
@@ -183,10 +215,18 @@ export class OpenAiConversation {
         if (parsed.turn.responseId !== undefined)
             this.lastResponseId = parsed.turn.responseId;
         this.pendingCallIds = parsed.callIds;
+        this.pendingFunctionCalls = parsed.functionCalls;
+        this.pendingActed = !isIdleTurn(parsed.turn.actions);
         this.replies += 1;
         this.carried.accept(this.replies, sent, parsed.outputItems);
     }
 }
+/** What a function call's output says about the call itself: that no such tool exists. */
+function callNote(call) {
+    return call.name === WAIT_TOOL_NAME
+        ? undefined
+        : `There is no tool named ${JSON.stringify(call.name)}.`;
+}
 /**
  * What form a closing reply takes, said in the request itself because text.format would rewrite
  * the cached prefix: the schema the strict retry sets.

package/dist/actors/computer-use/openai-wire.d.ts

@@ -12,8 +12,15 @@ export declare function openAiActionToCua(action: unknown): CuaAction | null;
 export interface ParsedOpenAiResponse {
     turn: CuaTurn;
     callIds: string[];
+    /** The function calls, in reply order, each owed a function_call_output. */
+    functionCalls: FunctionCall[];
     outputItems: unknown[];
 }
+/** A function call a reply made: its id, and its name, which is WAIT_TOOL_NAME unless it erred. */
+export interface FunctionCall {
+    readonly callId: string;
+    readonly name: string;
+}
 /**
  * Parse a Responses API response into a provider-neutral CuaTurn plus the
  * computer_call ids (needed to build the next turn's call outputs) and the raw
@@ -23,6 +30,15 @@ export interface ParsedOpenAiResponse {
  */
 export declare function parseOpenAiResponse(raw: unknown): ParsedOpenAiResponse;
 export type OpenAiReasoningSummary = "auto" | "concise" | "detailed";
+/**
+ * A function the participant names its wait length with; the computer tool's `wait` names none.
+ * The minutes set where the doubling of idle turns in a row starts (loop/watch.ts). Declared on
+ * every request, so adding it changes no request's cached prefix after the first. Its name and
+ * description say nothing of the screen or of later waits: participants told that a wait ends when
+ * the screen changes treated waiting as watching and stopped reloading a page that updates only on
+ * reload, and participants told a schedule copied it. Each watch's note says how long it lasted.
+ */
+export declare const WAIT_TOOL_NAME = "wait_minutes";
 export interface OpenAiCuContext {
     /**
      * The server keeps no conversation (explicit_context): the request asks not to be stored and
@@ -59,6 +75,11 @@ export declare function openingMessage(instructions: string, screenshot?: Buffer
  * the mapper self-validating and isolable.
  */
 export declare function buildCallOutput(callId: string, screenshot: Buffer | undefined, acknowledged?: CuaSafetyCheck[]): Record<string, unknown>;
+/**
+ * The answer to a function call: `text`, followed by the screen. `screenshot` null sends the text
+ * alone; undefined is a missing frame, refused as buildCallOutput refuses it.
+ */
+export declare function buildFunctionOutput(callId: string, text: string, screenshot: Buffer | undefined | null): Record<string, unknown>;
 export interface ContinuationRequestArgs {
     ctx: OpenAiCuContext;
     previousResponseId: string | undefined;

package/dist/actors/computer-use/openai-wire.js

@@ -102,6 +102,25 @@ export function openAiActionToCua(action) {
             return null;
     }
 }
+/**
+ * A wait_minutes call as a wait of the minutes it names, in whole milliseconds and at least 1.
+ * The session's caps then apply as to any named wait, and the trace records the length as named.
+ * Arguments that do not parse, or minutes that are not a finite number above zero, make a wait
+ * that names no length, as the computer tool's `wait` does.
+ */
+function waitMinutesAction(args) {
+    let minutes;
+    try {
+        minutes = asRecord(JSON.parse(asString(args))).minutes;
+    }
+    catch {
+        return { kind: "wait" };
+    }
+    if (typeof minutes !== "number" || !(minutes > 0))
+        return { kind: "wait" };
+    const ms = Math.max(1, Math.round(minutes * 60_000));
+    return Number.isFinite(ms) ? { kind: "wait", ms } : { kind: "wait" };
+}
 // Collect plain strings or { text } entries from a reasoning summary/content array.
 function collectTextEntries(value) {
     const out = [];
@@ -143,6 +162,7 @@ export function parseOpenAiResponse(raw) {
     const output = asArray(root.output);
     const actions = [];
     const callIds = [];
+    const functionCalls = [];
     const reasoningParts = [];
     const messageParts = [];
     const safetyChecks = [];
@@ -194,6 +214,17 @@ export function parseOpenAiResponse(raw) {
                 }
                 break;
             }
+            case "function_call": {
+                const callId = optionalString(item.call_id);
+                if (callId === undefined)
+                    break;
+                const name = asString(item.name);
+                functionCalls.push({ callId, name });
+                // A call to a tool that does not exist is a wait with no length, and its output says there
+                // is no such tool. A reply of only such calls is then an idle turn, so the session goes on.
+                actions.push(name === WAIT_TOOL_NAME ? waitMinutesAction(item.arguments) : { kind: "wait" });
+                break;
+            }
             default:
                 break;
         }
@@ -240,8 +271,34 @@ export function parseOpenAiResponse(raw) {
         ...(message.length > 0 ? { message } : {}),
         ...(usage === undefined ? {} : { usage }),
     };
-    return { turn, callIds, outputItems: output };
+    return { turn, callIds, functionCalls, outputItems: output };
 }
+/**
+ * A function the participant names its wait length with; the computer tool's `wait` names none.
+ * The minutes set where the doubling of idle turns in a row starts (loop/watch.ts). Declared on
+ * every request, so adding it changes no request's cached prefix after the first. Its name and
+ * description say nothing of the screen or of later waits: participants told that a wait ends when
+ * the screen changes treated waiting as watching and stopped reloading a page that updates only on
+ * reload, and participants told a schedule copied it. Each watch's note says how long it lasted.
+ */
+export const WAIT_TOOL_NAME = "wait_minutes";
+const WAIT_TOOL = {
+    type: "function",
+    name: WAIT_TOOL_NAME,
+    description: "Wait, then get a new screenshot. The reply says how long the wait lasted and why it ended.",
+    parameters: {
+        type: "object",
+        properties: {
+            minutes: {
+                type: "number",
+                description: "How long you want to wait, in minutes.",
+            },
+        },
+        required: ["minutes"],
+        additionalProperties: false,
+    },
+    strict: true,
+};
 // The fields shared by the initial and continuation requests: the tool spec,
 // truncation policy, reasoning effort, and (when configured) the safety id.
 function sharedRequestFields(ctx) {
@@ -256,7 +313,7 @@ function sharedRequestFields(ctx) {
         // The Responses API `computer` tool takes no display/environment fields; the model infers
         // resolution from the screenshots it is sent. (Sending display_* returns a 400
         // "Unknown parameter tools[0].display_width", confirmed against the live API 2026-06.)
-        tools: [{ type: "computer" }],
+        tools: [{ type: "computer" }, WAIT_TOOL],
         truncation: "auto",
         // `summary` asks for the provider-sanctioned reasoning summary items; the
         // capture side never scrapes or reconstructs raw chain-of-thought. Parsed by
@@ -318,16 +375,10 @@ export function openingMessage(instructions, screenshot) {
  * the mapper self-validating and isolable.
  */
 export function buildCallOutput(callId, screenshot, acknowledged) {
-    if (screenshot === undefined) {
-        throw new Error("openai-responses-cu requires observation.screenshot (it is a vision provider; pair a state-only executor with a non-vision provider)");
-    }
     return {
         type: "computer_call_output",
         call_id: callId,
-        output: {
-            type: "computer_screenshot",
-            image_url: `data:image/png;base64,${screenshot.toString("base64")}`,
-        },
+        output: { type: "computer_screenshot", image_url: screenshotUrl(screenshot) },
         ...(acknowledged && acknowledged.length > 0
             ? {
                 acknowledged_safety_checks: acknowledged.map(({ id, code, message }) => ({
@@ -339,6 +390,28 @@ export function buildCallOutput(callId, screenshot, acknowledged) {
             : {}),
     };
 }
+/**
+ * The answer to a function call: `text`, followed by the screen. `screenshot` null sends the text
+ * alone; undefined is a missing frame, refused as buildCallOutput refuses it.
+ */
+export function buildFunctionOutput(callId, text, screenshot) {
+    return {
+        type: "function_call_output",
+        call_id: callId,
+        output: screenshot === null
+            ? text
+            : [
+                ...(text ? [{ type: "input_text", text }] : []),
+                { type: "input_image", image_url: screenshotUrl(screenshot) },
+            ],
+    };
+}
+function screenshotUrl(screenshot) {
+    if (screenshot === undefined) {
+        throw new Error("openai-responses-cu requires observation.screenshot (it is a vision provider; pair a state-only executor with a non-vision provider)");
+    }
+    return `data:image/png;base64,${screenshot.toString("base64")}`;
+}
 /** An optional context hint as input items (none when there is no hint). */
 export function hintItems(contextHint) {
     return contextHint ? [inputMessage("user", [{ type: "input_text", text: contextHint }])] : [];

package/dist/actors/computer-use/wait.d.ts

@@ -21,16 +21,18 @@ export declare const CUA_WAIT_LIMITS: Readonly<{
     defaultWatchMaxMs: 600000;
     /**
      * How long a wait that names no duration lasts in a turn that only waits or takes screenshots,
-     * when a study does not set actor.idleWaitMs. OpenAI's computer-use `wait` names no duration. A
-     * participant told to wait about a minute sent ten in one turn, which lasts 50 s at this length;
-     * one wait a turn makes a one-minute wait about six turns. It is also how often a watch looks.
+     * when a study does not set actor.idleWaitMs. OpenAI's computer tool `wait` names no duration;
+     * its wait_minutes function names one in minutes. A participant told to wait about a minute
+     * sent ten computer tool waits in one turn, which lasts 50 s at this length; one wait a turn
+     * makes a one-minute wait about six turns. It is also the shortest a watch lasts and how often
+     * it looks.
      */
     defaultIdleMs: 5000;
     /**
      * How long a wait that names no duration lasts after the participant acts in the same turn, so
-     * the screen can settle before the next screenshot. Nearly every OpenAI computer-use wait follows
-     * a click or keypress this way, so a longer one would slow every run. A watch looks again this
-     * soon after a large part of the screen moved.
+     * the screen can settle before the next screenshot. Nearly every OpenAI computer tool wait
+     * follows a click or keypress this way, so a longer one would slow every run. A watch looks again
+     * this soon after a large part of the screen moved.
      */
     settleMs: 500;
     /**

package/dist/actors/computer-use/wait.js

@@ -2,8 +2,8 @@
 // longest (actor.maxWaitMs) and how long a wait that names no duration lasts while the participant
 // only waits (actor.idleWaitMs). The loop asks planWait for each wait. A turn with another action
 // sends its waits to the desktop in steps one desktop call carries; a turn that only waits watches
-// the screen instead (loop/watch.ts), for its waits' lengths, the named ones together up to
-// watchMaxMs, or longer as the watches of idle turns in a row grow.
+// the screen instead (loop/watch.ts), for its waits' lengths and at least idleWaitMs, the named
+// ones together up to watchMaxMs, or longer as the watches of idle turns in a row grow.
 export const CUA_WAIT_LIMITS = Object.freeze({
     /**
      * The longest wait one desktop call is given. A browser-control request must be answered within
@@ -26,16 +26,18 @@ export const CUA_WAIT_LIMITS = Object.freeze({
     defaultWatchMaxMs: 600_000,
     /**
      * How long a wait that names no duration lasts in a turn that only waits or takes screenshots,
-     * when a study does not set actor.idleWaitMs. OpenAI's computer-use `wait` names no duration. A
-     * participant told to wait about a minute sent ten in one turn, which lasts 50 s at this length;
-     * one wait a turn makes a one-minute wait about six turns. It is also how often a watch looks.
+     * when a study does not set actor.idleWaitMs. OpenAI's computer tool `wait` names no duration;
+     * its wait_minutes function names one in minutes. A participant told to wait about a minute
+     * sent ten computer tool waits in one turn, which lasts 50 s at this length; one wait a turn
+     * makes a one-minute wait about six turns. It is also the shortest a watch lasts and how often
+     * it looks.
      */
     defaultIdleMs: 5_000,
     /**
      * How long a wait that names no duration lasts after the participant acts in the same turn, so
-     * the screen can settle before the next screenshot. Nearly every OpenAI computer-use wait follows
-     * a click or keypress this way, so a longer one would slow every run. A watch looks again this
-     * soon after a large part of the screen moved.
+     * the screen can settle before the next screenshot. Nearly every OpenAI computer tool wait
+     * follows a click or keypress this way, so a longer one would slow every run. A watch looks again
+     * this soon after a large part of the screen moved.
      */
     settleMs: 500,
     /**

package/dist/actors/contract.d.ts

@@ -91,6 +91,10 @@ export interface ActorTraceItem {
      *  ran in place of a turn that only waited. Additive: absent on plain waits, on other items and
      *  producers, and in older bundles. */
     watch?: ActorWatch;
+    /** On a computer-use wait's `ui_action`: the length in milliseconds the participant named for
+     *  it, before any cap. Absent on a wait that named no length, such as the OpenAI computer
+     *  tool's `wait`, on other items and producers, and in older bundles. */
+    namedMs?: number;
 }
 /**
  * A watch over the screen while a computer-use participant only waited: the loop looked every

package/dist/actors/local-agent/cli.js

@@ -190,11 +190,11 @@ export function promptFor(request, screenshotPath) {
             "giving up, and put your closing words in message. When done=true, set outcome: reached if " +
             "the task is finished, blocked if something in the app stopped you, not_reached if you are " +
             "stopping for another reason. Otherwise outcome is null.",
-        "A turn whose actions are only waits ends when the screen changes and holds still, or when its " +
-            "waits' ms pass. While no change on the screen holds still, each further turn in a row that " +
-            "only waits lasts twice as long as the one before, up to the study's longest wait, and the note " +
-            "from the harness says how long you waited and why it ended. A wait among other actions lasts " +
-            "its ms.",
+        "A turn whose actions are only waits and that asks for some wait time asks to wait its waits' " +
+            "ms together; an ask shorter than a wait whose ms is null counts as one, and named ms count " +
+            "up to the study's longest wait. The note from the harness says how long you waited and why " +
+            "it ended. A wait among other actions lasts its ms, and the note says when the study's limit " +
+            "for one wait shortened it.",
         `Reply with ONLY a JSON object of this shape: ${shape}`,
         hint,
     ].join("\n");

package/dist/evidence/redaction.d.ts

@@ -14,6 +14,8 @@ export declare const REDACTION_MARKERS: {
 export declare function sensitivePatterns(): readonly RegExp[];
 /** True if the text contains a credential. Local paths and a URL on an E2B host alone do not count. */
 export declare function containsCredential(text: string): boolean;
+/** True if the text contains a URL on an E2B host, as containsSensitive reads one. */
+export declare function containsSandboxUrl(text: string): boolean;
 /** True if the text contains any secret-shaped token or known local path. */
 export declare function containsSensitive(text: string): boolean;
 /**

package/dist/evidence/redaction.js

@@ -76,6 +76,10 @@ const E2B_PUBLIC_PAGE = [
 // A stream URL's auth key rides its `password` parameter, 16 characters from the SDK, which the
 // credential parameter pattern matches as well.
 const SANDBOX_URL = new RegExp(String.raw `(?!https:\/\/(?:${E2B_PUBLIC_PAGE})[.,;:!?'")]*(?:\s|$))https?:\\?\/\\?\/(?:[^/\s@]*@)*[^/\s\\"'<>@]*e2b[^)\s]+`, "gi");
+// src/evidence/sensitive-json.ts scans a JSON array one element at a time and relies on which of
+// these patterns can match across the `},{` between two elements. A new pattern that can cross
+// those characters needs a case in tests/evidence/sensitive-json.test.ts.
+//
 // A pattern that matches a credential by its context puts the context in a `keep` group, which
 // redaction leaves in place: `?token=[REDACTED_SECRET]`. Context goes in a group and not in a
 // lookbehind, because a pattern that starts with a lookbehind is tried at every position of the
@@ -174,6 +178,10 @@ const CREDENTIAL_PATTERNS = SECRET_PATTERNS.filter((pattern) => pattern !== SAND
 export function containsCredential(text) {
     return CREDENTIAL_PATTERNS.some((pattern) => matchesPattern(pattern, text));
 }
+/** True if the text contains a URL on an E2B host, as containsSensitive reads one. */
+export function containsSandboxUrl(text) {
+    return matchesPattern(SANDBOX_URL, text);
+}
 /** True if the text contains any secret-shaped token or known local path. */
 export function containsSensitive(text) {
     return (containsSecret(text) || LOCAL_PATH_PATTERNS.some(([pattern]) => matchesPattern(pattern, text)));

package/dist/evidence/sensitive-json.d.ts

@@ -0,0 +1,9 @@
+/**
+ * containsSensitive(JSON.stringify(value)), with each element of the array `value[key]` serialized
+ * and scanned on its own, so no one string holds two elements. Only an array of plain objects is
+ * scanned that way. Any other array, and a value, array or element with a toJSON or a prototype of
+ * its own, is scanned as the whole text, which can be longer than one string holds. Getters and
+ * proxies are not detected, so the answer is the whole text's for values as JSON.parse returns
+ * them.
+ */
+export declare function containsSensitiveJson(value: unknown, key: string): boolean;

package/dist/evidence/sensitive-json.js

@@ -0,0 +1,96 @@
+// containsSensitive over a JSON document that may not fit in one string. V8's longest string is
+// 536,870,888 characters on Node 24, and a run with every participant's trace loaded can pass it.
+//
+// The document is scanned as pieces: the text before the array and its first element, each
+// element after that, and the last element with the text after the array. Every cut then falls on
+// the `,` between two objects, `},{`. Most patterns stop at a quote, so a match stays inside one
+// JSON string. Those that read a name and its value cross only the quotes around its `:`. A
+// credential variable's unquoted value runs over brackets and braces up to a comma, so at a cut it
+// stops, but after the last element it can run over the array's `]`. That is why the text after
+// the array joins the last element.
+//
+// The sandbox URL can cross a cut. Its user info runs over quotes, braces and commas up to an `@`:
+// `https://host"},{"contact":"ops@e2b-host`. From the end of its scheme to one character past
+// `e2b`, that match holds no slash and no whitespace. So a match across a cut starts at a scheme
+// with no slash or whitespace after it up to the cut, and reaches the next piece only up to its
+// first slash or whitespace. Between that scheme and the cut, the match can only be in its user
+// info. The scheme and every `@` there are inside JSON strings, so a host that starts after one
+// stops at its string's closing quote. Had that host reached `e2b` first, the scan of its piece or
+// an earlier junction would have matched. So the scan keeps only the scheme between pieces. Each
+// cut's junction scans the scheme, `"}` in place of the text after it, the cut's `,` and the next
+// piece up to its first slash or whitespace. A public E2B page after the scheme would need a space
+// or the text's end before the cut, so neither text exempts the URL. The scan holds one piece at a
+// time.
+import { isRecord } from "../run/type-guards.js";
+import { containsSandboxUrl, containsSensitive } from "./redaction.js";
+// The sandbox URL's scheme, `https://` or `https:\/\/` as JSON may escape it, at a text's end.
+const SCHEME_AT_END = /https?:\\?\/\\?\/$/i;
+const SLASH_OR_SPACE = /[/\s]/;
+/**
+ * containsSensitive(JSON.stringify(value)), with each element of the array `value[key]` serialized
+ * and scanned on its own, so no one string holds two elements. Only an array of plain objects is
+ * scanned that way. Any other array, and a value, array or element with a toJSON or a prototype of
+ * its own, is scanned as the whole text, which can be longer than one string holds. Getters and
+ * proxies are not detected, so the answer is the whole text's for values as JSON.parse returns
+ * them.
+ */
+export function containsSensitiveJson(value, key) {
+    // JSON.stringify writes only own enumerable keys, and `around` cuts the text at this one.
+    const elements = isPlainRecord(value) && Object.keys(value).includes(key) ? value[key] : undefined;
+    // Array.from reads a hole as undefined, where every would skip it.
+    if (!isPlainRecord(value) ||
+        !isPlainArray(elements) ||
+        !Array.from(elements).every(isPlainRecord))
+        return wholeTextSensitive(value);
+    const [prefix, suffix] = around(value, key);
+    if (elements.length === 0)
+        return containsSensitive(prefix + suffix);
+    // The scheme of a URL no slash or whitespace has followed, from an earlier piece.
+    let scheme;
+    for (const [index, element] of elements.entries()) {
+        const own = JSON.stringify(element);
+        const piece = (index === 0 ? prefix : "") + own + (index === elements.length - 1 ? suffix : "");
+        if (containsSensitive(piece))
+            return true;
+        if (scheme !== undefined && containsSandboxUrl(`${scheme}"},${head(piece)}`))
+            return true;
+        scheme = schemeAfter(scheme, piece);
+    }
+    return false;
+}
+const wholeTextSensitive = (value) => containsSensitive(JSON.stringify(value) ?? "");
+// JSON.stringify calls a toJSON with the value's key in its parent, and an element serialized
+// alone gets "" in place of its index. It writes a boxed primitive as the primitive. A plain object
+// or array with no toJSON is written as its own keys or items wherever it sits.
+const hasToJson = (value) => typeof value.toJSON === "function";
+function isPlainRecord(value) {
+    if (!isRecord(value) || hasToJson(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+const isPlainArray = (value) => Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype && !hasToJson(value);
+/** The document's text before the first element of `value[key]` and after its last. */
+function around(value, key) {
+    const keys = Object.keys(value);
+    const at = keys.indexOf(key);
+    const entries = (from, to) => Object.fromEntries(keys.slice(from, to).map((name) => [name, value[name]]));
+    const before = JSON.stringify({ ...entries(0, at), [key]: [] });
+    const after = JSON.stringify(entries(at + 1));
+    return [before.slice(0, -"]}".length), after === "{}" ? "]}" : `],${after.slice(1)}`];
+}
+/** `piece` up to and including its first slash or whitespace, or all of it when it has none. */
+function head(piece) {
+    const at = piece.search(SLASH_OR_SPACE);
+    return at === -1 ? piece : piece.slice(0, at + 1);
+}
+/** The scheme a sandbox URL could continue from after `piece`, given the one before it. */
+function schemeAfter(before, piece) {
+    let last = piece.length - 1;
+    while (last >= 0 && !SLASH_OR_SPACE.test(piece[last]))
+        last -= 1;
+    if (last === -1)
+        return before;
+    // `https:\/\/` is the longest scheme: ten characters ending at the slash.
+    return SCHEME_AT_END.exec(piece.slice(Math.max(0, last - 9), last + 1))?.[0];
+}

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

@@ -1,5 +1,6 @@
 import { collectDesktopRecording } from "../../evidence/desktop-recording-artifact.js";
 import path from "node:path";
+import { participantList } from "../../study/study-fields.js";
 import { inboxRecipientFor, } from "./participant-desktop.js";
 import { createLocalFirecrackerDesktop, } from "../../substrates/local/firecracker-desktop.js";
 import { localBrowserDefaults, localBrowserUnsupportedReason, } from "../../substrates/local/runtime-config.js";
@@ -139,11 +140,16 @@ function createLocalParticipantDesktop(context, run, warnings, artifactRoot) {
     };
 }
 /** The Codex account participant, whose unconfirmed cleanup blocks the study's analysis. */
-function accountProvider(state, maxWaitMs) {
-    return async ({ executor }) => {
+function accountProvider(state, config) {
+    return async ({ executor, participant: { index } }) => {
+        // The wait settings the participant's loop runs with (plan-participants.ts), so its tool
+        // description states them.
+        const maxWaitMs = config.actor?.maxWaitMs;
+        const idleWaitMs = participantList(config)?.[index]?.idleWaitMs ?? config.actor?.idleWaitMs;
         const participant = createRestrictedCodexParticipant({
             speechEnabled: executor.speechEnabled === true,
             ...(maxWaitMs === undefined ? {} : { maxWaitMs }),
+            ...(idleWaitMs === undefined ? {} : { idleWaitMs }),
         });
         state.participants.push(participant);
         const provider = Object.assign(participant.provider, {
@@ -185,7 +191,7 @@ export function prepareLocalVmRun(options) {
     const { config: _config, assets: _assets, signal: _signal, ...runOptions } = options;
     return {
         options: account
-            ? { ...runOptions, createProvider: accountProvider(state, config.actor?.maxWaitMs) }
+            ? { ...runOptions, createProvider: accountProvider(state, config) }
             : runOptions,
         localVm: {
             desktop: (run, warnings, artifactRoot) => createLocalParticipantDesktop(context, run, warnings, artifactRoot),

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

@@ -47,6 +47,9 @@ export async function startParticipantModel(spec, deps, executor) {
             ...(spec.planned.limits.maxWaitMs === undefined
                 ? {}
                 : { maxWaitMs: spec.planned.limits.maxWaitMs }),
+            ...(spec.planned.limits.idleWaitMs === undefined
+                ? {}
+                : { idleWaitMs: spec.planned.limits.idleWaitMs }),
             session: { env },
         });
         return { provider: codexParticipant.provider, codexParticipant };

package/dist/study/bundle-estimate.d.ts

@@ -16,6 +16,11 @@ export interface BundleEstimate {
     readonly runFileBytes: number;
     /** The largest participant trace file, which analysis also reads whole. */
     readonly largestTraceBytes: number;
+    /**
+     * Every participant's trace file together, whose items the run writer and the Observer page join
+     * in one string.
+     */
+    readonly tracesBytes: number;
     /** observer/index.html, which verify reads whole. */
     readonly observerPageBytes: number;
     /** Every file, screenshots included. */

package/dist/study/bundle-estimate.js

@@ -16,6 +16,13 @@
 // observer-data.json leaves the lists out too and was 0.94 to 1.12 of run.json's size on the live
 // runs measured, so it passes 32 MiB only after run.json passes 16 MiB, and the estimate does not
 // check it.
+// The Observer page and the Observer server join every participant's items in one string before
+// gzip. On a hosted desktop the sandbox id scrub (publicSandboxView) does too, on every write of
+// run.json and on a bundle export of the loaded run, which its 25 MiB default --max-bytes refuses
+// first. V8's longest string is 536,870,888 characters
+// on Node 24. A trace file's bytes are at least the characters of its items as compact JSON, so the
+// estimate compares the traces' bytes and may warn a little early.
+import { constants } from "node:buffer";
 import { EVIDENCE_LIMITS } from "../analysis/analysis-limits.js";
 import { RUN_ARTIFACT_MAX_BYTES } from "../run/contained-output.js";
 import { formatDuration } from "../run/projection.js";
@@ -156,6 +163,7 @@ export function estimateBundle(participants, sessionMs) {
     return {
         runFileBytes,
         largestTraceBytes: largestTrace,
+        tracesBytes: traces,
         observerPageBytes,
         // observer-data.json is about run.json's size.
         totalBytes: observerPageBytes + screenshots * RATES.screenshotBytes + traces + 2 * runFileBytes,
@@ -178,6 +186,7 @@ export function estimateBundle(participants, sessionMs) {
 export function bundleLimitReason(estimate) {
     const runFile = estimate.runFileBytes > EVIDENCE_LIMITS.sourceBytes;
     const page = estimate.observerPageBytes > RUN_ARTIFACT_MAX_BYTES;
+    const joined = estimate.tracesBytes > constants.MAX_STRING_LENGTH;
     const entries = estimate.entries > estimate.entryLimit;
     const passed = [
         ...(runFile
@@ -195,6 +204,11 @@ export function bundleLimitReason(estimate) {
                 `The Observer page, observer/index.html, may grow to about ${mib(estimate.observerPageBytes)}, past the ${mib(RUN_ARTIFACT_MAX_BYTES)} verify reads in one file.`,
             ]
             : []),
+        ...(joined
+            ? [
+                `All participants' traces together may grow to about ${mib(estimate.tracesBytes)}, past the ${mib(constants.MAX_STRING_LENGTH)} that fits in one string. On a hosted desktop, writing run.json puts them in one string, and so does a bundle export allowed past its 25 MiB default; the Observer page always does. run.json may then stop updating, that export would fail and the page would not build.`,
+            ]
+            : []),
         ...(entries
             ? [
                 `The run may hold about ${count(estimate.entries)} files and folders, past the ${count(estimate.entryLimit)} the public-safety scan reads in a run of ${plural(estimate.basis.participants, "participant")}.`,
@@ -222,7 +236,7 @@ export function bundleLimitReason(estimate) {
         ...(runFile ? ["shorten the mission (actor.mission)"] : []),
     ];
     // A trace is one participant's, so splitting the study helps only the run's own files.
-    if (runFile || page || entries || changes.length === 0)
+    if (runFile || page || joined || entries || changes.length === 0)
         changes.push("split the participants across studies");
     const advice = changes.length < 2
         ? changes.join("")

package/dist/study/types.d.ts

@@ -414,10 +414,11 @@ export interface StudyActor {
     maxWaitMs?: number;
     /**
      * Computer-use and shared-world: how long a `wait` that names no duration lasts when the
-     * participant's turn only waits or takes screenshots, and how often the loop looks at the screen
-     * while it watches such a turn, in whole milliseconds from 1000 to 600000 and no longer than
-     * maxWaitMs. Default 5000. After an action in the same turn such a wait lasts 500 ms. OpenAI's
-     * computer-use `wait` never names a duration.
+     * participant's turn only waits or takes screenshots, the shortest such a turn is watched for,
+     * and how often the loop looks at the screen while it watches such a turn, in whole milliseconds
+     * from 1000 to 600000 and no longer than maxWaitMs. Default 5000. After an action in the same
+     * turn such a wait lasts 500 ms. OpenAI's computer tool `wait` never names a duration; its
+     * wait_minutes function does.
      */
     idleWaitMs?: number;
     /**

package/dist/verify/verify.js

@@ -2,7 +2,8 @@ import path from "node:path";
 import { listAnalysisExecutions } from "../analysis/store-executions.js";
 import { loadAnalysis } from "../analysis/load.js";
 import { analysisSharingProblems } from "../analysis/sharing.js";
-import { containsSensitive, REDACTED_SANDBOX_ID } from "../evidence/redaction.js";
+import { REDACTED_SANDBOX_ID } from "../evidence/redaction.js";
+import { containsSensitiveJson } from "../evidence/sensitive-json.js";
 import { keyedSandboxIds, readRunSandboxIds } from "../run/sandbox-ids.js";
 import { validatePreparedRunArtifactPaths } from "../run/paths.js";
 import { isReadRunBundleSchema, RUN_BUNDLE_FILE, RUN_BUNDLE_SCHEMA, RUN_BUNDLE_V1_SCHEMA, RUN_BUNDLE_V2_SCHEMA, RUN_BUNDLE_V3_SCHEMA, } from "../run/bundle.js";
@@ -112,9 +113,10 @@ export async function verifyResolvedRun(cwd, runInput, runPaths) {
     addTraceScan(traces, publicSafetyFindings, unscannedArtifacts);
     // JSON escapes can hide a sensitive value from the byte scan while the
     // decoded recording exposes it to Observer, feedback, or analysis input.
+    // Each participant is scanned apart: together their traces can pass V8's longest string.
     if (publicSafetyFindings.length < MAX_REPORTED_FINDINGS &&
         recorded !== null &&
-        containsSensitive(JSON.stringify(recorded))) {
+        containsSensitiveJson(recorded, "streams")) {
         publicSafetyFindings.push("sensitive decoded run.json");
     }
     checks.push({

package/docs/architecture/actor-contract.md

@@ -176,6 +176,7 @@ export interface ActorTraceItem {
     looks: number;
     area?: { x: number; y: number; width: number; height: number }; // pixels, coordinates only
   };
+  namedMs?: number; // computer-use wait ui_action: the length the participant named, before any cap
 }
 
 export interface ActorCapabilities {

package/docs/architecture/browser-control.md

@@ -110,8 +110,8 @@ with speech, whose heard speech reaches the participant only with a screenshot),
 shortened` notice with both durations when it does, and sends the rest as consecutive waits of at
 most 30 seconds. The Codex participant's `humanish_ui` schema leaves a wait's length open for that
 reason; the wire still refuses a single wait over 30 seconds. A wait that names no duration, as
-every OpenAI computer-use wait does, reaches the desktop with a length too: 500 ms after an action
-in the same turn. A turn that only waits or takes screenshots sends no wait to the desktop: the
+the OpenAI computer tool's `wait` does, reaches the desktop with a length too: 500 ms after an
+action in the same turn. A turn that only waits or takes screenshots sends no wait to the desktop: the
 loop observes the screen every `actor.idleWaitMs` until it changes or the wait's time passes
 (`src/actors/computer-use/loop/watch.ts`), so a waiting participant costs one observe request per
 look.

package/docs/contracts/schemas.md

@@ -1082,14 +1082,17 @@ Core-owned fields:
   16 pixels counts once it holds still at a look; one of 24 tiles or fewer once
   it has held still for more than 65 s with no tile within 4 tiles of it ticking
   or moving with a region of more than 24 tiles
-  (`src/evidence/frame-change.ts`). The first watch lasts the turn's planned
-  length: the named waits' lengths, together up to `actor.maxWaitMs` (else
-  600000), and `idleWaitMs` for each wait that names none. Each further one in a row that ended
-  at its limit, or that a change of 24 tiles or fewer woke, lasts twice as long,
-  up to the larger of its planned length and that cap. `limitMs` is how long it
-  could last; `askedMs` is what the turn's waits asked for, the same sum with no
-  cap, so it is above `limitMs` when the named waits passed the cap and below it
-  when the watch grew; `wake` is `changed`, `speech`,
+  (`src/evidence/frame-change.ts`). The first watch's limit is the turn's
+  planned length: the named waits' lengths, together up to `actor.maxWaitMs` (else
+  600000), and `idleWaitMs` for each wait that names none, and at least
+  `idleWaitMs`. Each further one in a row that ended at its limit, or that a
+  change of 24 tiles or fewer woke, lasts twice as long, up to the larger of its
+  planned length and that cap. An OpenAI participant names a length with the
+  `wait_minutes` function tool; its computer tool's `wait` names none.
+  `limitMs` is how long it could last; `askedMs` is what the turn's
+  waits asked for, the same sum with no cap, so it is above `limitMs` when the
+  named waits passed the cap and below it when the watch grew or the named waits
+  were shorter than `idleWaitMs`; `wake` is `changed`, `speech`,
   `condition`, `limit`, `clock` (wind-down or end), `stalled` (a look got no
   frame; the next observation is a fresh one), or `stopped` (the study budget or
   the session's time ran out); `looks` counts its looks; `area` (`x`, `y`,
@@ -1100,6 +1103,14 @@ Core-owned fields:
   waits after the one carrying `watch` are titled `wait 0ms`. The look that
   ended a watch is the turn's `turn-NN` screenshot; other looks are not kept.
   Additive: absent on plain waits, other producers and older bundles
+- optional `items[].namedMs`, on the computer-use `ui_action` of each wait that
+  named its length: that length in milliseconds, as the participant named it,
+  before `actor.maxWaitMs` or the watch's cap applied. An OpenAI participant
+  names a length only through `wait_minutes`, so its waits with `namedMs` are
+  that tool's calls. Its waits without it are the computer tool's `wait`, a
+  `wait_minutes` call whose minutes were not a finite number above zero, and
+  a call to a function it does not have. Additive: absent on waits that named
+  none, other items and producers, and older bundles
 - optional `items[].page` and `finalPage` (`{ origin, path }`, `TracePage` in
   `src/actors/contract.ts`): where a computer-use participant's browser was. The loop puts `page`
   on the `screenshot` item of each observation that read a URL: `turn-00-start` is the page before
@@ -1183,8 +1194,9 @@ Core-owned fields:
   with the outputs that answered it, and the latest reply. Past an estimated
   64,000 input tokens it is cut down to 32,000 in one step: the opening
   screenshot is dropped first, then the oldest exchanges become lines of a note,
-  sent as an assistant message, that keeps their reasoning summaries, messages
-  and actions as text, with any text that came back with their screenshots.
+  sent as an assistant message, that keeps their reasoning summaries, messages,
+  actions and `wait_minutes` calls as text, with any text that came back with
+  their screenshots or in a function call's output, such as how a wait ended.
   Past 32,000 characters the note keeps its first four lines and its newest
   ones, and names the turns between them as not listed.
   The two newest exchanges are always carried whole, even when they alone pass

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.132.0",
+  "version": "0.133.0",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",