humanish 0.106.1 → 0.108.0

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

@@ -4,7 +4,7 @@ import { CUA_SPEECH_LIMITS } from "../speech.js";
 import { dwellCompleted, missingFrame, stopWhenMatched } from "./ending.js";
 import { CuaAbortError, CuaStallError, raceCallBound } from "./race.js";
 import { notice } from "./trace.js";
-// One projection feeds BOTH the stop guard and the task tracker, so a criterion that would stop
+// One projection feeds both the stop guard and the task tracker, so a criterion that would stop
 // the run and a criterion that completes a task can never see different evidence for one turn.
 function stopObservationOf(observation) {
     return {
@@ -72,8 +72,8 @@ export class DesktopObserver {
     }
     /**
      * Hand an observation the next turn may react to to the runtime hooks, and note whether it
-     * carried app state. Runtime-only: the seat's live location.href goes back to the orchestrator
-     * and is never persisted.
+     * carried app state. Runtime-only: the participant's live location.href goes back to the
+     * orchestrator and is never persisted.
      */
     handToHooks(observation) {
         const { onObservedUrl, onScreenshot } = this.session.settings;
@@ -118,7 +118,7 @@ export class DesktopObserver {
                 throw error;
         }
     }
-    // An executor without stallRecovery "fail_closed" gets one retry of a stalled observe (#480).
+    // An executor without stallRecovery "fail_closed" gets one retry of a stalled observe.
     // One that cannot safely replay a pending request opts out, so even a shorter outer bound stops
     // without retrying.
     async observeBounded(label) {
@@ -185,19 +185,19 @@ export class DesktopObserver {
         }));
         session.trace.bump("screenshots");
     }
-    // Evaluated BEFORE the stopWhen check each turn so a final task whose criterion coincides with
+    // Evaluated before the stopWhen check each turn so a final task whose criterion coincides with
     // the stop condition still lands in the funnel of the very turn that ends the session.
     observeTasks(observation, turnNumber) {
         const { taskTracker } = this.session;
         if (taskTracker === undefined)
             return;
         for (const completion of taskTracker.observe(stopObservationOf(observation), turnNumber)) {
-            // The id is researcher-authored config and the kinds are rule-type names; the matched VALUES
-            // (a URL, page text) never appear here — the same discipline as the stopWhen notice.
+            // The id is researcher-authored config and the kinds are rule-type names; the matched values
+            // (a URL, page text) never appear here: the same discipline as the stopWhen notice.
             this.session.trace.record("notice", () => notice("matched", `task completed: ${this.session.redactNarration(completion.id)}`, this.session.redactNarration(`turn ${turnNumber}; matched rule ${completion.matchedRuleIndex} (${completion.matchedKinds.join("+")})`)));
         }
     }
