humanish 0.131.1 → 0.133.0

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 { buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, 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. */
@@ -33,6 +38,8 @@ export class OpenAiConversation {
     /** Undefined once the account or model rejected reasoning summaries. */
     reasoningSummary;
     evidence;
+    /** The items of a closing request whose reply was not the stated JSON, for its strict retry. */
+    openClosing;
     constructor(settings) {
         this.settings = settings;
         this.mode = settings.zeroDataRetention ? "explicit_context" : "threaded";
@@ -40,16 +47,44 @@ export class OpenAiConversation {
         this.evidence = new ConversationRecord(settings.zeroDataRetention, settings.now);
     }
     /**
-     * The next request, carrying `req`'s screen: the opening request, or the outputs the latest
-     * reply's computer calls are owed. A closing request asks for strict JSON and no tools.
+     * The next participant turn's request, carrying `req`'s screen: the opening request, or the
+     * outputs the latest reply's computer and function calls are owed.
      */
-    request(req, closing) {
+    request(req) {
         const sent = this.newItems(req);
         return {
-            body: () => closing === undefined ? this.turnBody(req, sent) : this.closingBody(req, sent, closing),
-            accept: (reply) => this.accept(reply, closing, sent),
+            body: () => this.turnBody(req, sent),
+            accept: (reply) => this.accept(reply, sent),
         };
     }
+    /**
+     * The read-only closing request carrying `req`'s screen, sent once with `send`. It goes out
+     * without text.format, which is part of the cached prefix, so it reads the session from the
+     * cache. A completed reply that is not JSON the schema accepts comes back marked closingRetry and
+     * leaves the conversation where it was, so the next closing request is the same one with the
+     * strict schema set. Returns the reply's turn with the account it gave.
+     */
+    async close(req, closing, send) {
+        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, 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.
+        if (closing === "impressions")
+            this.evidence.requested(this.mode, this.carried, sent, closing);
+        const completed = asRecord(reply).status === "completed";
+        const parsed = parseOpenAiResponse(reply);
+        const account = completed ? closingAccount(parsed.turn.message, closing, strict) : undefined;
+        // A refusal would most likely stand under the strict schema too, so it is not asked again.
+        if (completed && account === undefined && !strict && !refused(reply)) {
+            this.openClosing = sent;
+            return { ...parsed.turn, closingRetry: true };
+        }
+        this.moveOn(parsed, sent);
+        return { ...parsed.turn, ...account };
+    }
     /**
      * The organization rejected server-side state: carry the conversation on the client from the
      * request being sent, and record which answer made the switch. False when the conversation is
@@ -78,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 {
@@ -111,8 +173,9 @@ export class OpenAiConversation {
      */
     turnBody(req, sent) {
         const ctx = this.context(req.instructions);
+        // `sent` is the opening message, and on a closing request also the ask and the reply's form.
         if (this.replies === 0)
-            return buildInitialRequest(ctx, req.observation.screenshot);
+            return { ...buildInitialRequest(ctx, req.observation.screenshot), input: [...sent] };
         return buildContinuationRequest({
             ctx,
             previousResponseId: this.lastResponseId,
@@ -120,36 +183,84 @@ export class OpenAiConversation {
             ...(this.mode === "explicit_context" ? { explicitContextItems: this.carried.carried() } : {}),
         });
     }
-    /** A read-only closing request: no tools, its own output limit, a strict schema. */
-    closingBody(req, sent, closing) {
+    /**
+     * A read-only closing request: the next turn's body with tools off and its own output limit,
+     * and the strict schema only when `schema` is set.
+     */
+    closingBody(req, sent, closing, schema) {
         return {
             ...this.turnBody(req, sent),
             tool_choice: "none",
             max_output_tokens: Math.min(this.settings.maxOutputTokens ?? CLOSING_OUTPUT_LIMIT, CLOSING_OUTPUT_LIMIT),
-            text: { format: CLOSING_FORMATS[closing] },
+            ...(schema ? { text: { format: CLOSING_FORMATS[closing] } } : {}),
         };
     }
     /**
-     * Move the conversation on to a reply to a request that added `sent`. A participant reply cut
-     * off by the output limit is set aside, so the next request is the same one again
-     * (outputLimitRetry); its actions never run, so no call output is owed for them.
+     * A participant turn's reply to a request that added `sent`. A reply cut off by the output
+     * limit is set aside, so the next request is the same one again (outputLimitRetry); its actions
+     * never run, so no call output is owed for them.
      */
-    accept(reply, closing, sent) {
+    accept(reply, sent) {
         // Recorded before the reply is accepted: accepting can cut the carried history, and the record
         // counts what this request carried.
-        if (closing !== "report")
-            this.evidence.requested(this.mode, this.carried, sent, closing);
+        this.evidence.requested(this.mode, this.carried, sent);
         const parsed = parseOpenAiResponse(reply);
-        if (closing === undefined && parsed.turn.interruption === "output_limit")
+        if (parsed.turn.interruption === "output_limit")
             return parsed.turn;
+        this.moveOn(parsed, sent);
+        return parsed.turn;
+    }
+    /** Move the conversation on to a reply to a request that added `sent`. */
+    moveOn(parsed, sent) {
         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);
-        return parsed.turn;
     }
 }
+/** 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.
+ */
+function replyForm(closing) {
+    const text = `Reply with only a JSON object that matches this JSON Schema, with no other text: ${JSON.stringify(CLOSING_FORMATS[closing].schema)}`;
+    return inputMessage("user", [{ type: "input_text", text }]);
+}
+/**
+ * The account a closing reply's text gives: JSON the request's schema accepts, or none. A reply
+ * sent without text.format must give every field the stated schema requires. With text.format the
+ * provider holds the reply to that schema, and the check is the one any provider's report gets.
+ */
+function closingAccount(message, closing, strict) {
+    // Without text.format a model may set the object in a code fence or after a message of its own.
+    const text = message ?? "";
+    let reply;
+    try {
+        reply = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+    }
+    catch {
+        return undefined;
+    }
+    if (closing === "report") {
+        const report = (strict ? closingReportSchema : closingReportSchema.required()).safeParse(reply);
+        return report.success ? { closingReport: report.data } : undefined;
+    }
+    const impressions = impressionsReplySchema.safeParse(reply);
+    return impressions.success ? { impressions: impressions.data.impressions } : undefined;
+}
+/** Whether a reply's messages include a refusal, which carries no output_text. */
+function refused(reply) {
+    return asArray(asRecord(reply).output).some((item) => asArray(asRecord(item).content).some((part) => asRecord(part).type === "refusal"));
+}
 /** The trace's account of how a session carried its conversation (ActorConversation). */
 class ConversationRecord {
     now;

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

@@ -1,8 +1,7 @@
-import { closingReportSchema, impressionsReplySchema } from "../closing-report.js";
 import { ComputerUseAdmissionLimitError, isComputerUseAdmissionLimitError, } from "./admission-limit.js";
 import { ComputerUsePromptRefusedError } from "./provider-error.js";
 import { OpenAiConversation, } from "./openai-conversation.js";
-import { asRecord, optionalString } from "./openai-wire.js";
+import { optionalString } from "./openai-wire.js";
 import { redactText } from "../../evidence/redaction.js";
 import { isMaxOutputTokens } from "../output-token-limit.js";
 import { prepareContainedOutputFile, prepareSelectedOutputDirectory, writeContainedOutputFile, } from "../../run/contained-output.js";
@@ -455,38 +454,15 @@ export function createOpenAiResponsesProvider(options) {
             }
         }
     };
-    const requestTurn = async (req, signal, closing, spend) => {
+    const requestTurn = async (req, signal, spend) => {
         await capture.prepareNext();
-        const request = conversation.request(req, closing);
-        // A closing request makes exactly one request: no HTTP or policy-latch retries.
-        const raw = closing === undefined
-            ? await postTurn(request, signal, spend)
-            : await post(request.body(), signal, 0, false);
-        const turn = request.accept(raw);
-        if (closing !== undefined) {
-            // Refusals, incomplete output, malformed JSON, and invalid shapes remain no-report results.
-            // Never promote raw JSON or a fallback paragraph into a structured finding.
-            try {
-                const reply = JSON.parse(turn.message ?? "");
-                if (asRecord(raw).status === "completed") {
-                    if (closing === "report") {
-                        const report = closingReportSchema.safeParse(reply);
-                        if (report.success)
-                            return { ...turn, closingReport: report.data };
-                    }
-                    else {
-                        const impressions = impressionsReplySchema.safeParse(reply);
-                        if (impressions.success)
-                            return { ...turn, impressions: impressions.data.impressions };
-                    }
-                }
-            }
-            catch {
-                /* A failed optional closing account keeps its usage and no report. */
-            }
-        }
-        return turn;
+        const request = conversation.request(req);
+        return request.accept(await postTurn(request, signal, spend));
     };
+    // Each closing request is posted once: no HTTP or policy-latch retries. A reply with no valid
+    // account keeps its usage and gives no report: refusals, incomplete output, malformed JSON and
+    // invalid shapes are never promoted into a structured finding.
+    const requestClosing = (req, signal, closing) => conversation.close(req, closing, (body) => post(body, signal, 0, false));
     return {
         id: "openai-responses-cu",
         version: model,
@@ -505,7 +481,7 @@ export function createOpenAiResponsesProvider(options) {
         get interactionUsageIncomplete() {
             return interactionUsageIncomplete;
         },
-        nextTurn: (req, signal, spend) => requestTurn(req, signal, undefined, spend),
+        nextTurn: (req, signal, spend) => requestTurn(req, signal, spend),
         get conversation() {
             return conversation.record();
         },
@@ -513,7 +489,7 @@ export function createOpenAiResponsesProvider(options) {
         // explicit_context one carries its newest screens whole and its oldest turns summarized past
         // the budget, which the trace's conversation record counts. A participant that worked a long
         // session writes its closing account from what it carries, as a person writes one from memory.
-        debrief: (req, signal) => requestTurn(req, signal, "report"),
-        requestImpressions: (req, signal) => requestTurn(req, signal, "impressions"),
+        debrief: (req, signal) => requestClosing(req, signal, "report"),
+        requestImpressions: (req, signal) => requestClosing(req, signal, "impressions"),
     };
 }

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;