humanish 0.100.1 → 0.102.0

package/dist/computer-use.d.ts

@@ -1,3 +1,5 @@
+import { type HeardSpeech } from "./cua-speech.js";
+export { CUA_SPEECH_LIMITS, type HeardSpeech } from "./cua-speech.js";
 import { type ActorCapabilities, type ActorCompletionReason, type ActorPersonaRef, type ActorStatus, type ActorTokenUsage, type ActorTrace, type ActorTraceItem, type ParticipantDeclaredOutcome, type ParticipantClosingReport } from "./actor-contract.js";
 import type { ActorExecutionProfile, ProviderRequestReceipt } from "./actor-contract.js";
 import type { RedactionHooks } from "./redaction.js";
@@ -38,6 +40,9 @@ export type CuaAction = {
 } | {
     kind: "wait";
     ms?: number;
+} | {
+    kind: "speak";
+    text: string;
 } | {
     kind: "screenshot";
 };
@@ -93,6 +98,8 @@ export interface CuaObservation {
     scrollY?: number;
     title?: string;
     text?: string;
+    /** Finalized speech captured from the participant's speaker sink. */
+    heardSpeech?: HeardSpeech[];
 }
 /**
  * A safety check the model raised. The triple is preserved verbatim from the
@@ -127,6 +134,8 @@ export interface CuaTurnRequest {
     contextHint?: string;
 }
 export interface CuaTurn {
+    /** This action proposal yielded from a provider request that remains active. No receipt or usage is settled yet. */
+    providerRequestPending?: true;
     providerRequest?: ProviderRequestReceipt;
     /** Continuation handle for the next turn. */
     responseId?: string;
@@ -144,6 +153,13 @@ export interface CuaTurn {
         output?: number;
         cachedInput?: number;
         cacheWriteInput?: number;
+        /** Per model inference inside this provider interaction. */
+        turns?: Array<{
+            input?: number;
+            output?: number;
+            cachedInput?: number;
+            cacheWriteInput?: number;
+        }>;
     };
     /** True when the model reported a natural endpoint (no further action). */
     done: boolean;