-    // The declared observation window (#510). The harness holds, looks, and takes nothing back to
+    // The declared observation window. The harness holds, looks, and takes nothing back to
     // the model: no action, no turn, no tokens. It runs once, cut to whatever session budget is
     // left, and says in the trace that the time was deliberate.
     async dwellIfDue(observation, turnNumber) {
@@ -238,7 +238,7 @@ export class DesktopObserver {
         }
         const heldMs = session.now() - dwellStartedAtMs;
         session.trace.record("notice", () => notice(
-        // A window that ENDS the session is structured, harness-owned completion evidence, the
+        // A window that ends the session is structured, harness-owned completion evidence, the
         // same class as a matched stopWhen, and the verdict resolver reads it that way.
         dwell.then === "stop" ? "matched" : "ok", "dwell window complete", `${frames} frame(s) over ${heldMs}ms; no model turn was requested during the window`));
         return { next: dwell.then, heldMs };

package/dist/actors/computer-use/loop/provider-call.d.ts

@@ -8,7 +8,7 @@ export type TurnReply = {
 };
 /**
  * Ask the provider for one turn. A fail_closed provider gets one single dispatch; any other is
- * raced against turnTimeoutMs (#469) and retried once when it stalls.
+ * raced against turnTimeoutMs and retried once when it stalls.
  */
 export declare function requestTurn(session: LoopSession, request: CuaTurnRequest, turnNumber: number): Promise<TurnReply>;
 /**

package/dist/actors/computer-use/loop/provider-call.js

@@ -12,7 +12,7 @@ import { reportedCounts, settledReceipt } from "./usage.js";
 const CUA_PROVIDER_CLEANUP_GRACE_MS = 5000;
 /**
  * Ask the provider for one turn. A fail_closed provider gets one single dispatch; any other is
- * raced against turnTimeoutMs (#469) and retried once when it stalls.
+ * raced against turnTimeoutMs and retried once when it stalls.
  */
 export async function requestTurn(session, request, turnNumber) {
     const { provider } = session;

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

@@ -7,7 +7,7 @@ import { UsageLedger } from "./usage.js";
 // (screenshot, wait, screenshot, wait), and a short idle limit ends that session as gave_up before
 // the mail can arrive.
 const DEFAULT_IDLE_STEPS = 24;
-// A no-progress turn also needs a repeated action (#383), so this needs less headroom than the
+// A no-progress turn also needs a repeated action, so this needs less headroom than the
 // idle limit.
 const DEFAULT_NO_PROGRESS_STEPS = 20;
 const DEFAULT_TURN_TIMEOUT_MS = 180_000;
@@ -105,9 +105,9 @@ export class LoopSession {
     remaining() {
         return this.timeoutMs - (this.now() - this.startedAtMs);
     }
-    // Model-authored narration: literal-scrub known provisioned values, THEN pattern-redact.
+    // Model-authored narration: literal-scrub known provisioned values, then pattern-redact.
     // A value the model transcribes (a DB password it read on screen) has no shape, so redactText
-    // alone cannot catch it — the lab's scrubKnownValues, injected as scrubText, closes that.
+    // alone cannot catch it; the lab's scrubKnownValues, injected as scrubText, closes that.
     redactNarration(text) {
         return this.settings.redaction.redactText(this.scrubText(text));
     }

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

@@ -8,8 +8,8 @@ export declare class LostRequestRefused extends Error {
 }
 /**
  * The spend caps, checked before the next provider request so a model stuck retrying cannot keep
- * spending. The lane cap stops the session once the running estimate crosses maxUsd; a null
- * estimate cannot trip it, because preflight guaranteed a rate. The study budget (#299) is checked
+ * spending. The per-participant cap stops the session once the running estimate crosses maxUsd; a null
+ * estimate cannot trip it, because preflight guaranteed a rate. The study budget is checked
  * next.
  */
 export declare function spendStop(session: LoopSession): Stop | undefined;

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

@@ -1,6 +1,6 @@
 import * as stops from "./ending.js";
 import { notice } from "./trace.js";
-// The spend guards. The lane cap (maxUsd) and the study budget (overRunBudget) are priced from
+// The spend guards. The per-participant cap (maxUsd) and the study budget (overRunBudget) are priced from
 // the usage each reply reports, plus a worst-case charge booked for each request lost without a
 // reply. A request whose cost is unknown and unbounded stops a capped session before the next one.
 /** Thrown through the provider when a lost attempt may not be sent again; carries the stop. */
@@ -13,8 +13,8 @@ export class LostRequestRefused extends Error {
 }
 /**
  * The spend caps, checked before the next provider request so a model stuck retrying cannot keep
- * spending. The lane cap stops the session once the running estimate crosses maxUsd; a null
- * estimate cannot trip it, because preflight guaranteed a rate. The study budget (#299) is checked
+ * spending. The per-participant cap stops the session once the running estimate crosses maxUsd; a null
+ * estimate cannot trip it, because preflight guaranteed a rate. The study budget is checked
  * next.
  */
 export function spendStop(session) {
@@ -29,7 +29,7 @@ export function spendStop(session) {
     if (overRunBudget) {
         const runStop = overRunBudget(session.usage.forCap());
         if (runStop !== null)
-            return stops.studySpendLimit(runStop);
+            return stops.runSpendLimit(runStop);
     }
     return undefined;
 }

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

@@ -20,7 +20,7 @@ export class TraceRecorder {
     constructor(now) {
         this.now = now;
     }
-    // The ONE recording choke point (#441): every trace item is stamped `at` from the
+    // The single recording choke point: every trace item is stamped `at` from the
     // loop's injected clock as it is recorded, so timed playback reads recorded facts
     // (deterministic in tests via the injected `now`). The id is allocated before the body is
     // built, so a body that fails to build (a redaction error) still consumes its id.
@@ -37,10 +37,10 @@ export class TraceRecorder {
 export function statusForCompletionReason(reason) {
     switch (reason) {
         case "goal_satisfied":
-        case "turn_completed": // turn_completed is a Codex-lane reason; this loop emits goal_satisfied
+        case "turn_completed": // turn_completed is a Codex reason; this loop emits goal_satisfied
             return "passed";
         // A session that ran out of time or budget did not reach its goal, whatever it achieved along
-        // the way. Calling that `passed` is how a truncated study came to be reported as a green one —
+        // the way. Calling that `passed` is how a truncated study came to be reported as a green one,
         // and why "raise the timeout" kept landing on the operator instead of on the tool. This switch
         // is exhaustive with no default, so a new completion reason forces a compile error here.
         case "budget_reached":
@@ -51,12 +51,12 @@ export function statusForCompletionReason(reason) {
             return "blocked";
         // A participant who stopped trying is the single most valuable thing a usability study
         // produces. Recording it as `failed` said the instrument broke, which is a different claim and
-        // a false one — see docs/principles/three-roles.md.
+        // a false one; see docs/principles/three-roles.md.
         case "gave_up":
             return "abandoned";
         // Only the harness failing is a harness failure.
         case "actor_error":
-        case "step_failed": // step_failed is the scripted-browser lane's reason; this loop never emits it
+        case "step_failed": // step_failed is the scripted-browser route's reason; this loop never emits it
         case "harness_error":
             return "failed";
     }
@@ -77,12 +77,12 @@ export function loopResult(session, stop, debrief) {
         ? "no screenshots captured"
         : session.redactScreenshots
             ? `${counts.screenshots} screenshot(s) redacted to blurred thumbnails via RedactionHooks`
-            : `${counts.screenshots} full-fidelity screenshot(s) retained for local use — NOT redacted for publishing; set redactScreenshots to blur a share-as-is bundle`;
-    // Self-describing artifact (invariant 6): when any observation carried structured app state,
+            : `${counts.screenshots} unblurred screenshot(s) kept for local use and not redacted for publishing; set redactScreenshots to blur screenshots in a bundle you plan to share`;
+    // Self-describing artifact: when any observation carried structured app state,
     // the trace says how the loop handled it: it fed progress and task checks and was not written to
     // the trace. The appState itself never appears in this bundle.
     const notes = session.observedAppState
-        ? `${screenshotNote}. App state was observed each turn to drive progress detection (a state-driven executor) and was NOT written to the trace — it is a runtime-only progress input, never persisted as evidence in this slice.`
+        ? `${screenshotNote}. App state was read each turn to detect progress (an in-process executor) and was not written to the trace: it is used only while the run is live and is never stored as evidence.`
         : screenshotNote;
     const tokenUsage = usage.tokenUsage();
     const trace = {
@@ -90,6 +90,7 @@ export function loopResult(session, stop, debrief) {
         provider: provider.id,
         ...usage.liveMetadata(),
         ...(provider.version === undefined ? {} : { providerVersion: provider.version }),
+        ...(provider.conversation === undefined ? {} : { conversation: provider.conversation }),
         protocol: "cua-loop",
         lane: "computer-use",
         persona: settings.persona,
@@ -130,8 +131,8 @@ export function loopResult(session, stop, debrief) {
         ...(usage.interactionUsageIncomplete(session.capDeclared)
             ? { interactionUsageIncomplete: true }
             : {}),
-        // The funnel is present exactly when a protocol was declared — including a session that ended
-        // on turn 0, whose funnel honestly reads 0/N. No tasks declared means no funnel, not an empty one.
+        // The funnel is present exactly when a protocol was declared, including a session that ended
+        // on turn 0, whose funnel reads 0/N. No tasks declared means no funnel, not an empty one.
         ...(session.taskTracker === undefined ? {} : { taskFunnel: session.taskTracker.funnel() }),
         ...(tokenUsage === undefined ? {} : { tokenUsage }),
         capabilities: provider.capabilities,

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

@@ -1,5 +1,5 @@
 import type { HeardSpeech } from "../speech.js";
-import type { ActorCapabilities, ActorExecutionProfile, ActorPersonaRef, ActorSessionResult, ActorTokenUsage, ActorTrace, ActorTraceItem, ParticipantClosingReport, ParticipantDeclaredOutcome, ProviderRequestReceipt } from "../../contract.js";
+import type { ActorCapabilities, ActorConversation, ActorExecutionProfile, ActorPersonaRef, ActorSessionResult, ActorTokenUsage, ActorTrace, ActorTraceItem, ParticipantClosingReport, ParticipantDeclaredOutcome, ProviderRequestReceipt } from "../../contract.js";
 import type { RedactionHooks } from "../../../evidence/redaction.js";
 import type { DwellWindow, StopWhen } from "../../stop-conditions.js";
 import type { LabTask } from "../../../lab/tasks.js";
@@ -93,7 +93,7 @@ export interface CuaObservation {
     url?: string;
     /**
      * The page's vertical scroll offset (window.scrollY), when the executor can read it. Scroll
-     * position is state (#393): inside a scroll-pinned section the viewport stays visually fixed
+     * position is state: inside a scroll-pinned section the viewport stays visually fixed
      * while the participant advances, so the frame hash alone reads "no change". Runtime-only like
      * url and text: it feeds the progress key, bucketed, and is never persisted.
      */
@@ -182,7 +182,7 @@ export interface CuaTurn {
     done: boolean;
     /** Explicit provider interruption, independent of actions or participant intent. */
     interruption?: "output_limit" | "token_limit" | "incomplete" | "unexpected_status";
-    /** The participant's own word for how it ended, when its reply format carries one (#570). */
+    /** The participant's own word for how it ended, when its reply format carries one. */
     outcome?: ParticipantDeclaredOutcome;
     /** Present only for an accepted structured closing account. */
     closingReport?: ParticipantClosingReport;
@@ -193,11 +193,13 @@ export interface CuaProvider {
     readonly requestPolicy?: "fail_closed";
     readonly executionProfile?: ActorExecutionProfile | undefined;
     readonly historyTurnsOmitted?: number;
+    /** How the conversation was carried between requests, for the trace. */
+    readonly conversation?: ActorConversation;
     readonly id: string;
     readonly version?: string | undefined;
     /**
      * The request settings this provider will actually send, for the trace to record. `version` says
-     * WHICH model; this says how it was asked to run. Optional: a provider with no such settings
+     * which model; this says how it was asked to run. Optional: a provider with no such settings
      * records none, and absence stays absence rather than becoming a default nobody chose.
      */
     readonly modelSettings?: {
@@ -229,7 +231,7 @@ export interface CuaProvider {
     nextTurn(req: CuaTurnRequest, signal: AbortSignal, spend?: CuaSpendGate): Promise<CuaTurn>;
     /** Optional read-only closing report. Implementations must disable tools and make no retries. */
     debrief?: ((req: CuaTurnRequest, signal: AbortSignal) => Promise<CuaTurn>) | undefined;
-    /** Release lane-owned model resources. Idempotent; reject if cleanup is unconfirmed. */
+    /** Release the participant's model resources. Idempotent; reject if cleanup is unconfirmed. */
     close?(): Promise<void>;
 }
 /** The desktop side of the loop. */
@@ -259,13 +261,13 @@ export interface CuaLoopOptions {
     /** Hard wall-clock runaway guard. The only count-free hard stop. */
     timeoutMs: number;
     /**
-     * Per-attempt bound on the provider call (#469), so a hung request is told apart from a
+     * Per-attempt bound on the provider call, so a hung request is told apart from a
      * participant still thinking. A stalled turn is retried once with a notice; a second stall ends
-     * the lane as harness_error.
+     * the participant as harness_error.
      */
     turnTimeoutMs?: number;
     /**
-     * Per-call bound on observation work (#480): executor.observe() and the idle actions (`wait`,
+     * Per-call bound on observation work: executor.observe() and the idle actions (`wait`,
      * `screenshot`), whose only job is to look. A `wait` adds its own ms to the bound. A stalled
      * observe is retried once; a stalled idle action is skipped with a notice.
      */
@@ -288,19 +290,19 @@ export interface CuaLoopOptions {
      */
     acknowledgeSafetyChecks?: (checks: CuaSafetyCheck[]) => CuaSafetyCheck[] | null;
     /**
-     * Redact (blur+downscale) persisted screenshots. Default FALSE — full-fidelity frames are
-     * retained, because the common case is a developer watching a sim of their OWN app locally
+     * Redact (blur+downscale) persisted screenshots. Default `false`: full-fidelity frames are
+     * retained, because the common case is a developer watching a sim of their own app locally
      * (gitignored .humanish), where blur destroys the core deliverable. Set true for unowned
-     * subjects or when the bundle is meant to be shared as-is. The frame sent to the PROVIDER is
+     * subjects or when the bundle is meant to be shared as-is. The frame sent to the provider is
      * always full-resolution regardless (the model must see the screen to act); this flag only
-     * governs what is PERSISTED. Publish-safety belongs at the publish boundary (commit scan / redactScreenshots), not capture.
+     * governs what is persisted. Publish-safety belongs at the publish boundary (commit scan / redactScreenshots), not capture.
      */
     redactScreenshots?: boolean;
     /**
-     * Extra literal scrub for KNOWN provisioned values (which have no detectable "shape", so
-     * pattern redaction cannot catch them), composed BEFORE redactText on every model-authored
+     * Extra literal scrub for known provisioned values (which have no detectable "shape", so
+     * pattern redaction cannot catch them), composed before redactText on every model-authored
      * text item (reasoning, message, completion summary) and the loop error. The lab passes the
-     * env-value scrubber here so a value the MODEL narrates can never land raw in the trace.
+     * env-value scrubber here so a value the model narrates can never land raw in the trace.
      * Default: identity (the loop is shape-only on its own).
      */
     scrubText?: (text: string) => string;
@@ -308,12 +310,12 @@ export interface CuaLoopOptions {
     writeScreenshot?: (name: string, bytes: Buffer) => Promise<string>;
     /**
      * Deterministic harness-owned success guards. Evaluated after the initial observation and after
-     * every post-action observation, before another model turn is requested. This keeps a lane from
+     * every post-action observation, before another model turn is requested. This keeps a participant from
      * wandering after the product already reached an app-visible endpoint.
      */
     stopWhen?: StopWhen;
     /**
-     * A declared observation window (#510): once its condition matches (or after the first
+     * A declared observation window: once its condition matches (or after the first
      * observation when it has none) the loop holds the page for the window, captures a frame on the
      * cadence, takes no action and requests no model turn, then hands control back or ends. Runs at
      * most once per session and never past the session budget.
@@ -322,11 +324,11 @@ export interface CuaLoopOptions {
     /** Injected pause for the dwell window's cadence; tests advance their clock through it. */
     sleep?: (ms: number) => Promise<void>;
     /**
-     * The lab's declared protocol (#414): discrete tasks whose completion is corroborated by the
+     * The lab's declared protocol: discrete tasks whose completion is corroborated by the
      * same observations stopWhen reads, on the same cadence. The tracker never influences the loop's
-     * control flow — a completed task list does not stop a session (that is stopWhen's job); it only
+     * control flow: a completed task list does not stop a session (that is stopWhen's job); it only
      * records the funnel that lands on the trace. The participant-facing halves of these tasks are
-     * already IN `instructions` (composed upstream); the loop reads only the `success` criteria,
+     * already in `instructions` (composed upstream); the loop reads only the `success` criteria,
      * which never reach the prompt.
      */
     tasks?: readonly LabTask[];
@@ -338,18 +340,18 @@ export interface CuaLoopOptions {
      */
     maxUsd?: number;
     /**
-     * Injected PURE per-turn cost estimator (keeps the loop free of the operator rate table and
+     * Injected pure per-turn cost estimator (keeps the loop free of the operator rate table and
      * makes the cap deterministic in tests). Given running (input, output) token totals, returns the
      * estimated USD, or null when unpriceable. Only consulted when `maxUsd` is set. A null estimate
-     * mid-run cannot trip the cap — preflight already guaranteed a rate exists, so a null here is a
+     * mid-run cannot trip the cap; preflight already guaranteed a rate exists, so a null here is a
      * vanished-rate harness condition, not a silent uncapped pass.
      */
     estimateTurnCostUsd?: (usage: ActorTokenUsage) => number | null;
     /**
-     * RUN-LEVEL spend guard (#299): called with this lane's running usage each turn, at the same
-     * point the per-lane cap is checked. Returns a human-readable reason when the STUDY's shared
+     * Run-level spend guard: called with this participant's running usage each turn, at the same
+     * point the per-participant cap is checked. Returns a human-readable reason when the study's shared
      * budget is exhausted, else null. On a non-null return the loop stops with `budget_reached`
-     * regardless of material progress — a study-level stop is a recruiting decision hitting its
+     * regardless of material progress: a study-level stop is a recruiting decision hitting its
      * limit, not this participant's runaway, so it never reads as `gave_up`.
      */
     overRunBudget?: (usage: ActorTokenUsage) => string | null;
@@ -368,6 +370,9 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public shared-world handoff (src/routes/shared-world/handoff.ts)
      * latches the host participant's lobby URL and checks that each follower reached the same lobby.
+     *
+     * @deprecated Wrap the executor's `observe` and read `url` from each observation it returns. The
+     * next minor removes this option.
      */
     onObservedUrl?: (url: string | undefined) => void;
     /**
@@ -378,6 +383,9 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public handoff scans the host's narration for the lobby code,
      * because the E2B desktop's CDP URL read behind onObservedUrl is unreliable.
+     *
+     * @deprecated Wrap the provider's `nextTurn` and read `reasoning` and `message` from each turn it
+     * returns. The next minor removes this option.
      */
     onMessage?: (text: string) => void;
     /**
@@ -387,10 +395,13 @@ export interface CuaLoopOptions {
      *
      * Built-in caller: the external-public handoff reads the lobby code off each participant's own
      * frame until that participant has one: the host's latch, or a follower's convergence observation.
+     *
+     * @deprecated Wrap the executor's `observe` and read `screenshot` from each observation it
+     * returns. The next minor removes this option.
      */
     onScreenshot?: (frame: Buffer) => void;
     /**
-     * Trace snapshot for a watcher (#441): the redacted items recorded so far, with the running
+     * Trace snapshot for a watcher: the redacted items recorded so far, with the running
      * usage so a run can be priced in flight. Called after each checkpoint's screenshot (the initial
      * observation and every acted turn, so a flush never shows an action without the frame before
      * it), after each dwell frame, and after a closing request. The array is a fresh copy; its items

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

@@ -80,7 +80,7 @@ export class UsageLedger {
     cachedInput = 0;
     cacheWriteInput = 0;
     output = 0;
-    // Per model-inference usage, in order (#334): the recorded fact long-context pricing tiers
+    // Per model-inference usage, in order: the recorded fact long-context pricing tiers
     // need. A continuing native tool interaction may contain several inference requests.
     turns = [];
     /** An interaction turn arrived without complete usage, or its receipt said usage is incomplete. */
@@ -245,7 +245,7 @@ export class UsageLedger {
             input: this.input,
             output: this.output,
             // Recorded only when the provider actually reported it, so a reader can tell "no cache
-            // hits" from "this provider does not say" (#391); same for cache writes (#334).
+            // hits" from "this provider does not say"; same for cache writes.
             ...(this.cachedInput > 0 ? { cachedInput: this.cachedInput } : {}),
             ...(this.cacheWriteInput > 0 ? { cacheWriteInput: this.cacheWriteInput } : {}),
             ...(this.turns.length > 0 ? { turns: this.turns.map((turn) => ({ ...turn })) } : {}),

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

@@ -187,11 +187,11 @@ function stopBeforeActing(session, turn, turnNumber) {
         return stops.accountBilledCaps;
     if (turn.interruption !== undefined) {
         // Preserve usage and partial narration of an interrupted response. Its usage still counts
-        // toward the study budget; when that exhausts it, sibling lanes stop, so this trace says why.
-        const studyStop = overRunBudget?.(session.usage.forCap());
+        // toward the study budget; when that exhausts it, sibling participants stop, so this trace says why.
+        const runBudgetStop = overRunBudget?.(session.usage.forCap());
         recordNarration(session, turn, turnNumber, "interrupted");
-        if (studyStop != null) {
-            session.trace.record("notice", () => notice("warn", "study budget reached during an interrupted response", studyStop));
+        if (runBudgetStop != null) {
+            session.trace.record("notice", () => notice("warn", "study budget reached during an interrupted response", runBudgetStop));
         }
         return stops.providerInterrupted(turn.interruption);
     }

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

@@ -0,0 +1,37 @@
+/** The estimated input a carried conversation may reach before its oldest turns are summarized. */
+export declare const CONTEXT_TOKEN_BUDGET = 64000;
+/** What the next request would carry, for the trace. */
+export interface CarriedContextSize {
+    readonly exchanges: number;
+    readonly screenshots: number;
+    readonly notedTurns: number;
+    readonly estimatedTokens: number;
+}
+export declare class CarriedConversation {
+    private readonly budget;
+    private opening;
+    private readonly exchanges;
+    /** The latest accepted reply's output items, which the next request answers. */
+    private pending;
+    private readonly notes;
+    private notesDropped;
+    private collapsedTurns;
+    constructor(budget?: number);
+    /**
+     * Record an accepted reply. `sent` is what that request added after the carried items: the
+     * opening message on the first request, then the call outputs and any hint.
+     */
+    accept(turn: number, sent: readonly unknown[], output: readonly unknown[]): void;
+    /** The items to send ahead of a request's own new items. */
+    carried(): unknown[];
+    /** The carried context's size, for the trace. */
+    size(): CarriedContextSize;
+    private trim;
+    private noteItem;
+}
+/**
+ * A rough input-token estimate: images by their size in 32-pixel patches, everything else at four
+ * characters a token. It decides when to trim, not what is billed; the trace records the billed
+ * input per request beside it.
+ */
+export declare function estimateTokens(items: readonly unknown[]): number;