pi-cursor-sdk 0.1.15 → 0.1.16

package/src/cursor-provider.ts

@@ -6,17 +6,34 @@ import {
 	type Model,
 	type SimpleStreamOptions,
 	type AssistantMessage,
+	type ToolResultMessage,
 } from "@earendil-works/pi-ai";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Agent, createAgentPlatform } from "@cursor/sdk";
 import type { InteractionUpdate, SDKAgent, SettingSource } from "@cursor/sdk";
 import { installCursorMcpToolTimeoutOverride } from "./cursor-mcp-timeout-override.js";
-import { buildCursorPrompt, type CursorPrompt } from "./context.js";
+import { buildCursorSendPrompt } from "./context.js";
+import {
+	acquireSessionCursorAgent,
+	commitSessionAgentSend,
+	disposeAllSessionCursorAgents,
+	resetSessionCursorAgent,
+} from "./cursor-session-agent.js";
 import {
-	getRegisteredCursorPiToolBridge,
 	type CursorPiBridgeToolRequest,
 	type CursorPiToolBridgeRun,
 } from "./cursor-pi-tool-bridge.js";
+import {
+	consumeCursorLiveToolResults,
+	createCursorLiveRunAccountingState,
+	takeCursorLiveTurnInputTokens,
+	type CursorLiveRunAccountingState,
+} from "./cursor-live-run-accounting.js";
+import {
+	applyCursorApproximateUsage,
+	estimateCursorPromptInputTokens,
+	getCursorPromptOptions,
+} from "./cursor-usage-accounting.js";
 import { getCursorSessionCwd } from "./cursor-session-cwd.js";
 import { getEffectiveFastForModelId } from "./cursor-state.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
@@ -64,8 +81,6 @@ const GENERIC_CURSOR_SDK_ERROR_MESSAGE =
 	"Cursor SDK request failed. The API key may be missing, invalid, or unauthorized. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
 const AUTH_CURSOR_SDK_ERROR_MESSAGE =
 	"Cursor SDK request failed because the API key may be invalid or unauthorized. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
-const APPROX_CHARS_PER_TOKEN = 4;
-const IMAGE_TOKEN_ESTIMATE = 1200;
 const CURSOR_ACTIVITY_TRACE_MAX_CHARS = 50000;
 const DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS = 5 * 60 * 1000;
 const CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN = /^(cursor-replay-\d+-\d+)-tool-\d+$/;
@@ -79,12 +94,18 @@ type CursorLiveQueuedEvent =
 	| { type: "tool"; tool: CursorNativeToolDisplayItem }
 	| { type: "bridge-tool"; request: CursorPiBridgeToolRequest };
 
+interface CursorLiveSdkRun {
+	cancel(): Promise<void>;
+}
+
 interface CursorLiveRun {
 	id: string;
 	agent: SDKAgent;
 	bridgeRun?: CursorPiToolBridgeRun;
-	promptInputTokens: number;
-	promptInputTokensReported: boolean;
+	sessionBridgeRun?: CursorPiToolBridgeRun;
+	sessionAgentScopeKey?: string;
+	sdkRun?: CursorLiveSdkRun;
+	accounting: CursorLiveRunAccountingState;
 	pendingEvents: CursorLiveQueuedEvent[];
 	textDeltas: string[];
 	emittedText: string;
@@ -103,6 +124,7 @@ interface CursorLiveTurnState {
 	partial: AssistantMessage;
 	thinkingContentIndex: number;
 	textContentIndex: number;
+	emittedText: string;
 }
 
 let cursorNativeReplayCounter = 0;
@@ -262,27 +284,6 @@ async function cacheSdkContextWindow(agentId: string, modelId: string): Promise<
 	}
 }
 
