@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent.js

@@ -31,6 +31,8 @@ import { buildMcpStateResult, buildNeutralHookResult, buildPiBashError, buildPiB
 import { AgentClientMessageSchema, AgentConversationTurnStructureSchema, AgentRunRequestSchema, AgentServerMessageSchema, AgentStoreConflictErrorSchema, AgentStoreConflictResultSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, CanvasDiagnosticsErrorSchema, CanvasDiagnosticsResultSchema, ClientHeartbeatSchema, ComputerUseErrorSchema, ComputerUseResultSchema, ConversationActionSchema, ConversationSearchErrorSchema, ConversationSearchResultSchema, ConversationStateStructureSchema, ConversationStepSchema, ConversationTurnStructureSchema, DeleteErrorSchema, DeleteRejectedSchema, DeleteResultSchema, DeleteSuccessSchema, DiagnosticsErrorSchema, DiagnosticsRejectedSchema, DiagnosticsResultSchema, DiagnosticsSuccessSchema, ExecClientControlMessageSchema, ExecClientHeartbeatSchema, ExecClientMessageSchema, ExecClientStreamCloseSchema, ExecClientThrowSchema, FetchErrorSchema, FetchResultSchema, ForceBackgroundShellResultSchema, ForceBackgroundShellStatus, ForceBackgroundSubagentResultSchema, ForceBackgroundSubagentStatus, GetBlobResultSchema, GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, GrepContentMatchSchema, GrepContentResultSchema, GrepCountResultSchema, GrepErrorSchema, GrepFileCountSchema, GrepFileMatchSchema, GrepFilesResultSchema, GrepResultSchema, GrepSuccessSchema, GrepUnionResultSchema, KvClientMessageSchema, ListMcpResourcesExecResultSchema, ListMcpResourcesSuccessSchema, LsDirectoryTreeNode_FileSchema, LsDirectoryTreeNodeSchema, LsErrorSchema, LsRejectedSchema, LsResultSchema, LsSuccessSchema, McpAllowlistPrecheckResultSchema, McpApprovedSchema, McpArgsSchema, McpErrorSchema, McpImageContentSchema, McpRejectedSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolCallSchema, McpToolDefinitionSchema, McpToolErrorSchema, McpToolNotFoundSchema, McpToolResultContentItemSchema, McpToolResultSchema, ModelDetailsSchema, ReadErrorSchema, ReadMcpResourceExecResultSchema, ReadMcpResourceNotFoundSchema, ReadRejectedSchema, ReadResultSchema, ReadSuccessSchema, RecordScreenFailureSchema, RecordScreenResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, ResumeActionSchema, SelectedContextSchema, SelectedImageSchema, SetBlobResultSchema, ShellAllowlistPrecheckResultSchema, ShellFailureSchema, ShellRejectedSchema, ShellResultSchema, ShellStreamExitSchema, ShellStreamSchema, ShellStreamStartSchema, ShellStreamStderrSchema, ShellStreamStdoutSchema, ShellSuccessSchema, SmartModeClassifierErrorSchema, SmartModeClassifierResultSchema, SubagentAwaitNotFoundSchema, SubagentAwaitResultSchema, SubagentErrorSchema, SubagentResultSchema, ToolCallSchema, UserMessageActionSchema, UserMessageSchema, WebFetchAllowlistPrecheckResultSchema, WriteErrorSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, WriteSuccessSchema, } from "./cursor-agent/gen/agent_pb.js";
 import { composeShellCommand, omitUndefinedArgs, piLimit, piLsPath, piReadArgs, piTimeout, } from "./cursor-agent/pi-args.js";
 import { buildRequestedModel } from "./cursor-agent/reasoning-params.js";
+import { CURSOR_CONVERSATION_POISONED_MESSAGE, createConversationRotationStore, isZeroTokenResourceExhausted, resolveConversationRotationPersistPath, } from "./cursor-conversation-rotation.js";
+import { keepUsableCursorTaskArgs } from "./cursor-task-args.js";
 export const CURSOR_API_URL = "https://api2.cursor.sh";
 export const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
 const EXEC_HEARTBEAT_INTERVAL_MS = 3000;
@@ -91,7 +93,6 @@ export function sanitizeCursorCallerHeaders(headers) {
 const NOT_IMPLEMENTED_SUFFIX = "not implemented by this client";
 const NOT_IMPLEMENTED = "Not implemented by this client";
 /** Bare gRPC `resource_exhausted` end-streams (also inside a Connect error message). */
-const RESOURCE_EXHAUSTED_PATTERN = /resource.?exhausted/i;
 const conversationStateCache = new Map();
 const conversationBlobStores = new Map();
 /**
@@ -101,7 +102,18 @@ const conversationBlobStores = new Map();
  * and the cached state migrates, so the retry loop's next attempt starts a
  * fresh conversation. Keyed by the base id so a failed rotation never repeats.
  */
-const rotatedConversationIds = new Map();
+let conversationRotationStore = createConversationRotationStore({
+    persistPath: resolveConversationRotationPersistPath(),
+});
+let conversationRotationPersistPath = resolveConversationRotationPersistPath();
+function rotationStore() {
+    const persistPath = resolveConversationRotationPersistPath();
+    if (persistPath !== conversationRotationPersistPath) {
+        conversationRotationPersistPath = persistPath;
+        conversationRotationStore = createConversationRotationStore({ persistPath });
+    }
+    return conversationRotationStore;
+}
 const CONNECT_END_STREAM_FLAG = 0b00000010;
 function log(type, subtype, data) {
     if (!process.env.DEBUG_CURSOR)
@@ -217,10 +229,6 @@ export const stream = (model, context, options) => {
         let openBlockState;
         let resolveH2 = () => { };
         let rejectH2 = () => { };
-        const h2Completion = new Promise((resolve, reject) => {
-            resolveH2 = resolve;
-            rejectH2 = reject;
-        });
         const settleH2 = (error) => {
             if (h2Settled)
                 return;
@@ -244,218 +252,264 @@ export const stream = (model, context, options) => {
         let baseConversationId;
         let conversationId;
         let usageState;
-        try {
-            const apiKey = options?.apiKey;
-            if (!apiKey) {
-                throw new Error("Cursor access token is required; run /login cursor");
-            }
-            baseConversationId = options?.conversationId ?? options?.sessionId ?? randomUUID();
-            conversationId = rotatedConversationIds.get(baseConversationId) ?? baseConversationId;
-            const blobStore = conversationBlobStores.get(conversationId) ?? new Map();
-            conversationBlobStores.set(conversationId, blobStore);
-            const cachedState = conversationStateCache.get(conversationId);
-            const { requestBytes, conversationState } = await buildGrpcRequest(model, context, options, {
-                conversationId,
-                blobStore,
-                conversationState: cachedState,
+        let retryPoisonedConversation = false;
+        let attempt = 0;
+        do {
+            retryPoisonedConversation = false;
+            attempt += 1;
+            h2Settled = false;
+            sawTurnEnded = false;
+            endStreamError = null;
+            openBlockState = undefined;
+            const h2Completion = new Promise((resolve, reject) => {
+                resolveH2 = resolve;
+                rejectH2 = reject;
             });
-            conversationStateCache.set(conversationId, conversationState);
-            const requestContextTools = buildMcpToolDefinitions(context.tools);
-            const baseUrl = model.baseUrl || CURSOR_API_URL;
-            const requestPath = "/agent.v1.AgentService/Run";
-            // Caller headers are additive, and are spread FIRST so the protocol
-            // framing, auth, and request id below always win.
-            const callerHeaders = sanitizeCursorCallerHeaders(providerHeadersToRecord(options?.headers));
-            const requestHeaders = {
-                ...callerHeaders,
-                ":method": "POST",
-                ":path": requestPath,
-                "content-type": "application/connect+proto",
-                "connect-protocol-version": "1",
-                te: "trailers",
-                authorization: `Bearer ${apiKey}`,
-                "x-ghost-mode": "true",
-                "x-cursor-client-version": CURSOR_CLIENT_VERSION,
-                "x-cursor-client-type": "cli",
-                "x-request-id": randomUUID(),
-            };
-            h2Client = http2.connect(baseUrl);
-            h2Client.on("error", (error) => settleH2(mapH2TransportError(error, baseUrl)));
-            h2Request = h2Client.request(requestHeaders);
-            stream.push({ type: "start", partial: output });
-            let pendingBuffer = Buffer.alloc(0);
-            let currentTextBlock = null;
-            let currentThinkingBlock = null;
-            let currentToolCall = null;
-            const resolvedMcpToolCallIds = new Set();
-            usageState = { sawTokenDelta: false, sawTurnEndedUsage: false };
-            const state = {
-                get currentTextBlock() {
-                    return currentTextBlock;
-                },
-                get currentThinkingBlock() {
-                    return currentThinkingBlock;
-                },
-                get currentToolCall() {
-                    return currentToolCall;
-                },
-                openToolCalls: new Map(),
-                resolvedMcpToolCallIds,
-                setTextBlock: (b) => {
-                    currentTextBlock = b;
-                },
-                setThinkingBlock: (b) => {
-                    currentThinkingBlock = b;
-                },
-                setToolCall: (t) => {
-                    currentToolCall = t;
-                },
-                onToolResult: options?.onToolResult ?? options?.execHandlers?.onToolResult,
-            };
-            openBlockState = state;
-            const onConversationCheckpoint = (checkpoint) => {
-                conversationStateCache.set(conversationId, checkpoint);
-            };
-            h2Request.on("data", (chunk) => {
-                // Steady state drains fully per chunk; alias the fresh h2 chunk
-                // instead of copying it through Buffer.concat.
-                pendingBuffer = pendingBuffer.length === 0 ? chunk : Buffer.concat([pendingBuffer, chunk]);
-                while (pendingBuffer.length >= 5) {
-                    const flags = pendingBuffer[0];
-                    const msgLen = pendingBuffer.readUInt32BE(1);
-                    if (pendingBuffer.length < 5 + msgLen)
-                        break;
-                    const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
-                    pendingBuffer = pendingBuffer.subarray(5 + msgLen);
-                    if (flags & CONNECT_END_STREAM_FLAG) {
-                        const endError = parseConnectEndStream(messageBytes);
-                        if (endError) {
-                            endStreamError = endError;
-                            h2Request?.close();
+            try {
+                const apiKey = options?.apiKey;
+                if (!apiKey) {
+                    throw new Error("Cursor access token is required; run /login cursor");
+                }
+                baseConversationId = options?.conversationId ?? options?.sessionId ?? randomUUID();
+                conversationId = rotationStore().getWireId(baseConversationId);
+                const blobStore = conversationBlobStores.get(conversationId) ?? new Map();
+                conversationBlobStores.set(conversationId, blobStore);
+                const cachedState = conversationStateCache.get(conversationId);
+                const { requestBytes, conversationState } = await buildGrpcRequest(model, context, options, {
+                    conversationId,
+                    blobStore,
+                    conversationState: cachedState,
+                });
+                conversationStateCache.set(conversationId, conversationState);
+                const requestContextTools = buildMcpToolDefinitions(context.tools);
+                const baseUrl = model.baseUrl || CURSOR_API_URL;
+                const requestPath = "/agent.v1.AgentService/Run";
+                // Caller headers are additive, and are spread FIRST so the protocol
+                // framing, auth, and request id below always win.
+                const callerHeaders = sanitizeCursorCallerHeaders(providerHeadersToRecord(options?.headers));
+                const requestHeaders = {
+                    ...callerHeaders,
+                    ":method": "POST",
+                    ":path": requestPath,
+                    "content-type": "application/connect+proto",
+                    "connect-protocol-version": "1",
+                    te: "trailers",
+                    authorization: `Bearer ${apiKey}`,
+                    "x-ghost-mode": "true",
+                    "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+                    "x-cursor-client-type": "cli",
+                    "x-request-id": randomUUID(),
+                };
+                h2Client = http2.connect(baseUrl);
+                h2Client.on("error", (error) => settleH2(mapH2TransportError(error, baseUrl)));
+                h2Request = h2Client.request(requestHeaders);
+                if (attempt === 1) {
+                    stream.push({ type: "start", partial: output });
+                }
+                let pendingBuffer = Buffer.alloc(0);
+                let currentTextBlock = null;
+                let currentThinkingBlock = null;
+                let currentToolCall = null;
+                const resolvedMcpToolCallIds = new Set();
+                usageState = { sawTokenDelta: false, sawTurnEndedUsage: false };
+                const state = {
+                    get currentTextBlock() {
+                        return currentTextBlock;
+                    },
+                    get currentThinkingBlock() {
+                        return currentThinkingBlock;
+                    },
+                    get currentToolCall() {
+                        return currentToolCall;
+                    },
+                    openToolCalls: new Map(),
+                    resolvedMcpToolCallIds,
+                    setTextBlock: (b) => {
+                        currentTextBlock = b;
+                    },
+                    setThinkingBlock: (b) => {
+                        currentThinkingBlock = b;
+                    },
+                    setToolCall: (t) => {
+                        currentToolCall = t;
+                    },
+                    onToolResult: options?.onToolResult ?? options?.execHandlers?.onToolResult,
+                };
+                openBlockState = state;
+                const onConversationCheckpoint = (checkpoint) => {
+                    conversationStateCache.set(conversationId, checkpoint);
+                };
+                h2Request.on("data", (chunk) => {
+                    // Steady state drains fully per chunk; alias the fresh h2 chunk
+                    // instead of copying it through Buffer.concat.
+                    pendingBuffer = pendingBuffer.length === 0 ? chunk : Buffer.concat([pendingBuffer, chunk]);
+                    while (pendingBuffer.length >= 5) {
+                        const flags = pendingBuffer[0];
+                        const msgLen = pendingBuffer.readUInt32BE(1);
+                        if (pendingBuffer.length < 5 + msgLen)
+                            break;
+                        const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
+                        pendingBuffer = pendingBuffer.subarray(5 + msgLen);
+                        if (flags & CONNECT_END_STREAM_FLAG) {
+                            const endError = parseConnectEndStream(messageBytes);
+                            if (endError) {
+                                endStreamError = endError;
+                                h2Request?.close();
+                            }
+                            continue;
                         }
-                        continue;
-                    }
-                    try {
-                        const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-                        const isTurnEnded = serverMessage.message.case === "interactionUpdate" &&
-                            serverMessage.message.value.message?.case === "turnEnded";
-                        // Dispatch is fire-and-forget so the socket keeps draining
-                        // while a handler runs, but the promise is tracked: `done`
-                        // must not be pushed while an exec handler is still resolving,
-                        // or the buffered tool result is delivered after the turn
-                        // already finalized and the call is left unpaired.
-                        const dispatch = handleServerMessage(serverMessage, output, stream, state, blobStore, h2Request, options?.execHandlers, state.onToolResult, usageState, requestContextTools, onConversationCheckpoint).catch((error) => {
-                            log("error", "handleServerMessage", { error: String(error) });
-                        });
-                        inFlightDispatches.add(dispatch);
-                        void dispatch.finally(() => inFlightDispatches.delete(dispatch));
-                        // Application completion is not protocol success; wait for a
-                        // clean HTTP/2 end.
-                        if (isTurnEnded) {
-                            sawTurnEnded = true;
+                        try {
+                            const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
+                            const isTurnEnded = serverMessage.message.case === "interactionUpdate" &&
+                                serverMessage.message.value.message?.case === "turnEnded";
+                            // Dispatch is fire-and-forget so the socket keeps draining
+                            // while a handler runs, but the promise is tracked: `done`
+                            // must not be pushed while an exec handler is still resolving,
+                            // or the buffered tool result is delivered after the turn
+                            // already finalized and the call is left unpaired.
+                            const dispatch = handleServerMessage(serverMessage, output, stream, state, blobStore, h2Request, options?.execHandlers, state.onToolResult, usageState, requestContextTools, onConversationCheckpoint).catch((error) => {
+                                log("error", "handleServerMessage", { error: String(error) });
+                            });
+                            inFlightDispatches.add(dispatch);
+                            void dispatch.finally(() => inFlightDispatches.delete(dispatch));
+                            // Application completion is not protocol success; wait for a
+                            // clean HTTP/2 end.
+                            if (isTurnEnded) {
+                                sawTurnEnded = true;
+                            }
+                        }
+                        catch (e) {
+                            log("error", "parseServerMessage", { error: String(e) });
                         }
                     }
-                    catch (e) {
-                        log("error", "parseServerMessage", { error: String(e) });
+                });
+                const sendHeartbeat = () => {
+                    if (!h2Request || h2Request.closed) {
+                        return;
+                    }
+                    const heartbeatMessage = create(AgentClientMessageSchema, {
+                        message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
+                    });
+                    const heartbeatBytes = toBinary(AgentClientMessageSchema, heartbeatMessage);
+                    h2Request.write(frameConnectMessage(heartbeatBytes));
+                };
+                h2Request.on("trailers", (trailers) => {
+                    const status = trailers["grpc-status"];
+                    const msg = trailers["grpc-message"];
+                    if (status && status !== "0" && !endStreamError) {
+                        endStreamError = new Error(`gRPC error ${status}: ${decodeURIComponent(String(msg || ""))}`);
                     }
-                }
-            });
-            const sendHeartbeat = () => {
-                if (!h2Request || h2Request.closed) {
-                    return;
-                }
-                const heartbeatMessage = create(AgentClientMessageSchema, {
-                    message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
                 });
-                const heartbeatBytes = toBinary(AgentClientMessageSchema, heartbeatMessage);
-                h2Request.write(frameConnectMessage(heartbeatBytes));
-            };
-            h2Request.on("trailers", (trailers) => {
-                const status = trailers["grpc-status"];
-                const msg = trailers["grpc-message"];
-                if (status && status !== "0" && !endStreamError) {
-                    endStreamError = new Error(`gRPC error ${status}: ${decodeURIComponent(String(msg || ""))}`);
+                h2Request.on("end", () => {
+                    settleH2();
+                });
+                h2Request.on("error", (error) => {
+                    settleH2(mapH2TransportError(error, baseUrl));
+                });
+                if (options?.signal) {
+                    options.signal.addEventListener("abort", () => {
+                        h2Request?.close();
+                        settleH2(new Error("Request was aborted"));
+                    });
                 }
-            });
-            h2Request.on("end", () => {
-                settleH2();
-            });
-            h2Request.on("error", (error) => {
-                settleH2(mapH2TransportError(error, baseUrl));
-            });
-            if (options?.signal) {
-                options.signal.addEventListener("abort", () => {
-                    h2Request?.close();
-                    settleH2(new Error("Request was aborted"));
+                h2Request.write(frameConnectMessage(requestBytes));
+                heartbeatTimer = setInterval(sendHeartbeat, 5000);
+                await h2Completion;
+                // The transport is done, but a handler decoded from the last chunk
+                // may still be running. Pushing `done` now would let the host drain
+                // its buffered tool results before such a handler reserved its entry,
+                // leaving the call unpaired and stripped from rebuilt transcripts.
+                await drainInFlightDispatches();
+                endCurrentTextBlock(output, stream, state);
+                endCurrentThinkingBlock(output, stream, state);
+                flushOpenToolCalls(output, stream, state);
+                calculateCost(model, output.usage);
+                stream.push({
+                    type: "done",
+                    reason: output.stopReason,
+                    message: output,
                 });
+                stream.end();
             }
-            h2Request.write(frameConnectMessage(requestBytes));
-            heartbeatTimer = setInterval(sendHeartbeat, 5000);
-            await h2Completion;
-            // The transport is done, but a handler decoded from the last chunk
-            // may still be running. Pushing `done` now would let the host drain
-            // its buffered tool results before such a handler reserved its entry,
-            // leaving the call unpaired and stripped from rebuilt transcripts.
-            await drainInFlightDispatches();
-            endCurrentTextBlock(output, stream, state);
-            endCurrentThinkingBlock(output, stream, state);
-            flushOpenToolCalls(output, stream, state);
-            calculateCost(model, output.usage);
-            stream.push({
-                type: "done",
-                reason: output.stopReason,
-                message: output,
-            });
-            stream.end();
-        }
-        catch (error) {
-            // Same reason as the success path: a handler still running would land
-            // its real result after the turn finalized and be discarded — even
-            // though the tool may already have run side effects. On abort the
-            // drain returns immediately.
-            await drainInFlightDispatches();
-            // A stream that dies mid-turn leaves blocks open. Closing them here
-            // settles their live cards and pairs the server-owned calls that
-            // nothing else answers — an unpaired call is stripped from every
-            // rebuilt transcript.
-            if (openBlockState) {
-                endCurrentTextBlock(output, stream, openBlockState);
-                endCurrentThinkingBlock(output, stream, openBlockState);
-                flushOpenToolCalls(output, stream, openBlockState);
-            }
-            const message = error instanceof Error ? error.message : JSON.stringify(error);
-            // A server-side per-conversation rejection surfaces as a bare
-            // resource_exhausted with zero tokens — the conversation is poisoned,
-            // not the account. Rotate the wire id once and migrate cached state
-            // so the caller's retry loop starts a fresh conversation.
-            if (conversationId !== undefined &&
-                baseConversationId !== undefined &&
-                usageState !== undefined &&
-                !usageState.sawTokenDelta &&
-                RESOURCE_EXHAUSTED_PATTERN.test(message) &&
-                !rotatedConversationIds.has(baseConversationId)) {
-                const rotated = randomUUID();
-                rotatedConversationIds.set(baseConversationId, rotated);
-                const cached = conversationStateCache.get(conversationId);
-                if (cached)
-                    conversationStateCache.set(rotated, cached);
-                const blobs = conversationBlobStores.get(conversationId);
-                if (blobs)
-                    conversationBlobStores.set(rotated, blobs);
+            catch (error) {
+                // Same reason as the success path: a handler still running would land
+                // its real result after the turn finalized and be discarded — even
+                // though the tool may already have run side effects. On abort the
+                // drain returns immediately.
+                await drainInFlightDispatches();
+                // A stream that dies mid-turn leaves blocks open. Closing them here
+                // settles their live cards and pairs the server-owned calls that
+                // nothing else answers — an unpaired call is stripped from every
+                // rebuilt transcript.
+                if (openBlockState) {
+                    endCurrentTextBlock(output, stream, openBlockState);
+                    endCurrentThinkingBlock(output, stream, openBlockState);
+                    flushOpenToolCalls(output, stream, openBlockState);
+                }
+                let message = error instanceof Error ? error.message : JSON.stringify(error);
+                // A server-side per-conversation rejection surfaces as a bare
+                // resource_exhausted with zero tokens. That has two distinct causes:
+                // an oversized payload, and a genuinely poisoned conversationId.
+                // Only the second is fixed by rotating the wire id.
+                //
+                // The FIRST 0-token RE for a base conversation always surfaces without
+                // rotating, so the session layer gets first refusal: agent-session
+                // classifies a surfaced 0-token RE as overflow and compacts before
+                // retrying. Rotating here instead would swallow the error, make that
+                // compaction dead code, and burn the 3-rotation budget replaying the
+                // same oversized payload. Once that surface has happened (the flag is
+                // persisted with the wire id), compaction has had its turn and further
+                // 0-token REs rotate and retry in-call, up to the cap.
+                if (conversationId !== undefined &&
+                    baseConversationId !== undefined &&
+                    usageState !== undefined &&
+                    isZeroTokenResourceExhausted(message, usageState.sawTokenDelta)) {
+                    if (rotationStore().shouldSkip(baseConversationId)) {
+                        // The base conversation burned its rotation cap; another wire id
+                        // will not help, so surface the poisoned-conversation error and
+                        // let the session move to a different provider.
+                        message = CURSOR_CONVERSATION_POISONED_MESSAGE;
+                    }
+                    else if (rotationStore().shouldSurfaceBeforeRotating(baseConversationId)) {
+                        // First 0-token RE for this conversation: surface it so the
+                        // session layer can compact. If the payload really was oversized,
+                        // the compacted retry succeeds and no rotation is ever spent.
+                        rotationStore().markSurfaced(baseConversationId, conversationId);
+                    }
+                    else {
+                        const decision = rotationStore().recordZeroTokenPoison(baseConversationId, conversationId);
+                        if (decision.kind === "rotated") {
+                            const cached = conversationStateCache.get(conversationId);
+                            if (cached)
+                                conversationStateCache.set(decision.wireId, cached);
+                            const blobs = conversationBlobStores.get(conversationId);
+                            if (blobs)
+                                conversationBlobStores.set(decision.wireId, blobs);
+                            retryPoisonedConversation = true;
+                        }
+                        else {
+                            message = CURSOR_CONVERSATION_POISONED_MESSAGE;
+                        }
+                    }
+                }
+                if (!retryPoisonedConversation) {
+                    output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+                    output.errorMessage = message;
+                    stream.push({ type: "error", reason: output.stopReason, error: output });
+                    stream.end();
+                }
             }
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = message;
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
-        }
-        finally {
-            if (heartbeatTimer) {
-                clearInterval(heartbeatTimer);
-                heartbeatTimer = null;
+            finally {
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+                h2Request?.close();
+                h2Client?.close();
+                h2Request = null;
+                h2Client = null;
             }
-            h2Request?.close();
-            h2Client?.close();
-        }
+        } while (retryPoisonedConversation);
     })();
     return stream;
 };
@@ -2544,12 +2598,16 @@ export function processInteractionUpdate(update, output, stream, state, usageSta
             const toolCall = update.message.value.toolCall;
             if (settled[kStreamingBlockKind] === "mcp") {
                 // Authoritative full parse of the accumulated argument buffer.
+                const previousArgs = settled.arguments;
                 const partial = settled[kStreamingPartialJson];
                 if (partial !== undefined) {
                     settled.arguments = parseStreamingJson(partial);
                 }
                 const decodedArgs = decodeMcpArgsMap(selectMcpCall(toolCall)?.args?.args);
                 settled.arguments = mergeCursorMcpToolCallArgs(settled.arguments, decodedArgs);
+                if (settled.name === "task") {
+                    settled.arguments = keepUsableCursorTaskArgs(previousArgs, settled.arguments);
+                }
             }
             else if (settled[kStreamingBlockKind] === "connect-scm") {
                 // The authoritative outcome arrives only here. Late args are merged
@@ -2622,8 +2680,24 @@ function applyBilledTurnEndedUsage(update, output, usageState) {
     }
     usageState.sawTurnEndedUsage = true;
     const usage = output.usage;
-    usage.cacheRead = Number(cacheReadTokens ?? 0n);
-    usage.cacheWrite = Number(cacheWriteTokens ?? 0n);
+    const cacheRead = Number(cacheReadTokens ?? 0n);
+    const cacheWrite = Number(cacheWriteTokens ?? 0n);
+    const liveUsed = usageState.liveUsedTokens ?? 0;
+    // Cursor sometimes reports dashboard-cumulative cache_read (millions) while
+    // usedTokens stays at the real window (~150k). Folding that into totalTokens
+    // forces a useless compact and then a 0-token resource_exhausted.
+    if (liveUsed > 0 && cacheRead > liveUsed * 3) {
+        if (outputTokens !== undefined) {
+            usage.output = Number(outputTokens);
+        }
+        usage.cacheRead = 0;
+        usage.cacheWrite = cacheWrite <= liveUsed ? cacheWrite : 0;
+        usage.input = Math.max(0, liveUsed - usage.output - usage.cacheWrite);
+        usage.totalTokens = liveUsed;
+        return;
+    }
+    usage.cacheRead = cacheRead;
+    usage.cacheWrite = cacheWrite;
     usage.input = Math.max(0, Number(inputTokens ?? 0n) - usage.cacheRead - usage.cacheWrite);
     if (outputTokens !== undefined) {
         usage.output = Number(outputTokens);
@@ -2641,6 +2715,7 @@ function applyCheckpointTokenDetails(checkpoint, output, usageState) {
     const usedTokens = checkpoint.tokenDetails?.usedTokens ?? 0;
     if (usedTokens <= 0)
         return;
+    usageState.liveUsedTokens = usedTokens;
     const usage = output.usage;
     usage.input = Math.max(0, usedTokens - usage.output - usage.cacheRead - usage.cacheWrite);
     usage.totalTokens = usage.input + usage.output + usage.cacheRead + usage.cacheWrite;