pi-cursor-sdk 0.1.60 → 0.1.61

package/src/cursor-pi-tool-bridge-run.ts

@@ -9,6 +9,7 @@ import {
 	ListToolsRequestSchema,
 	type CallToolResult,
 } from "@modelcontextprotocol/sdk/types.js";
+import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
 import { MCP_ENDPOINT_ROOT, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
 import {
 	type CursorPiToolBridgeDiagnosticEvent,
@@ -17,6 +18,7 @@ import {
 	type CursorPiToolBridgeRequestDiagnosticFields,
 	writeCursorPiToolBridgeDiagnostic,
 } from "./cursor-pi-tool-bridge-diagnostics.js";
+import { resolveCursorPiToolBridgeCallTimeoutMs } from "./cursor-pi-tool-bridge-env.js";
 import type {
 	CursorPiBridgeToolRequest,
 	CursorPiToolBridgeRun,
@@ -46,6 +48,7 @@ interface PendingBridgeCall {
 	reject: (error: Error) => void;
 	signal?: AbortSignal;
 	onAbort?: () => void;
+	timeout?: ReturnType<typeof setTimeout>;
 	settled: boolean;
 }
 
@@ -58,6 +61,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 	private readonly registry: CursorPiToolBridgeRunHost;
 	private readonly env: Record<string, string | undefined>;
 	private readonly endpointPath: string;
+	private readonly callTimeoutMs: number;
 	private readonly knownMcpToolNames: ReadonlySet<string>;
 	private readonly knownCursorMcpCallIds = new Set<string>();
 	private readonly queuedRequests: CursorPiBridgeToolRequest[] = [];
@@ -87,6 +91,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		this.debugRecorder = options.debugRecorder;
 		this.id = `cursor-pi-bridge-run-${randomUUID()}`;
 		this.endpointPath = `${MCP_ENDPOINT_ROOT}/${randomUUID()}/mcp`;
+		this.callTimeoutMs = resolveCursorPiToolBridgeCallTimeoutMs(env);
 		this.knownMcpToolNames = new Set(snapshot.tools.map((tool) => tool.mcpToolName));
 	}
 
@@ -218,7 +223,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		}
 		this.queuedRequests.splice(0);
 		for (const pending of [...this.pendingByBridgeCallId.values()]) {
-			this.rejectPending(pending, error, "cancelled");
+			this.rejectAndAbortPending(pending, error, "cancelled");
 		}
 	}
 