-function estimateTextTokens(text: string): number {
-	return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
-}
-
-function estimatePromptInputTokens(prompt: CursorPrompt): number {
-	return estimateTextTokens(prompt.text) + prompt.images.length * IMAGE_TOKEN_ESTIMATE;
-}
-
-function getPromptInputTokenBudget(model: Model<Api>): number {
-	const outputReserveTokens = Math.min(model.maxTokens, Math.max(1, Math.floor(model.contextWindow * 0.2)));
-	return Math.max(1, model.contextWindow - outputReserveTokens);
-}
-
-function setApproximateUsage(partial: AssistantMessage, promptInputTokens: number, outputText: string): void {
-	partial.usage.input = promptInputTokens;
-	partial.usage.output = estimateTextTokens(outputText);
-	partial.usage.cacheRead = 0;
-	partial.usage.cacheWrite = 0;
-	partial.usage.totalTokens = partial.usage.input + partial.usage.output;
-}
-
 function sanitizeSingleLine(value: string): string {
 	return value.replace(/\s+/g, " ").trim();
 }
@@ -391,6 +392,18 @@ function getPendingCursorLiveRun(context: Context): CursorLiveRun | undefined {
 	return undefined;
 }
 
+function isCursorLiveRunToolResult(run: CursorLiveRun, message: ToolResultMessage): boolean {
+	const replayId = getCursorNativeReplayIdFromToolCallId(message.toolCallId);
+	if (replayId) return replayId === run.id;
+	return run.bridgeRun?.hasPendingPiToolCallId(message.toolCallId) ?? false;
+}
+
+function consumeCursorLiveRunToolResults(run: CursorLiveRun, context: Context) {
+	const consumed = consumeCursorLiveToolResults(run.accounting, context, (toolResult) => isCursorLiveRunToolResult(run, toolResult));
+	run.accounting = consumed.state;
+	return consumed;
+}
+
 function splitTextIntoReplayDeltas(text: string): string[] {
 	const deltas: string[] = [];
 	let remaining = text;
@@ -446,7 +459,7 @@ function scheduleCursorNativeRunIdleDispose(run: CursorLiveRun): void {
 	if (run.disposed) return;
 	clearCursorNativeRunIdleDispose(run);
 	run.idleDisposeTimer = setTimeout(() => {
-		void disposeCursorNativeRun(run);
+		void releaseCursorLiveRun(run);
 	}, cursorNativeReplayIdleDisposeMs);
 	run.idleDisposeTimer.unref?.();
 }
@@ -557,6 +570,7 @@ function emitCursorLiveQueuedEvent(
 	} else if (event.type === "thinking-completed") {
 		closeCursorNativeThinkingBlock(turn);
 	} else if (event.type === "text-delta") {
+		turn.emittedText += event.text;
 		if (run) run.emittedText += event.text;
 		emitCursorNativeTextDelta(turn, event.text);
 	}
@@ -580,44 +594,72 @@ function collectCursorBridgeToolBatch(run: CursorLiveRun): CursorPiBridgeToolReq
 	return requests;
 }
 