@@ -158,10 +174,10 @@ export interface CuaTurn {
 export interface CuaProvider {
     /** Single dispatch; the promise includes owned request cleanup. No stall retry. */
     readonly requestPolicy?: "fail_closed";
-    readonly executionProfile?: ActorExecutionProfile;
+    readonly executionProfile?: ActorExecutionProfile | undefined;
     readonly historyTurnsOmitted?: number;
     readonly id: string;
-    readonly version?: 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
@@ -188,6 +204,8 @@ export interface CuaProvider {
     /** Latched uncertainty from hidden interactive attempts (for example, a transport retry).
      *  A later success or pre-dispatch refusal cannot make earlier unreported usage complete. */
     readonly interactionUsageIncomplete?: boolean;
+    /** Latest known usage for the active, unsettled request. Used only for runtime spend guards. */
+    readonly pendingRequestUsage?: CuaTurn["usage"];
     nextTurn(req: CuaTurnRequest, signal: AbortSignal): Promise<CuaTurn>;
     /** Optional read-only closing report. Implementations must disable tools and make no retries. */
     debrief?: ((req: CuaTurnRequest, signal: AbortSignal) => Promise<CuaTurn>) | undefined;
@@ -201,6 +219,8 @@ export interface CuaExecutor {
      * legacy observation/idle stall recovery. Wrappers must preserve this value.
      */
     readonly stallRecovery?: "fail_closed";
+    /** True only when this executor can play a `speak` action into the participant microphone. */
+    readonly speechEnabled?: boolean;
     /** Capture the current desktop frame and its state signature. */
     observe(): Promise<CuaObservation>;
     /**

package/dist/computer-use.js

@@ -1,3 +1,5 @@
+import { CUA_SPEECH_LIMITS } from "./cua-speech.js";
+export { CUA_SPEECH_LIMITS } from "./cua-speech.js";
 import { ACTOR_TRACE_SCHEMA } from "./actor-contract.js";
 import { CuaProviderError, isCuaProviderError } from "./cua-provider-error.js";
 import { classifyCuaAction, summarizeAffordanceUse } from "./affordance.js";
@@ -20,11 +22,29 @@ export function validClosingReport(value) {
 function validTokenCount(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+function normalizedUsageTurns(usage) {
+    if (!Array.isArray(usage.turns) || usage.turns.length === 0)
+        return undefined;
+    const fields = ["input", "output", "cachedInput", "cacheWriteInput"];
+    const turns = [];
+    for (const raw of usage.turns) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        if (fields.every(field => raw[field] === undefined) || fields.some(field => raw[field] !== undefined && !validTokenCount(raw[field])))
+            return undefined;
+        if ((raw.cachedInput ?? 0) + (raw.cacheWriteInput ?? 0) > (raw.input ?? 0))
+            return undefined;
+        turns.push(Object.fromEntries(fields.flatMap(field => raw[field] === undefined ? [] : [[field, raw[field]]])));
+    }
+    return fields.every(field => turns.reduce((sum, turn) => sum + (turn[field] ?? 0), 0) === (usage[field] ?? 0))
+        ? turns : undefined;
+}
 function completeTurnUsage(usage) {
     return usage !== undefined && validTokenCount(usage.input) && validTokenCount(usage.output)
         && (usage.cachedInput === undefined || validTokenCount(usage.cachedInput))
         && (usage.cacheWriteInput === undefined || validTokenCount(usage.cacheWriteInput))
-        && (usage.cachedInput ?? 0) + (usage.cacheWriteInput ?? 0) <= usage.input;
+        && (usage.cachedInput ?? 0) + (usage.cacheWriteInput ?? 0) <= usage.input
+        && (usage.turns === undefined || normalizedUsageTurns(usage) !== undefined);
 }
 // Waiting is a legitimate strategy, not idleness. A persona told to sign up and verify by email
 // polls its inbox — screenshot, wait, screenshot, wait — and at 6 steps that ended the session as
@@ -62,6 +82,8 @@ export function actionFingerprint(actions) {
                 return `scroll@${bucket(action.x)},${bucket(action.y)}:${Math.sign(action.dx)},${Math.sign(action.dy)}`;
             case "type":
                 return `type:${action.text.length}`;
+            case "speak":
+                return `speak:${action.text.length}`;
             case "keypress":
                 return `keypress:${action.keys.join("+")}`;
             case "drag":
@@ -195,6 +217,8 @@ export function describeCuaAction(action) {
             return `scroll (${action.dx}, ${action.dy}) at (${action.x}, ${action.y})`;
         case "type":
             return `type [${action.text.length} chars]`;
+        case "speak":
+            return `speak [${action.text.length} chars]`;
         case "keypress":
             return `keypress ${action.keys.join("+")}`;
         case "drag":
@@ -389,9 +413,44 @@ export async function runComputerUseLoop(options) {
     let usageInput = 0;
     let usageCachedInput = 0;
     let usageCacheWriteInput = 0;
-    // Per provider-REQUEST usage, in order (#334): the recorded fact long-context pricing tiers
-    // need — totals alone cannot say which requests crossed the provider's threshold.
+    let usageOutput = 0;
+    let sawUsage = false;
+    let incompleteInteractionUsage = false;
+    let unreportedInteractionUsage = false;
+    let interactionRequestPending = false;
+    // Per model-inference usage, in order (#334): the recorded fact long-context pricing tiers
+    // need. A continuing native tool interaction may contain several inference requests.
     const usageTurns = [];
+    const knownPendingUsage = () => {
+        const usage = interactionRequestPending ? provider.pendingRequestUsage : undefined;
+        if (!completeTurnUsage(usage))
+            return undefined;
+        const turns = usage.turns === undefined ? undefined : normalizedUsageTurns(usage);
+        return { input: usage.input, output: usage.output,
+            ...(usage.cachedInput === undefined ? {} : { cachedInput: usage.cachedInput }),
+            ...(usage.cacheWriteInput === undefined ? {} : { cacheWriteInput: usage.cacheWriteInput }),
+            ...(turns === undefined ? {} : { turns }) };
+    };
+    const withPendingUsage = (settled) => {
+        const pendingUsage = knownPendingUsage();
+        if (pendingUsage === undefined)
+            return settled;
+        const input = (settled.input ?? 0) + pendingUsage.input;
+        const output = (settled.output ?? 0) + pendingUsage.output;
+        return {
+            ...settled,
+            input,
+            output,
+            ...((settled.cachedInput !== undefined || pendingUsage.cachedInput !== undefined)
+                ? { cachedInput: (settled.cachedInput ?? 0) + (pendingUsage.cachedInput ?? 0) } : {}),
+            ...((settled.cacheWriteInput !== undefined || pendingUsage.cacheWriteInput !== undefined)
+                ? { cacheWriteInput: (settled.cacheWriteInput ?? 0) + (pendingUsage.cacheWriteInput ?? 0) } : {}),
+            turns: [...(settled.turns ?? []), ...(pendingUsage.turns ?? [{ input: pendingUsage.input, output: pendingUsage.output,
+                        ...(pendingUsage.cachedInput === undefined ? {} : { cachedInput: pendingUsage.cachedInput }),
+                        ...(pendingUsage.cacheWriteInput === undefined ? {} : { cacheWriteInput: pendingUsage.cacheWriteInput }) }])],
+            ...(settled.total === undefined ? {} : { total: input + output })
+        };
+    };
     // The running usage snapshot both spend guards consume: totals plus the per-request ledger,
     // shaped exactly like the trace's final tokenUsage so one estimator prices both identically.
     // Unlike the persisted trace (where absent means "unreported"), this runtime callback arg
@@ -408,18 +467,16 @@ export async function runComputerUseLoop(options) {
         ...(providerRequests.length > 0 && providerRequests.every(r => r.usageComplete && completeTurnUsage(r.usage))
             ? { total: usageInput + usageOutput } : {})
     });
-    const runningUsage = () => provider.executionProfile?.billing === "account-unknown" ? accountUsage() : ({
+    const runningUsage = () => withPendingUsage(provider.executionProfile?.billing === "account-unknown" ? accountUsage() : ({
         input: usageInput,
         output: usageOutput,
         cachedInput: usageCachedInput,
         cacheWriteInput: usageCacheWriteInput,
         ...(usageTurns.length > 0 ? { turns: usageTurns } : {})
-    });
-    let usageOutput = 0;
-    let sawUsage = false;
-    let incompleteInteractionUsage = false;
-    let unreportedInteractionUsage = false;
+    }));
     const hasUnreportedInteractionUsage = () => unreportedInteractionUsage || provider.interactionUsageIncomplete === true;
+    const usageUnavailableForCap = () => incompleteInteractionUsage || unreportedInteractionUsage ||
+        (interactionRequestPending ? knownPendingUsage() === undefined : provider.interactionUsageIncomplete === true);
     let lastResponseId;
     let currentPhase = "initializing computer-use loop";
     let lastActionTitle;
@@ -431,9 +488,14 @@ export async function runComputerUseLoop(options) {
         counts[key] = (counts[key] ?? 0) + 1;
     };
     const recordUsage = (turn, interaction = true) => {
-        if (interaction && (!completeTurnUsage(turn.usage) || turn.providerRequest?.usageComplete === false))
-            incompleteInteractionUsage = true;
+        if (turn.providerRequestPending === true)
+            return;
         const raw = turn.usage;
+        const turns = raw?.turns === undefined ? undefined : normalizedUsageTurns(raw);
+        if (interaction && (!completeTurnUsage(raw) || turn.providerRequest?.usageComplete === false))
+            incompleteInteractionUsage = true;
+        if (interaction && raw?.turns !== undefined && turns === undefined)
+            unreportedInteractionUsage = true;
         if (raw === undefined)
             return;
         const usage = {
@@ -449,7 +511,10 @@ export async function runComputerUseLoop(options) {
         usageCachedInput += usage.cachedInput ?? 0;
         usageCacheWriteInput += usage.cacheWriteInput ?? 0;
         usageOutput += usage.output ?? 0;
-        usageTurns.push(usage);
+        if (raw.turns === undefined)
+            usageTurns.push(usage);
+        else if (turns !== undefined)
+            usageTurns.push(...turns);
     };
     /** Marked providers own one attempt through settlement; an outer race never retries it. */
     const markedRequest = async (request, kind, capMs) => {
@@ -463,6 +528,7 @@ export async function runComputerUseLoop(options) {
         let failure;
         let failed = false;
         let accepted;
+        let pendingYield = false;
         const pending = Promise.resolve().then(() => {
             if (controller.signal.aborted)
                 throw new CuaProviderError("cancelled", { dispatched: false, usageComplete: false, cleanup: "confirmed" });
@@ -471,9 +537,18 @@ export async function runComputerUseLoop(options) {
         void pending.catch(() => undefined);
         try {
             accepted = await raceBounded(`participant ${kind}`, pending, remaining(), capMs, signal);
-            const r = accepted.providerRequest;
-            if (!r || r.dispatched !== true || typeof r.usageComplete !== "boolean" || r.cleanup !== "confirmed") {
-                throw new CuaProviderError("invalid_response", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, accepted.usage);
+            if (accepted.providerRequestPending === true) {
+                if (kind !== "interaction" || accepted.done || accepted.actions.length === 0 || accepted.pendingSafetyChecks.length > 0 ||
+                    accepted.providerRequest !== undefined || accepted.usage !== undefined || accepted.interruption !== undefined || accepted.closingReport !== undefined) {
+                    throw new CuaProviderError("invalid_response", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" });
+                }
+                pendingYield = true;
+            }
+            else {
+                const r = accepted.providerRequest;
+                if (!r || r.dispatched !== true || typeof r.usageComplete !== "boolean" || r.cleanup !== "confirmed") {
+                    throw new CuaProviderError("invalid_response", { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" }, accepted.usage);
+                }
             }
         }
         catch (error) {
@@ -495,6 +570,10 @@ export async function runComputerUseLoop(options) {
                 }
             }
         }
+        if (!failed && pendingYield) {
+            interactionRequestPending = true;
+            return accepted;
+        }
         const final = settlement;
         const typed = isCuaProviderError(failure) ? failure : final && "error" in final && isCuaProviderError(final.error) ? final.error : undefined;
         const turn = final && "turn" in final ? final.turn : undefined;
@@ -502,14 +581,15 @@ export async function runComputerUseLoop(options) {
         const receipt = raw && (typeof raw.dispatched === "boolean" || raw.dispatched === "unknown") &&
             typeof raw.usageComplete === "boolean" && ["confirmed", "unconfirmed"].includes(raw.cleanup) ? { dispatched: raw.dispatched, usageComplete: raw.usageComplete, cleanup: raw.cleanup }
             : { dispatched: "unknown", usageComplete: false, cleanup: "unconfirmed" };
-        const rawUsage = typed?.usage ?? turn?.usage;
+        const rawUsage = typed?.usage ?? (turn?.providerRequestPending === true ? undefined : turn?.usage);
         const usage = rawUsage === undefined ? undefined : Object.fromEntries(["input", "output", "cachedInput", "cacheWriteInput", "total"].flatMap(key => {
             const value = rawUsage[key];
             return validTokenCount(value) ? [[key, value]] : [];
         }));
         // restricted-codex-session sets dispatched only after initialize/config/account/
         // thread/MCP admission, immediately before turn/start; it is not a success claim.
-        providerRequests.push({ ordinal: providerRequests.length + 1, kind, ...receipt,
+        const settledKind = interactionRequestPending ? "interaction" : kind;
+        providerRequests.push({ ordinal: providerRequests.length + 1, kind: settledKind, ...receipt,
             profileVerified: provider.executionProfile !== undefined && receipt.dispatched === true,
             ...(typed ? { errorCode: typed.code, ...(typed.failurePhase === undefined ? {} : { failurePhase: typed.failurePhase }) } : {}),
             ...(usage === undefined ? {} : { usage: { ...usage } }) });
@@ -518,11 +598,12 @@ export async function runComputerUseLoop(options) {
             record({ id: nextId("notice"), kind: "notice", lifecycle: "completed", status: "error",
                 title: "participant request cleanup unconfirmed", text: "The request did not confirm cleanup within the settlement boundary. No further participant request or action is admitted." });
         }
-        if (kind === "interaction" && receipt.dispatched !== false && (!receipt.usageComplete || !completeTurnUsage(usage)))
+        if (settledKind === "interaction" && receipt.dispatched !== false && (!receipt.usageComplete || !completeTurnUsage(usage)))
             unreportedInteractionUsage = true;
+        interactionRequestPending = false;
         if (failed) {
             if (usage)
-                recordUsage({ actions: [], pendingSafetyChecks: [], done: false, usage, providerRequest: receipt }, kind === "interaction");
+                recordUsage({ actions: [], pendingSafetyChecks: [], done: false, usage, providerRequest: receipt }, settledKind === "interaction");
             if (failure instanceof CuaAbortError || failure instanceof CuaDeadlineError)
                 throw failure;
             if (failure instanceof CuaStallError)
@@ -667,6 +748,24 @@ export async function runComputerUseLoop(options) {
                 return await raceBounded(`observe (${label}, retry)`, executor.observe(), remaining(), observationTimeoutMs, signal);
             }
         };
+        const seenSpeechIds = new Set();
+        let pendingHeardSpeech = [];
+        let heardSpeechChanged = false;
+        const collectHeardSpeech = (value) => {
+            for (const utterance of value.heardSpeech ?? []) {
+                if (seenSpeechIds.has(utterance.id))
+                    continue;
+                seenSpeechIds.add(utterance.id);
+                pendingHeardSpeech.push(utterance);
+                heardSpeechChanged = true;
+                record({ id: nextId("notice"), kind: "notice", lifecycle: "completed", status: "ok",
+                    title: "speech heard", text: redactNarration(utterance.text) });
+            }
+            if (pendingHeardSpeech.length > CUA_SPEECH_LIMITS.utterances) {
+                throw new CuaExecutorError("invalid_response", "outcome_uncertain");
+            }
+            return pendingHeardSpeech.length === 0 ? value : { ...value, heardSpeech: pendingHeardSpeech.slice() };
+        };
         // The declared observation window (#510). 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.
@@ -705,7 +804,7 @@ export async function runComputerUseLoop(options) {
                     throw new CuaAbortError();
                 await sleep(Math.min(dwell.everyMs, budget - (now() - dwellStartedAtMs)));
                 currentPhase = `dwell frame ${frames + 1}`;
-                const frameObservation = await observeBounded(`dwell frame ${frames + 1}`);
+                const frameObservation = collectHeardSpeech(await observeBounded(`dwell frame ${frames + 1}`));
                 frames += 1;
                 if (frameObservation.screenshot !== undefined)
                     onScreenshot?.(frameObservation.screenshot);
@@ -729,7 +828,7 @@ export async function runComputerUseLoop(options) {
             contextHint = `The study held this page under observation for ${Math.round(dwellHeldMs / 1000)} seconds (a declared dwell window; you took no actions in that time). Continue the mission from the current state of the page.`;
             return "continue";
         };
-        let observation = await observeBounded("initial");
+        let observation = collectHeardSpeech(await observeBounded("initial"));
         // Runtime-only: hand the seat's live location.href back to the orchestrator (never persisted).
         onObservedUrl?.(observation.url);
         if (observation.screenshot !== undefined)
@@ -744,7 +843,7 @@ export async function runComputerUseLoop(options) {
         observeTasks(observation, 0);
         const initialDwell = await dwellIfDue(observation, 0);
         if (initialDwell !== undefined) {
-            observation = await observeBounded("after dwell");
+            observation = collectHeardSpeech(await observeBounded("after dwell"));
             onObservedUrl?.(observation.url);
             if (observation.screenshot !== undefined)
                 onScreenshot?.(observation.screenshot);
@@ -877,9 +976,19 @@ export async function runComputerUseLoop(options) {
                 }
             }
             bump("turns");
+            pendingHeardSpeech = [];
+            heardSpeechChanged = false;
             previousResponseId = turn.responseId ?? previousResponseId;
             lastResponseId = turn.responseId ?? lastResponseId;
             recordUsage(turn);
+            // A host-authenticated provider may learn its account billing class during
+            // startup. Never price that account usage from an API model rate.
+            if (provider.executionProfile?.billing === "account-unknown" &&
+                (maxUsd !== undefined || overRunBudget !== undefined || estimateTurnCostUsd !== undefined)) {
+                completionReason = "harness_error";
+                reason = "Codex is using a ChatGPT account; API dollar caps cannot bound account usage. Use a finite timeout or the OpenAI API participant.";
+                break;
+            }
             if (turn.interruption !== undefined) {
                 // A provider can exhaust its response budget before producing visible text, or midway
                 // through an action. Preserve usage and partial narration, but never interpret either as
@@ -909,7 +1018,7 @@ export async function runComputerUseLoop(options) {
                     title: tokenLimit ? "provider token limit reached" : unexpectedStatus ? "unexpected provider response status" : "provider response incomplete", text: reason });
                 break;
             }
-            if (requiresUsage && (incompleteInteractionUsage || hasUnreportedInteractionUsage())) {
+            if (requiresUsage && usageUnavailableForCap()) {
                 stopForUnreportedUsage();
                 break;
             }
@@ -1029,7 +1138,7 @@ export async function runComputerUseLoop(options) {
                 if (taskTracker !== undefined) {
                     try {
                         currentPhase = "observing closing task state";
-                        const closing = await observeBounded("closing");
+                        const closing = collectHeardSpeech(await observeBounded("closing"));
                         observeTasks(closing, turnNumber);
                     }
                     catch (error) {
@@ -1203,6 +1312,7 @@ export async function runComputerUseLoop(options) {
                     kind: "ui_action",
                     lifecycle: "completed",
                     title: actionTitle,
+                    ...(action.kind === "speak" ? { text: redactNarration(action.text) } : {}),
                     // Structured pin coordinates (#441), exactly the click classes the Observer
                     // pins render — recorded fact instead of a title re-parse downstream.
                     ...(action.kind === "click" || action.kind === "double_click"
@@ -1213,7 +1323,7 @@ export async function runComputerUseLoop(options) {
             if (signal?.aborted)
                 throw new CuaAbortError();
             currentPhase = `observing UI state after turn ${turnNumber}`;
-            observation = await observeBounded(`after turn ${turnNumber}`);
+            observation = collectHeardSpeech(await observeBounded(`after turn ${turnNumber}`));
             // Runtime-only: hand the seat's live location.href back to the orchestrator (never persisted).
             onObservedUrl?.(observation.url);
             if (observation.screenshot !== undefined)
@@ -1228,7 +1338,7 @@ export async function runComputerUseLoop(options) {
             observeTasks(observation, turnNumber);
             const dwellOutcome = await dwellIfDue(observation, turnNumber);
             if (dwellOutcome !== undefined) {
-                observation = await observeBounded("after dwell");
+                observation = collectHeardSpeech(await observeBounded("after dwell"));
                 onObservedUrl?.(observation.url);
                 if (observation.screenshot !== undefined)
                     onScreenshot?.(observation.screenshot);
@@ -1276,13 +1386,14 @@ export async function runComputerUseLoop(options) {
             // behavioral signal already (the agent took nothing but screenshots and waits), so it keeps
             // reading the frame on its own — a repeated screenshot is exactly what an idle streak IS, and
             // feeding repetition into it would grant an extra forgiveness step for being idle.
-            const progressed = frameChanged || !repeatingRecentAction;
+            const observedProgress = frameChanged || heardSpeechChanged;
+            const progressed = observedProgress || !repeatingRecentAction;
             // A screenshot/wait turn while the UI visibly changes may be patience through loading or a
             // transition, so grant a bounded recovery window. Do not grant infinite immunity: animated
             // pixels or state-executor turn counters can otherwise keep a screenshot/wait loop alive
             // until the wall-clock timeout.
             if (idleThisTurn) {
-                if (frameChanged && idleProgressForgivenessUsed < IDLE_PROGRESS_FORGIVENESS_STEPS) {
+                if (observedProgress && idleProgressForgivenessUsed < IDLE_PROGRESS_FORGIVENESS_STEPS) {
                     idleProgressForgivenessUsed += 1;
                     consecutiveIdle = 0;
                 }
@@ -1434,11 +1545,11 @@ export async function runComputerUseLoop(options) {
             skip = "the session deadline was reached";
         else if (provider.requiresFrame && closingObservation.screenshot === undefined)
             skip = "the final observation has no required frame";
-        if (skip === undefined && (maxUsd !== undefined || overRunBudget !== undefined) && (incompleteInteractionUsage || hasUnreportedInteractionUsage())) {
+        if (skip === undefined && (maxUsd !== undefined || overRunBudget !== undefined) && usageUnavailableForCap()) {
             skip = "remaining model budget is unknown because an earlier participant turn did not report complete usage";
         }
         if (skip === undefined && maxUsd !== undefined) {
-            const estimate = sawUsage ? estimateTurnCostUsd?.(runningUsage()) : undefined;
+            const estimate = sawUsage || knownPendingUsage() !== undefined ? estimateTurnCostUsd?.(runningUsage()) : undefined;
             if (estimate === undefined || estimate === null || !Number.isFinite(estimate))
                 skip = "remaining model budget could not be established";
             else if (estimate >= maxUsd)
@@ -1512,7 +1623,7 @@ export async function runComputerUseLoop(options) {
                         const detail = signal?.aborted ? "cancelled" : controller.signal.aborted || error instanceof CuaDeadlineError || error instanceof CuaStallError
                             ? "closing report deadline reached" : error instanceof Error ? error.message : String(error);
                         const closingReceipt = provider.requestPolicy === "fail_closed" ? providerRequests.at(-1) : undefined;
-                        const usageReported = closingReceipt?.kind === "debrief" && closingReceipt.usageComplete && completeTurnUsage(closingReceipt.usage);
+                        const usageReported = closingReceipt?.usageComplete === true && completeTurnUsage(closingReceipt.usage);
                         note("failed", `${detail}; closing request usage is ${usageReported ? "reported" : "unreported"}`, usageReported);
                     }
                 }
@@ -1579,7 +1690,8 @@ export async function runComputerUseLoop(options) {
         ...(affordanceObservations.length > 0 ? { affordanceUse: summarizeAffordanceUse(affordanceObservations) } : {}),
         ...(declaredOutcome === undefined ? {} : { declaredOutcome }),
         ...(debrief === undefined ? {} : { debrief }),
-        ...(hasUnreportedInteractionUsage() || (requiresUsage && incompleteInteractionUsage) ? { interactionUsageIncomplete: true } : {}),
+        ...(interactionRequestPending || hasUnreportedInteractionUsage() || (requiresUsage && incompleteInteractionUsage)
+            ? { 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.
         ...(taskTracker === undefined ? {} : { taskFunnel: taskTracker.funnel() }),