@@ -290,7 +295,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 				settled: false,
 			};
 			pending.onAbort = () => {
-				this.rejectPending(pending, new Error("Cursor MCP bridge tool request was aborted"), "cancelled");
+				this.rejectAndAbortPending(pending, new Error("Cursor MCP bridge tool request was aborted"), "cancelled");
 			};
 			if (signal?.aborted) {
 				pending.onAbort();
@@ -301,6 +306,11 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 			this.pendingByBridgeCallId.set(request.bridgeCallId, pending);
 			this.pendingByCursorMcpCallId.set(cursorMcpCallId, pending);
 			this.knownCursorMcpCallIds.add(cursorMcpCallId);
+			pending.timeout = setTimeout(() => {
+				const reason = `Cursor pi bridge CallTool timed out after ${this.callTimeoutMs} ms`;
+				this.rejectAndAbortPending(pending, new Error(reason));
+			}, this.callTimeoutMs);
+			pending.timeout.unref?.();
 			if (!this.onToolRequest) {
 				if (this.liveRunHandlerDetached) {
 					this.rejectPending(pending, new Error("Cursor pi tool bridge has no active live run"), "cancelled");
@@ -345,8 +355,8 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		pending.resolve(result);
 	}
 
-	private rejectPending(pending: PendingBridgeCall, error: Error, kind: "cancelled" | "error" = "error"): void {
-		if (pending.settled) return;
+	private rejectPending(pending: PendingBridgeCall, error: Error, kind: "cancelled" | "error" = "error"): boolean {
+		if (pending.settled) return false;
 		pending.settled = true;
 		this.removePending(pending);
 		this.emitRequestRejectedDiagnostic(pending.request, kind);
@@ -357,6 +367,17 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 			rejectionKind: kind,
 		});
 		pending.reject(error);
+		return true;
+	}
+
+	private rejectAndAbortPending(
+		pending: PendingBridgeCall,
+		error: Error,
+		kind: "cancelled" | "error" = "error",
+	): void {
+		if (this.rejectPending(pending, error, kind)) {
+			bridgeToolExecutionAbortTracker.abort(pending.request.piToolCallId, error.message);
+		}
 	}
 
 	private lifecycleDiagnosticFields(pendingCount = this.pendingCount()): CursorPiToolBridgeLifecycleDiagnosticFields {
@@ -401,7 +422,8 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 	}
 
 	private removePending(pending: PendingBridgeCall): void {
-		pending.signal?.removeEventListener("abort", pending.onAbort ?? (() => undefined));
+		if (pending.onAbort) pending.signal?.removeEventListener("abort", pending.onAbort);
+		if (pending.timeout) clearTimeout(pending.timeout);
 		this.pendingByPiToolCallId.delete(pending.request.piToolCallId);
 		this.pendingByBridgeCallId.delete(pending.request.bridgeCallId);
 		if (pending.request.cursorMcpCallId) this.pendingByCursorMcpCallId.delete(pending.request.cursorMcpCallId);

package/src/cursor-pi-tool-bridge.ts

@@ -7,10 +7,11 @@ import {
 } from "./cursor-pi-tool-bridge-diagnostics.js";
 import {
 	CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
+	CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV,
 	CURSOR_PI_TOOL_BRIDGE_ENV,
 } from "./cursor-pi-tool-bridge-env.js";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
-import { MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
+import { isCursorPiBridgeToolCallId, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
 import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
 import type {
 	CursorPiToolBridge,
@@ -34,8 +35,10 @@ export type { CursorPiToolBridgeDiagnosticEvent } from "./cursor-pi-tool-bridge-
 export { resolveCursorPiToolBridgeDebugEnabled } from "./cursor-pi-tool-bridge-diagnostics.js";
 export {
 	CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
+	CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV,
 	CURSOR_PI_TOOL_BRIDGE_ENV,
 	resolveCursorPiToolBridgeBuiltinsEnabled,
+	resolveCursorPiToolBridgeCallTimeoutMs,
 	resolveCursorPiToolBridgeEnabled,
 } from "./cursor-pi-tool-bridge-env.js";
 export {
@@ -91,7 +94,12 @@ export function registerCursorPiToolBridge(pi: CursorPiToolBridgeExtensionApi):
 	const bridge = new CursorPiToolBridgeRegistry(pi);
 	registeredCursorPiToolBridge = bridge;
 	pi.on("tool_call", (event, ctx) => {
-		if (!bridge.hasPendingPiToolCallId(event.toolCallId)) return undefined;
+		if (registeredCursorPiToolBridge !== bridge) return undefined;
+		if (!bridge.hasPendingPiToolCallId(event.toolCallId)) {
+			return isCursorPiBridgeToolCallId(event.toolCallId)
+				? { block: true, reason: "Cursor pi bridge tool call is no longer pending" }
+				: undefined;
+		}
 		const windowsAbortMarker = installWindowsBridgeBashAbortMarker(event);
 		const trackingStarted = bridgeToolExecutionAbortTracker.track(event.toolCallId, {
 			signal: ctx.signal,
@@ -124,6 +132,7 @@ export function getRegisteredCursorPiToolBridge(): CursorPiToolBridge | undefine
 export const __testUtils = {
 	CURSOR_PI_TOOL_BRIDGE_ENV,
 	CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
+	CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV,
 	CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV,
 	CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX,
 	LOOPBACK_HOST,

package/src/cursor-provider-errors.ts

@@ -1,4 +1,5 @@
 import type { RunError, RunResult } from "@cursor/sdk";
+import type { CursorRuntime } from "./cursor-config.js";
 import { asRecord } from "./cursor-record-utils.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 
@@ -8,6 +9,8 @@ const GENERIC_CURSOR_SDK_ERROR_MESSAGE =
 	"Cursor SDK request failed. The Cursor SDK API key may be missing, invalid, or unauthorized. Cursor Agent CLI/Desktop login is not reused. 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 Cursor SDK API key may be invalid or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
+const CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE =
+	"Cursor Cloud Agents request failed because Cloud API authentication rejected the API key. Use a user API key from Cursor Dashboard -> API Keys or a service account API key from Team settings; Team Admin API keys are not supported as Cursor Cloud Agents credentials. Configure the key with /login -> Use an API key -> Cursor, CURSOR_API_KEY, or --api-key, then retry.";
 // Keep "Network error" aligned with pi's agent-level retry classifier.
 const NETWORK_CURSOR_SDK_ERROR_MESSAGE =
 	"Network error: Cursor SDK request failed during network or service I/O. Check your connection; pi will retry automatically when auto-retry is enabled.";
@@ -40,6 +43,58 @@ function getErrorStringField(record: Record<string, unknown> | undefined, key: s
 	return typeof value === "string" ? value : undefined;
 }
 
+function getErrorName(error: unknown, record: Record<string, unknown> | undefined): string | undefined {
+	return error instanceof Error ? error.name : getErrorStringField(record, "name");
+}
+
+function scrubHttpsHelpUrl(helpUrl: string | undefined, apiKey: string | undefined): string | undefined {
+	if (!helpUrl) return undefined;
+	try {
+		const url = new URL(helpUrl);
+		if (url.protocol !== "https:") return undefined;
+		url.username = "";
+		url.password = "";
+		url.pathname = url.pathname
+			.split("/")
+			.map((segment) => {
+				const decoded = decodeURIComponent(segment);
+				const scrubbed = scrubSensitiveText(decoded, apiKey);
+				return scrubbed === decoded ? segment : encodeURIComponent(scrubbed);
+			})
+			.join("/");
+		const scrubbedParams = new URLSearchParams();
+		for (const [name, value] of url.searchParams) {
+			const scrubbedName = scrubSensitiveText(name, apiKey);
+			const scrubbedPair = scrubSensitiveText(`${name}=${value}`, apiKey);
+			scrubbedParams.append(scrubbedName, scrubbedPair === `${name}=${value}` ? value : "[redacted]");
+		}
+		url.search = scrubbedParams.toString();
+		if (url.hash) {
+			const decoded = decodeURIComponent(url.hash.slice(1));
+			const scrubbed = scrubSensitiveText(decoded, apiKey);
+			if (scrubbed !== decoded) url.hash = encodeURIComponent(scrubbed);
+		}
+		return scrubSensitiveText(url.href, apiKey).trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatIntegrationNotConnectedError(
+	error: unknown,
+	record: Record<string, unknown> | undefined,
+	scrubbedMessage: string,
+	apiKey: string | undefined,
+): string | undefined {
+	if (getErrorName(error, record) !== "IntegrationNotConnectedError") return undefined;
+	const provider = scrubSensitiveText(getErrorStringField(record, "provider") ?? "", apiKey).trim();
+	if (!provider) return undefined;
+	const message = scrubbedMessage || "Cursor Cloud integration is not connected.";
+	const punctuation = /[.!?]$/.test(message) ? "" : ".";
+	const helpUrl = scrubHttpsHelpUrl(getErrorStringField(record, "helpUrl"), apiKey);
+	return `${message}${punctuation} Connect the ${provider} integration${helpUrl ? `: ${helpUrl}` : "."}`;
+}
+
 function getErrorStack(error: unknown, record: Record<string, unknown> | undefined): string {
 	return error instanceof Error ? error.stack ?? "" : getErrorStringField(record, "stack") ?? "";
 }
@@ -278,12 +333,27 @@ export function resolveCursorSdkAbortCause(options: {
 	return "unknown";
 }
 
-export function sanitizeCursorProviderError(error: unknown, apiKey?: string): string {
+export function sanitizeCursorProviderError(
+	error: unknown,
+	apiKey?: string,
+	runtimeTarget?: CursorRuntime,
+): string {
+	const record = asRecord(error);
 	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
 	if (message === MISSING_CURSOR_API_KEY_MESSAGE) return MISSING_CURSOR_API_KEY_MESSAGE;
 	const scrubbed = scrubSensitiveText(message, apiKey).trim();
+	const integrationMessage = runtimeTarget === "cloud"
+		? formatIntegrationNotConnectedError(error, record, scrubbed, apiKey)
+		: undefined;
+	if (integrationMessage) return integrationMessage;
 	const connectClassification = classifyCursorConnectError(error);
-	if (connectClassification?.kind === "unauthenticated" || isLikelyAuthError(scrubbed)) return AUTH_CURSOR_SDK_ERROR_MESSAGE;
+	if (
+		(runtimeTarget === "cloud" && getErrorName(error, record) === "AuthenticationError") ||
+		connectClassification?.kind === "unauthenticated" ||
+		isLikelyAuthError(scrubbed)
+	) {
+		return runtimeTarget === "cloud" ? CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE : AUTH_CURSOR_SDK_ERROR_MESSAGE;
+	}
 	if (connectClassification?.kind === "network" || isLikelyNetworkTimeout(scrubbed)) return NETWORK_CURSOR_SDK_ERROR_MESSAGE;
 	if (isGenericCursorRunFailureMessage(scrubbed)) return RETRYABLE_CURSOR_RUN_FAILURE_PREFIX;
 	if (isGenericErrorMessage(scrubbed)) return GENERIC_CURSOR_SDK_ERROR_MESSAGE;

package/src/cursor-provider-live-run-drain.ts

@@ -278,9 +278,10 @@ async function emitCursorLiveRunPendingToolUseTurn(
 		if (options.mode === "emit") turn.emitter.closeAll();
 		emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, active, debugRecorder);
 	} else {
+		const requests = cursorLiveRuns.collectBridgeToolBatch(run);
+		if (requests.length === 0) return "handled";
 		if (!sdkTurnEnded) cursorLiveRuns.ignoreFutureSdkTurnUsage(run);
 		if (options.mode === "emit") turn.emitter.closeAll();
-		const requests = cursorLiveRuns.collectBridgeToolBatch(run);
 		emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests);
 	}
 	return "tool_use";

package/src/cursor-provider-run-finalizer.ts

@@ -10,6 +10,7 @@ import {
 	resolveCursorSdkAbortCause,
 	sanitizeCursorProviderError,
 } from "./cursor-provider-errors.js";
+import type { CursorRuntime } from "./cursor-config.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
@@ -70,6 +71,7 @@ export interface CursorRunFinalizerParams {
 	sdkEventDebug: () => CursorSdkEventDebugSink | undefined;
 	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	resolvedApiKey: () => string | undefined;
+	runtimeTarget: () => CursorRuntime | undefined;
 }
 
 export interface StartCursorLiveRunCompletionParams {
@@ -112,7 +114,7 @@ export class CursorRunFinalizer {
 				if (!liveRun.disposed) {
 					cursorLiveRuns.markError(
 						liveRun,
-						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey),
+						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"),
 					);
 				}
 				this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) }));
@@ -212,7 +214,11 @@ export class CursorRunFinalizer {
 			this.pushTerminalError(
 				this.params.runnerParams.partial,
 				"error",
-				sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey),
+				sanitizeCursorProviderError(
+					error,
+					this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey,
+					prepared?.runtimeTarget ?? this.params.runtimeTarget(),
+				),
 			);
 		}
 	}

package/src/cursor-provider-run-outcome.ts

@@ -6,6 +6,7 @@ import {
 	resolveCursorSdkAbortCause,
 	sanitizeCursorProviderError,
 } from "./cursor-provider-errors.js";
+import type { CursorRuntime } from "./cursor-config.js";
 import { hasUsableText } from "./cursor-record-utils.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
@@ -45,6 +46,7 @@ export interface ResolveCursorRunOutcomeParams {
 	runErrorFallback?: RunError;
 	resolvedApiKey?: string;
 	optionsApiKey?: string;
+	runtimeTarget: CursorRuntime;
 }
 
 function hasCursorAssistantText(
@@ -104,7 +106,11 @@ export function resolveCursorRunOutcome(params: ResolveCursorRunOutcomeParams):
 				status: "error",
 				assistantTextProduced: false,
 			}),
-			errorMessage: sanitizeCursorProviderError(failureDetail, params.resolvedApiKey ?? params.optionsApiKey),
+			errorMessage: sanitizeCursorProviderError(
+				failureDetail,
+				params.resolvedApiKey ?? params.optionsApiKey,
+				params.runtimeTarget,
+			),
 		};
 	}
 

package/src/cursor-provider-turn-finalize.ts

@@ -1,4 +1,4 @@
-import type { RunError, SDKAgent } from "@cursor/sdk";
+import type { LocalAgentStore, RunError, SDKAgent } from "@cursor/sdk";
 import { loadCursorTranscriptWebToolCallsAfterOffset } from "./cursor-agent-message-web-tools.js";
 import {
 	collectCursorCloudRunReport,
@@ -18,11 +18,21 @@ import {
 import type { CursorProviderTurnPrepareResult } from "./cursor-provider-turn-types.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 
-export async function cacheSdkContextWindow(agentId: string, modelId: string, cwd?: string): Promise<void> {
+export async function cacheSdkContextWindow(
+	agentId: string,
+	modelId: string,
+	cwd?: string,
+	store?: LocalAgentStore,
+): Promise<void> {
 	try {
 		const { createAgentPlatform } = await loadCursorSdk();
 		const platform = await createAgentPlatform(
-			cwd ? { workspaceRef: cwd, scopedWorkspaceRef: cwd } : undefined,
+			cwd || store
+				? {
+						...(cwd ? { workspaceRef: cwd, scopedWorkspaceRef: cwd } : {}),
+						...(store ? { localStore: store } : {}),
+					}
+				: undefined,
 		);
 		const checkpoint = await platform.checkpointStore.loadLatest(agentId);
 		const contextWindow = getCheckpointContextWindow(checkpoint);
@@ -57,6 +67,7 @@ export function buildCursorRunOutcomeFromWait(params: BuildCursorRunOutcomeParam
 		runErrorFallback: params.runErrorFallback,
 		resolvedApiKey: params.resolvedApiKey,
 		optionsApiKey: params.optionsApiKey,
+		runtimeTarget: prepared.runtimeTarget,
 	});
 }
 
@@ -64,6 +75,7 @@ async function replayCursorTranscriptWebToolCalls(
 	agentId: string,
 	cwd: string,
 	messageOffset: number | undefined,
+	turnStore: LocalAgentStore,
 	turnCoordinator: CursorSdkTurnCoordinator,
 	sdkEventDebug: CursorSdkEventDebugSink | undefined,
 ): Promise<void> {
@@ -72,6 +84,7 @@ async function replayCursorTranscriptWebToolCalls(
 			agentId,
 			cwd,
 			offset: messageOffset,
+			store: turnStore,
 		});
 		if (transcriptToolCalls.length === 0) return;
 		sdkEventDebug?.recordCoordinatorEvent("cursor-transcript-web-tools", {
@@ -175,6 +188,7 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 			params.run.agentId,
 			params.prepared.cwd,
 			params.cursorAgentMessageOffset,
+			params.prepared.sessionAgentLease.store,
 			params.prepared.runtime.turnCoordinator,
 			params.sdkEventDebug,
 		);
@@ -186,7 +200,12 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 		// Debug artifact failures must never affect provider execution.
 	}
 	if (params.prepared.runtimeTarget === "local" && params.cacheContextWindow !== false) {
-		await cacheSdkContextWindow(params.contextWindowAgentId ?? params.run.agentId, params.modelId, params.prepared.cwd);
+		await cacheSdkContextWindow(
+			params.contextWindowAgentId ?? params.run.agentId,
+			params.modelId,
+			params.prepared.cwd,
+			params.prepared.sessionAgentLease.store,
+		);
 	}
 	return { outcome, displayOnlyTraceBlock };
 }

package/src/cursor-provider-turn-prepare.ts

@@ -1,6 +1,8 @@
 import type { Context, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
 import type { AgentModeOption, ModelSelection, SDKAgent } from "@cursor/sdk";
+import { configureCursorSdkHttp1 } from "./cursor-http1.js";
 import { installCursorMcpToolTimeoutOverride } from "./cursor-mcp-timeout-override.js";
+import { ensureCursorRipgrepPath } from "./cursor-ripgrep-path.js";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-sdk-output-filter.js";
 import {
 	acquireSessionCursorAgent,
@@ -32,9 +34,9 @@ import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
 import {
 	formatCursorCloudPreflightError,
 	buildCursorCloudAgentOptions,
-	inspectCursorCloudLocalState,
 	preflightCursorCloudRuntime,
 } from "./cursor-cloud-options.js";
+import { inspectCursorCloudLocalState } from "./cursor-cloud-local-state.js";
 import { getCursorSessionName, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
 import {
@@ -127,7 +129,12 @@ async function prepareCursorCloudProviderTurn(
 	try {
 		const preflight = preflightCursorCloudRuntime({
 			resolvedConfig,
-			localState: inspectCursorCloudLocalState(cwd),
+			localState: resolvedConfig.cloud.allowLocalState.value
+				? { insideGitRepo: false }
+				: inspectCursorCloudLocalState(cwd, {
+					repo: resolvedConfig.cloud.repo.value,
+					branch: resolvedConfig.cloud.branch.value,
+				}),
 			hasPriorContext: context.messages.length > 1,
 		});
 		if (!preflight.ok) throw new Error(formatCursorCloudPreflightError(preflight));
@@ -241,11 +248,17 @@ async function prepareCursorLocalProviderTurn(
 	let completed = false;
 
 	try {
+		ensureCursorRipgrepPath();
 		const localSafety = {
 			autoReview: resolvedConfig.local.autoReview.value,
 			sandboxEnabled: resolvedConfig.local.sandboxEnabled.value,
 		};
-		const { Agent } = await loadCursorSdk();
+		const sdk = await loadCursorSdk();
+		const { Agent } = sdk;
+		const useHttp1ForAgent = configureCursorSdkHttp1(
+			sdk,
+			resolvedConfig.local.useHttp1ForAgent,
+		);
 
 		installCursorMcpToolTimeoutOverride();
 		restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
@@ -261,6 +274,7 @@ async function prepareCursorLocalProviderTurn(
 			settingSources,
 			localSafety,
 			localResume: resolvedConfig.local.resume.value,
+			useHttp1ForAgent,
 			debugRecorder: sdkEventDebug,
 			onBridgeToolRequest: (request: CursorPiBridgeToolRequest) => {
 				if (liveRunForBridgeQueue && !liveRunForBridgeQueue.disposed) {

package/src/cursor-provider-turn-runner.ts

@@ -3,6 +3,7 @@ import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run
 import { invalidateSessionAgent } from "./cursor-session-agent.js";
 import { getCursorSessionCwd, getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
+import type { CursorRuntime } from "./cursor-config.js";
 import { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
 import {
@@ -38,6 +39,7 @@ function requireLocalLivePreparedTurn(prepared: CursorProviderTurnPrepareResult)
 export class CursorProviderTurnRunner {
 	private sdkEventDebug: CursorSdkEventDebugSink | undefined;
 	private resolvedApiKey: string | undefined;
+	private runtimeTarget: CursorRuntime | undefined;
 
 	constructor(private readonly params: CursorProviderTurnRunnerParams) {}
 
@@ -59,6 +61,7 @@ export class CursorProviderTurnRunner {
 			sdkEventDebug: () => this.sdkEventDebug,
 			sdkProcessErrorGuard,
 			resolvedApiKey: () => this.resolvedApiKey,
+			runtimeTarget: () => this.runtimeTarget,
 		});
 
 		try {
@@ -74,6 +77,7 @@ export class CursorProviderTurnRunner {
 			// Resolved once here, before any drain await, so the drain decision and the
 			// prepare dispatch below always act on the same config snapshot.
 			const resolvedConfig = resolveCursorProviderTurnConfig(cwd);
+			this.runtimeTarget = resolvedConfig.runtime.value;
 			if (resolvedConfig.runtime.value === "local") {
 				// The observed local-executor closed-pipe EPIPE is contained only from this
 				// turn's pre-send live-run drain through run completion; for live runs the
@@ -163,6 +167,7 @@ export class CursorProviderTurnRunner {
 			sdkEventDebug: () => this.sdkEventDebug,
 			sdkProcessErrorGuard: installCursorSdkProcessErrorGuard(),
 			resolvedApiKey: () => this.resolvedApiKey,
+			runtimeTarget: () => this.runtimeTarget,
 		});
 		await runFinalizer.applyTerminalEvent({ kind: "error", prepared: undefined, error });
 		await runFinalizer.cleanup(undefined, undefined, undefined);

package/src/cursor-provider-turn-send.ts

@@ -76,7 +76,7 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 		let cursorAgentMessageOffset: number | undefined;
 		if (prepared.runtimeTarget === "local") {
 			try {
-				cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd);
+				cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd, prepared.sessionAgentLease.store);
 			} catch (error) {
 				recordDebug(() => sdkEventDebug?.recordError("cursor_agent_message_count", error));
 			}

package/src/cursor-question-tool.ts

@@ -2,11 +2,17 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { arePiToolsDisabled } from "./cursor-active-tools.js";
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle, type CursorModelLifecycleExtensionApi } from "./cursor-model-lifecycle.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
 
 export const CURSOR_ASK_QUESTION_TOOL_NAME = "cursor_ask_question";
+export const CURSOR_ASK_QUESTION_ENV = "PI_CURSOR_ASK_QUESTION";
+
+export function resolveCursorAskQuestionEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return parseEnvBoolean(env[CURSOR_ASK_QUESTION_ENV], true);
+}
 
 interface CursorQuestionOption {
 	label: string;
@@ -188,6 +194,8 @@ function syncCursorQuestionToolForModel(pi: Pick<ExtensionAPI, "getActiveTools"
 }
 
 export function registerCursorQuestionTool(pi: CursorQuestionToolExtensionApi): void {
+	if (!resolveCursorAskQuestionEnabled()) return;
+
 	pi.registerTool({
 		name: CURSOR_ASK_QUESTION_TOOL_NAME,
 		label: "Cursor question",

package/src/cursor-ripgrep-path.ts

@@ -0,0 +1,32 @@
+import { accessSync, constants } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join } from "node:path";
+
+const RIPGREP_ENV = "CURSOR_RIPGREP_PATH";
+
+export function resolveBundledCursorRipgrepPath(
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	try {
+		const require = createRequire(fromModuleUrl);
+		const platformPackage = `@cursor/sdk-${process.platform}-${process.arch}`;
+		const sdkEntry = require.resolve("@cursor/sdk");
+		const packageDirectory = dirname(
+			require.resolve(`${platformPackage}/package.json`, { paths: [dirname(sdkEntry)] }),
+		);
+		const ripgrepPath = join(packageDirectory, "bin", process.platform === "win32" ? "rg.exe" : "rg");
+		accessSync(ripgrepPath, constants.X_OK);
+		return ripgrepPath;
+	} catch {
+		return undefined;
+	}
+}
+
+export function ensureCursorRipgrepPath(): string | undefined {
+	const configuredPath = process.env[RIPGREP_ENV];
+	if (configuredPath && isAbsolute(configuredPath)) return configuredPath;
+
+	const bundledPath = resolveBundledCursorRipgrepPath();
+	if (bundledPath) process.env[RIPGREP_ENV] = bundledPath;
+	return bundledPath;
+}