-function trimAlreadyEmittedCursorText(text: string, emittedText: string): string {
+function isCursorTextBoundary(text: string, index: number): boolean {
+	if (index <= 0 || index >= text.length) return true;
+	const before = text[index - 1];
+	const after = text[index];
+	return !/[\p{L}\p{N}_]/u.test(before) || !/[\p{L}\p{N}_]/u.test(after);
+}
+
+function trimAlreadyEmittedCursorText(text: string, emittedText: string, options?: { allowPartialPrefix?: boolean }): string {
 	if (!text || !emittedText) return text;
 	if (text === emittedText) return "";
-	if (text.startsWith(emittedText)) return text.slice(emittedText.length);
-	if (emittedText.endsWith(text)) return "";
-	if (text.trim() === emittedText.trim()) return "";
-	if (emittedText.trim().endsWith(text.trim())) return "";
+	if (text.startsWith(emittedText) && (options?.allowPartialPrefix || isCursorTextBoundary(text, emittedText.length))) {
+		return text.slice(emittedText.length);
+	}
+	if (emittedText.endsWith(text) && isCursorTextBoundary(emittedText, emittedText.length - text.length)) return "";
+	const trimmedText = text.trim();
+	const trimmedEmittedText = emittedText.trim();
+	if (trimmedText === trimmedEmittedText) return "";
+	if (trimmedText && trimmedEmittedText.endsWith(trimmedText)) {
+		const suffixStart = trimmedEmittedText.length - trimmedText.length;
+		if (isCursorTextBoundary(trimmedEmittedText, suffixStart)) return "";
+	}
 	return text;
 }
 
+function trimCurrentTurnAlreadyEmittedCursorText(text: string, currentTurnEmittedText: string, emittedText = currentTurnEmittedText): string {
+	if (!currentTurnEmittedText) return trimAlreadyEmittedCursorText(text, emittedText);
+	const currentTurnTrimmedText = trimAlreadyEmittedCursorText(text, currentTurnEmittedText, { allowPartialPrefix: true });
+	if (currentTurnTrimmedText !== text) return currentTurnTrimmedText;
+	if (emittedText.endsWith(currentTurnEmittedText)) {
+		const emittedTextTrimmedText = trimAlreadyEmittedCursorText(text, emittedText, { allowPartialPrefix: true });
+		if (emittedTextTrimmedText !== text) return emittedTextTrimmedText;
+	}
+	return trimAlreadyEmittedCursorText(text, emittedText);
+}
+
 function selectCursorFinalText(
 	resultText: unknown,
 	textDeltas: readonly string[],
 	emittedText: string,
 	fallbackText?: string,
+	options?: { allowPartialPrefix?: boolean },
 ): string {
 	const candidates = [typeof resultText === "string" ? resultText : undefined, fallbackText, textDeltas.join("")];
 	for (const candidate of candidates) {
 		if (!hasUsableText(candidate)) continue;
-		const trimmedCandidate = trimAlreadyEmittedCursorText(candidate, emittedText);
+		const trimmedCandidate = trimAlreadyEmittedCursorText(candidate, emittedText, options);
 		if (hasUsableText(trimmedCandidate)) return trimmedCandidate;
 	}
 	return "";
 }
 
-function takeCursorNativePromptInputTokens(run: CursorLiveRun): number {
+function takeCursorLiveSessionInputTokens(run: CursorLiveRun, toolResultInputTokens: number): number {
 	// Native replay can split one Cursor run into multiple pi turns; count prompt input once.
-	if (run.promptInputTokensReported) return 0;
-	run.promptInputTokensReported = true;
-	return run.promptInputTokens;
+	const taken = takeCursorLiveTurnInputTokens(run.accounting, toolResultInputTokens);
+	run.accounting = taken.state;
+	return taken.sessionInputTokens;
 }
 
 function emitCursorNativeToolUseTurn(
 	stream: AssistantMessageEventStream,
 	partial: AssistantMessage,
+	model: Model<Api>,
+	context: Context,
 	run: CursorLiveRun,
+	toolResultInputTokens: number,
 	tools: CursorNativeToolDisplayItem[],
-	outputText: string,
 ): void {
 	const shouldTerminate = run.done && !run.finalText?.trim() && run.pendingEvents.length === 0;
 	for (const tool of tools) {
@@ -636,7 +678,7 @@ function emitCursorNativeToolUseTurn(
 			run.recordedToolDisplayIds.push(tool.id);
 		}
 	}
-	setApproximateUsage(partial, takeCursorNativePromptInputTokens(run), outputText);
+	applyCursorApproximateUsage(partial, model, context, takeCursorLiveSessionInputTokens(run, toolResultInputTokens));
 	partial.stopReason = "toolUse";
 	stream.push({ type: "done", reason: "toolUse", message: partial });
 	scheduleCursorNativeRunIdleDispose(run);
@@ -645,9 +687,11 @@ function emitCursorNativeToolUseTurn(
 function emitCursorBridgeToolUseTurn(
 	stream: AssistantMessageEventStream,
 	partial: AssistantMessage,
+	model: Model<Api>,
+	context: Context,
 	run: CursorLiveRun,
+	toolResultInputTokens: number,
 	requests: CursorPiBridgeToolRequest[],
-	outputText: string,
 ): void {
 	for (const request of requests) {
 		const contentIndex = partial.content.length;
@@ -662,37 +706,58 @@ function emitCursorBridgeToolUseTurn(
 		const block = partial.content[contentIndex];
 		if (block.type === "toolCall") stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial });
 	}
-	setApproximateUsage(partial, takeCursorNativePromptInputTokens(run), outputText);
+	applyCursorApproximateUsage(partial, model, context, takeCursorLiveSessionInputTokens(run, toolResultInputTokens));
 	partial.stopReason = "toolUse";
 	stream.push({ type: "done", reason: "toolUse", message: partial });
 	scheduleCursorNativeRunIdleDispose(run);
 }
 
-async function disposeCursorNativeRun(run: CursorLiveRun): Promise<void> {
+function isSuccessfulCursorLiveRun(run: CursorLiveRun): boolean {
+	return run.done && !run.cancelled && !run.errorMessage;
+}
+
+async function abandonSessionCursorAgent(scopeKey: string | undefined): Promise<void> {
+	if (!scopeKey) return;
+	await resetSessionCursorAgent(scopeKey);
+}
+
+async function releaseCursorLiveRun(run: CursorLiveRun): Promise<void> {
 	if (run.disposed) return;
+	const abandoned = !isSuccessfulCursorLiveRun(run);
 	run.disposed = true;
 	pendingCursorLiveRuns.delete(run.id);
 	clearCursorNativeRunIdleDispose(run);
-	run.bridgeRun?.cancel("Cursor live run disposed");
+	run.bridgeRun?.cancel("Cursor live run released");
 	for (const toolDisplayId of run.recordedToolDisplayIds) deleteCursorNativeToolDisplay(toolDisplayId);
 	run.recordedToolDisplayIds = [];
 	run.waiters.clear();
-	try {
-		await run.bridgeRun?.dispose();
-	} catch {
-		// bridge disposal failure should not mask the provider result
+	if (run.sessionBridgeRun) {
+		run.sessionBridgeRun.setOnToolRequest(undefined);
 	}
-	try {
-		await run.agent[Symbol.asyncDispose]();
-	} catch {
-		// disposal failure should not mask the provider result
+	if (run.bridgeRun && run.bridgeRun !== run.sessionBridgeRun) {
+		try {
+			await run.bridgeRun.dispose();
+		} catch {
+			// bridge disposal failure should not mask the provider result
+		}
+	}
+	if (abandoned) {
+		try {
+			await run.sdkRun?.cancel();
+		} catch {
+			// cancellation failure should not block session-agent abandonment
+		}
+		await abandonSessionCursorAgent(run.sessionAgentScopeKey);
 	}
 }
 
 async function emitCursorNativeRunNextTurn(
 	stream: AssistantMessageEventStream,
 	partial: AssistantMessage,
+	model: Model<Api>,
+	context: Context,
 	run: CursorLiveRun,
+	toolResultInputTokens: number,
 	signal?: AbortSignal,
 ): Promise<void> {
 	const turn: CursorLiveTurnState = {
@@ -700,6 +765,7 @@ async function emitCursorNativeRunNextTurn(
 		partial,
 		thinkingContentIndex: -1,
 		textContentIndex: -1,
+		emittedText: "",
 	};
 
 	while (true) {
@@ -708,17 +774,17 @@ async function emitCursorNativeRunNextTurn(
 			if (event.type === "tool") {
 				await settleCursorLiveToolBatch(run);
 				if (signal?.aborted) throw new CursorAbortError();
-				const outputText = closeCursorNativeTurnBlocks(turn);
+				closeCursorNativeTurnBlocks(turn);
 				const tools = collectCursorNativeToolBatch(run);
-				emitCursorNativeToolUseTurn(stream, partial, run, tools, outputText);
+				emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, tools);
 				return;
 			}
 			if (event.type === "bridge-tool") {
 				await settleCursorLiveToolBatch(run);
 				if (signal?.aborted) throw new CursorAbortError();
-				const outputText = closeCursorNativeTurnBlocks(turn);
+				closeCursorNativeTurnBlocks(turn);
 				const requests = collectCursorBridgeToolBatch(run);
-				emitCursorBridgeToolUseTurn(stream, partial, run, requests, outputText);
+				emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests);
 				return;
 			}
 			run.pendingEvents.shift();
@@ -728,26 +794,26 @@ async function emitCursorNativeRunNextTurn(
 		if (run.cancelled) {
 			partial.stopReason = "aborted";
 			stream.push({ type: "error", reason: "aborted", error: partial });
-			await disposeCursorNativeRun(run);
+			await releaseCursorLiveRun(run);
 			return;
 		}
 		if (run.errorMessage) {
 			partial.stopReason = "error";
 			partial.errorMessage = run.errorMessage;
 			stream.push({ type: "error", reason: "error", error: partial });
-			await disposeCursorNativeRun(run);
+			await releaseCursorLiveRun(run);
 			return;
 		}
 		if (run.done) {
-			let outputText = closeCursorNativeTurnBlocks(turn);
-			const finalText = trimAlreadyEmittedCursorText(run.finalText ?? run.textDeltas.join(""), run.emittedText);
+			closeCursorNativeTurnBlocks(turn);
+			const finalText = trimCurrentTurnAlreadyEmittedCursorText(run.finalText ?? run.textDeltas.join(""), turn.emittedText, run.emittedText);
 			if (finalText) {
-				outputText += await emitTextDeltas(stream, partial, splitTextIntoReplayDeltas(finalText));
+				await emitTextDeltas(stream, partial, splitTextIntoReplayDeltas(finalText));
 			}
-			setApproximateUsage(partial, takeCursorNativePromptInputTokens(run), outputText);
+			applyCursorApproximateUsage(partial, model, context, takeCursorLiveSessionInputTokens(run, toolResultInputTokens));
 			partial.stopReason = "stop";
 			stream.push({ type: "done", reason: "stop", message: partial });
-			await disposeCursorNativeRun(run);
+			await releaseCursorLiveRun(run);
 			return;
 		}
 
@@ -758,17 +824,19 @@ async function emitCursorNativeRunNextTurn(
 async function replayPendingCursorLiveRun(
 	stream: AssistantMessageEventStream,
 	partial: AssistantMessage,
+	model: Model<Api>,
 	context: Context,
 	signal?: AbortSignal,
 ): Promise<boolean> {
 	const run = getPendingCursorLiveRun(context);
 	if (!run) return false;
 	clearCursorNativeRunIdleDispose(run);
-	run.bridgeRun?.resolveToolResultsFromContext(context);
+	const consumed = consumeCursorLiveRunToolResults(run, context);
+	run.bridgeRun?.resolveToolResults(consumed.toolResults);
 	try {
-		await emitCursorNativeRunNextTurn(stream, partial, run, signal);
+		await emitCursorNativeRunNextTurn(stream, partial, model, context, run, consumed.toolResultInputTokens, signal);
 	} catch (error) {
-		if (error instanceof CursorAbortError) await disposeCursorNativeRun(run);
+		if (error instanceof CursorAbortError) await releaseCursorLiveRun(run);
 		throw error;
 	}
 	return true;
@@ -786,10 +854,10 @@ export function streamCursor(
 		let agent: SDKAgent | null = null;
 		let activeLiveRun: CursorLiveRun | undefined;
 		let bridgeRun: CursorPiToolBridgeRun | undefined;
-		let bridgeRunOwnedByLiveRun = false;
 		let liveRunForBridgeQueue: CursorLiveRun | undefined;
 		const queuedBridgeRequestsBeforeLiveRun: CursorPiBridgeToolRequest[] = [];
 		let resolvedApiKey: string | undefined;
+		let sessionAgentScopeKey = "";
 		let abortSignal: AbortSignal | undefined;
 		let abortListener: (() => void) | undefined;
 		let restoreCursorSdkOutputFilter: (() => void) | undefined;
@@ -802,7 +870,7 @@ export function streamCursor(
 			stream.push({ type: "start", partial });
 			throwIfAborted();
 
-			if (await replayPendingCursorLiveRun(stream, partial, context, options?.signal)) {
+			if (await replayPendingCursorLiveRun(stream, partial, model, context, options?.signal)) {
 				stream.end();
 				return;
 			}
@@ -818,41 +886,41 @@ export function streamCursor(
 			const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 			const settingSources = resolveCursorSettingSources();
 
-			const registeredBridge = getRegisteredCursorPiToolBridge();
-			bridgeRun = registeredBridge
-				? await registeredBridge.createRun({
-						onToolRequest: (request) => {
-							if (liveRunForBridgeQueue && !liveRunForBridgeQueue.disposed) {
-								queueCursorNativeEvent(liveRunForBridgeQueue, { type: "bridge-tool", request });
-							} else {
-								queuedBridgeRequestsBeforeLiveRun.push(request);
-							}
-						},
-					})
-				: undefined;
-			if (!bridgeRun?.enabled || !bridgeRun.mcpServers) {
-				await bridgeRun?.dispose();
-				bridgeRun = undefined;
-			}
-
 			installCursorMcpToolTimeoutOverride();
 			restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
-			agent = await suppressCursorSdkOutput(() =>
-				Agent.create({
-					apiKey,
-					model: selection,
-					local: settingSources ? { cwd, settingSources } : { cwd },
-					...(bridgeRun?.mcpServers ? { mcpServers: bridgeRun.mcpServers } : {}),
-				}),
-			);
+			const sessionAgentAcquireParams = {
+				apiKey,
+				cwd,
+				modelSelection: selection,
+				settingSources,
+				onBridgeToolRequest: (request: CursorPiBridgeToolRequest) => {
+					if (liveRunForBridgeQueue && !liveRunForBridgeQueue.disposed) {
+						queueCursorNativeEvent(liveRunForBridgeQueue, { type: "bridge-tool", request });
+					} else {
+						queuedBridgeRequestsBeforeLiveRun.push(request);
+					}
+				},
+				createAgent: (createOptions: Parameters<typeof Agent.create>[0]) =>
+					suppressCursorSdkOutput(() => Agent.create(createOptions)),
+			};
+			let sessionAgentLease = await acquireSessionCursorAgent(sessionAgentAcquireParams);
+			sessionAgentScopeKey = sessionAgentLease.scopeKey;
+			agent = sessionAgentLease.agent;
+			bridgeRun = sessionAgentLease.bridgeRun;
 			throwIfAborted();
 
-			const prompt = buildCursorPrompt(context, {
-				maxInputTokens: getPromptInputTokenBudget(model),
-				charsPerToken: APPROX_CHARS_PER_TOKEN,
-				imageTokenEstimate: IMAGE_TOKEN_ESTIMATE,
-			});
-			const promptInputTokens = estimatePromptInputTokens(prompt);
+			const promptOptions = getCursorPromptOptions(model);
+			let { prompt, bootstrap } = buildCursorSendPrompt(context, promptOptions, sessionAgentLease.sendState);
+			if (sessionAgentLease.sendState.bootstrapped && bootstrap) {
+				await resetSessionCursorAgent(sessionAgentLease.scopeKey);
+				sessionAgentLease = await acquireSessionCursorAgent(sessionAgentAcquireParams);
+				sessionAgentScopeKey = sessionAgentLease.scopeKey;
+				agent = sessionAgentLease.agent;
+				bridgeRun = sessionAgentLease.bridgeRun;
+				({ prompt, bootstrap } = buildCursorSendPrompt(context, promptOptions, sessionAgentLease.sendState));
+			}
+			const sessionBridgeRun = sessionAgentLease.bridgeRun;
+			const promptInputTokens = estimateCursorPromptInputTokens(prompt, promptOptions);
 			let thinkingContentIndex = -1;
 			let activityTraceChars = 0;
 			let activityTraceTruncated = false;
@@ -868,8 +936,9 @@ export function streamCursor(
 						id: useNativeToolReplay ? nativeReplayId : bridgeRun!.id,
 						agent,
 						bridgeRun,
-						promptInputTokens,
-						promptInputTokensReported: false,
+						sessionBridgeRun,
+						sessionAgentScopeKey,
+						accounting: createCursorLiveRunAccountingState(promptInputTokens),
 						pendingEvents: [],
 						textDeltas,
 						emittedText: "",
@@ -884,7 +953,6 @@ export function streamCursor(
 				pendingCursorLiveRuns.set(liveRun.id, liveRun);
 				activeLiveRun = liveRun;
 				liveRunForBridgeQueue = liveRun;
-				bridgeRunOwnedByLiveRun = bridgeRun !== undefined;
 				for (const request of queuedBridgeRequestsBeforeLiveRun.splice(0)) {
 					queueCursorNativeEvent(liveRun, { type: "bridge-tool", request });
 				}
@@ -1218,6 +1286,7 @@ export function streamCursor(
 				{ text: prompt.text, images: prompt.images.length > 0 ? prompt.images : undefined },
 				{ onDelta, onStep },
 			);
+			if (liveRun) liveRun.sdkRun = run;
 			if (options?.signal?.aborted) {
 				await run.cancel().catch(() => {});
 				throw new CursorAbortError();
@@ -1231,14 +1300,24 @@ export function streamCursor(
 						discardIncompleteStartedToolCalls();
 						await cacheSdkContextWindow(liveRun.agent.agentId, model.id);
 						if (liveRun.disposed) return;
+						if (result.status === "finished" && !options?.signal?.aborted) {
+							commitSessionAgentSend(sessionAgentScopeKey, context, bootstrap);
+						} else {
+							await abandonSessionCursorAgent(sessionAgentScopeKey);
+						}
 						liveRun.cancelled = result.status === "cancelled";
-						liveRun.finalText = selectCursorFinalText(result.result, liveRun.textDeltas, liveRun.emittedText, cursorPlanTextCandidate);
+						if (result.status === "error") {
+							liveRun.errorMessage = sanitizeError(result.result ?? "Cursor SDK run failed", resolvedApiKey ?? options?.apiKey);
+						} else {
+							liveRun.finalText = selectCursorFinalText(result.result, liveRun.textDeltas, liveRun.emittedText, cursorPlanTextCandidate);
+						}
 						liveRun.done = true;
 						notifyCursorNativeRun(liveRun);
 						scheduleCursorNativeRunIdleDispose(liveRun);
 					})
-					.catch((error: unknown) => {
+					.catch(async (error: unknown) => {
 						if (liveRun.disposed) return;
+						await abandonSessionCursorAgent(sessionAgentScopeKey);
 						liveRun.errorMessage = sanitizeError(error, resolvedApiKey ?? options?.apiKey);
 						notifyCursorNativeRun(liveRun);
 						scheduleCursorNativeRunIdleDispose(liveRun);
@@ -1248,9 +1327,9 @@ export function streamCursor(
 					await waitForCursorNativeRunProgress(liveRun, options?.signal);
 					await settleCursorLiveToolBatch(liveRun);
 					closeTraceBlock();
-					await emitCursorNativeRunNextTurn(stream, partial, liveRun, options?.signal);
+					await emitCursorNativeRunNextTurn(stream, partial, model, context, liveRun, 0, options?.signal);
 				} catch (error) {
-					if (error instanceof CursorAbortError) await disposeCursorNativeRun(liveRun);
+					if (error instanceof CursorAbortError) await releaseCursorLiveRun(liveRun);
 					throw error;
 				}
 				agent = null;
@@ -1266,16 +1345,26 @@ export function streamCursor(
 			closeTraceBlock();
 
 			if (result.status === "cancelled") {
+				await abandonSessionCursorAgent(sessionAgentScopeKey);
 				partial.stopReason = "aborted";
 				stream.push({ type: "error", reason: "aborted", error: partial });
+			} else if (result.status === "error") {
+				await abandonSessionCursorAgent(sessionAgentScopeKey);
+				partial.stopReason = "error";
+				partial.errorMessage = sanitizeError(result.result ?? "Cursor SDK run failed", resolvedApiKey ?? options?.apiKey);
+				stream.push({ type: "error", reason: "error", error: partial });
 			} else {
-				const finalCursorText = selectCursorFinalText(result.result, textDeltas, textDeltas.join(""), cursorPlanTextCandidate);
-				const finalText = flushText(hasUsableText(finalCursorText) ? [finalCursorText] : []);
-				setApproximateUsage(partial, promptInputTokens, finalText);
+				commitSessionAgentSend(sessionAgentScopeKey, context, bootstrap);
+				const finalCursorText = selectCursorFinalText(result.result, textDeltas, textDeltas.join(""), cursorPlanTextCandidate, {
+					allowPartialPrefix: true,
+				});
+				flushText(hasUsableText(finalCursorText) ? [finalCursorText] : []);
+				applyCursorApproximateUsage(partial, model, context, promptInputTokens);
 				stream.push({ type: "done", reason: "stop", message: partial });
 			}
 		} catch (error) {
-			if (activeLiveRun && !activeLiveRun.disposed) await disposeCursorNativeRun(activeLiveRun);
+			if (activeLiveRun && !activeLiveRun.disposed) await releaseCursorLiveRun(activeLiveRun);
+			else await abandonSessionCursorAgent(sessionAgentScopeKey);
 			if (error instanceof CursorAbortError) {
 				partial.stopReason = "aborted";
 				stream.push({ type: "error", reason: "aborted", error: partial });
@@ -1286,28 +1375,10 @@ export function streamCursor(
 			}
 		} finally {
 			restoreCursorSdkOutputFilter?.();
-			if (activeLiveRun?.disposed) agent = null;
 
 			if (abortSignal && abortListener) {
 				abortSignal.removeEventListener("abort", abortListener);
 			}
-
-			if (bridgeRun && !bridgeRunOwnedByLiveRun) {
-				try {
-					await bridgeRun.dispose();
-				} catch {
-					// bridge disposal failure should not mask original error
-				}
-			}
-
-			if (agent) {
-				try {
-					await agent[Symbol.asyncDispose]();
-				} catch {
-					// disposal failure should not mask original error
-				}
-				agent = null;
-			}
 		}
 
 		stream.end();
@@ -1325,4 +1396,5 @@ export const __testUtils = {
 	resetCursorNativeReplayIdleDisposeMs: () => {
 		cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
 	},
+	resetSessionCursorAgents: () => disposeAllSessionCursorAgents(),
 };

package/src/cursor-question-tool.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ExtensionHandler, SessionStartEvent } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge.js";
@@ -34,6 +34,11 @@ interface CursorQuestionDetails {
 	cancelled: boolean;
 }
 
+interface CursorQuestionToolExtensionApi extends Pick<ExtensionAPI, "getActiveTools" | "registerTool" | "setActiveTools"> {
+	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
+	on(event: "model_select", handler: (event: { model: ExtensionContext["model"] }, ctx: ExtensionContext) => Promise<void> | void): void;
+}
+
 type RawQuestionOption = string | { label?: string; value?: string; description?: string };
 
 type RawQuestion = {
@@ -186,7 +191,7 @@ function syncCursorQuestionToolForModel(pi: Pick<ExtensionAPI, "getActiveTools"
 	pi.setActiveTools([...activeToolNames]);
 }
 
-export function registerCursorQuestionTool(pi: ExtensionAPI): void {
+export function registerCursorQuestionTool(pi: CursorQuestionToolExtensionApi): void {
 	pi.registerTool({
 		name: CURSOR_ASK_QUESTION_TOOL_NAME,
 		label: "Cursor question",