@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.1

package/src/cursor-provider-errors.ts

@@ -1,5 +1,4 @@
 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";
 
@@ -9,8 +8,6 @@ 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.";
@@ -47,54 +44,6 @@ function getErrorName(error: unknown, record: Record<string, unknown> | undefine
 	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") ?? "";
 }
@@ -352,23 +301,14 @@ export function resolveCursorSdkAbortCause(options: {
 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 (
-		(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 === "unauthenticated" || isLikelyAuthError(scrubbed)) {
+		return AUTH_CURSOR_SDK_ERROR_MESSAGE;
 	}
 	if (connectClassification?.kind === "network" || isCursorSdkConnectionStalledError(error) || isLikelyNetworkTimeout(scrubbed)) return NETWORK_CURSOR_SDK_ERROR_MESSAGE;
 	if (isGenericCursorRunFailureMessage(scrubbed)) return RETRYABLE_CURSOR_RUN_FAILURE_PREFIX;

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

@@ -196,7 +196,6 @@ function emitCursorNativeToolUseTurn(
 		}
 	}
 	applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-		runtime: "local",
 		turn: cursorLiveRuns.takeSdkTurnUsage(run),
 	});
 	partial.stopReason = "toolUse";
@@ -244,7 +243,6 @@ function emitCursorBridgeToolUseTurn(
 		if (block.type === "toolCall") stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial });
 	}
 	applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-		runtime: "local",
 		turn: cursorLiveRuns.takeSdkTurnUsage(run),
 	});
 	partial.stopReason = "toolUse";
@@ -380,7 +378,6 @@ export async function drainCursorLiveRunTurn(
 					await emitTextDeltas(stream, partial, splitTextIntoReplayDeltas(finalText));
 				}
 				applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-					runtime: "local",
 					turn: cursorLiveRuns.takeSdkTurnUsage(run),
 					billed: run.billedTurnUsage,
 				});

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

@@ -10,7 +10,6 @@ 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,
@@ -25,7 +24,6 @@ import type {
 	CursorProviderTurnSend,
 	CursorProviderTurnSendResult,
 	LiveCursorProviderTurnRuntime,
-	LocalCursorProviderTurnPrepareResult,
 } from "./cursor-provider-turn-types.js";
 import { applyCursorUsage } from "./cursor-usage-accounting.js";
 import { hasUsableText } from "./cursor-record-utils.js";
@@ -35,13 +33,12 @@ export type CursorTurnTerminalEvent =
 			kind: "direct";
 			prepared: CursorProviderTurnPrepareResult;
 			outcome: CursorRunOutcome;
-			displayOnlyTraceBlock?: string;
 	  }
 	| { kind: "error"; prepared: CursorProviderTurnPrepareResult | undefined; error: unknown };
 
 function applyLiveRunOutcome(
 	outcome: CursorRunOutcome,
-	prepared: LocalCursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime },
+	prepared: CursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime },
 	context: CursorProviderTurnRunnerParams["context"],
 ): void {
 	if (prepared.runtime.liveRun.disposed) return;
@@ -71,12 +68,11 @@ export interface CursorRunFinalizerParams {
 	sdkEventDebug: () => CursorSdkEventDebugSink | undefined;
 	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	resolvedApiKey: () => string | undefined;
-	runtimeTarget: () => CursorRuntime | undefined;
 }
 
 export interface StartCursorLiveRunCompletionParams {
 	send: CursorProviderTurnSend;
-	prepared: LocalCursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
+	prepared: CursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
 	modelId: string;
 	discardIncompleteTools: (outcome: IncompleteCursorToolRunOutcomeInput) => void;
 }
@@ -114,7 +110,7 @@ export class CursorRunFinalizer {
 				if (!liveRun.disposed) {
 					cursorLiveRuns.markError(
 						liveRun,
-						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"),
+						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey),
 					);
 				}
 				this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) }));
@@ -129,7 +125,7 @@ export class CursorRunFinalizer {
 	async applyTerminalEvent(event: CursorTurnTerminalEvent): Promise<void> {
 		if (this.terminalApplied) return;
 		if (event.kind === "direct") {
-			await this.applyDirectOutcome(event.prepared, event.outcome, event.displayOnlyTraceBlock);
+			await this.applyDirectOutcome(event.prepared, event.outcome);
 			this.terminalApplied = true;
 			return;
 		}
@@ -165,7 +161,6 @@ export class CursorRunFinalizer {
 	private async applyDirectOutcome(
 		prepared: CursorProviderTurnPrepareResult,
 		outcome: CursorRunOutcome,
-		displayOnlyTraceBlock: string | undefined,
 	): Promise<void> {
 		const { stream, partial, model, context } = this.params.runnerParams;
 		prepared.runtime.turnCoordinator.closeTraceBlock();
@@ -184,12 +179,10 @@ export class CursorRunFinalizer {
 					outcome.kind === "finished" && hasUsableText(outcome.finalText) ? [outcome.finalText] : [],
 				);
 				applyCursorUsage(partial, model, context, prepared.meta.promptInputTokens, {
-					runtime: prepared.runtimeTarget,
 					turn: prepared.runtime.turnCoordinator.lastSdkTurnUsage,
 					billed: prepared.runtime.billedTurnUsage,
 				});
 				if (prepared.meta.resumeNotice) emitDisplayOnlyTraceBlock(stream, partial, prepared.meta.resumeNotice);
-				if (displayOnlyTraceBlock) emitDisplayOnlyTraceBlock(stream, partial, displayOnlyTraceBlock);
 				stream.push({ type: "done", reason: "stop", message: partial });
 				break;
 		}
@@ -219,7 +212,6 @@ export class CursorRunFinalizer {
 				sanitizeCursorProviderError(
 					error,
 					this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey,
-					prepared?.runtimeTarget ?? this.params.runtimeTarget(),
 				),
 			);
 		}

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

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

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

@@ -1,13 +1,6 @@
 import type { LocalAgentStore, RunError, SDKAgent } from "@cursor/sdk";
 import { loadCursorTranscriptWebToolCallsAfterOffset } from "./cursor-agent-message-web-tools.js";
-import {
-	collectCursorCloudRunReport,
-	formatCursorCloudRunReport,
-	type CursorCloudRunReport,
-} from "./cursor-cloud-reporting.js";
-import { recordCursorCloudLifecycleRun } from "./cursor-cloud-lifecycle.js";
 import { getCheckpointContextWindow, saveCachedContextWindow } from "./context-window-cache.js";
-import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import type { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import {
@@ -68,7 +61,6 @@ export function buildCursorRunOutcomeFromWait(params: BuildCursorRunOutcomeParam
 		runErrorFallback: params.runErrorFallback,
 		resolvedApiKey: params.resolvedApiKey,
 		optionsApiKey: params.optionsApiKey,
-		runtimeTarget: prepared.runtimeTarget,
 	});
 }
 
@@ -99,22 +91,6 @@ async function replayCursorTranscriptWebToolCalls(
 	}
 }
 
-function scrubCursorCloudReportingError(error: unknown, apiKey: string | undefined): Error {
-	return new Error(scrubSensitiveText(error instanceof Error ? error.message : String(error), apiKey));
-}
-
-function recordCursorCloudReportingError(
-	sdkEventDebug: CursorSdkEventDebugSink | undefined,
-	error: unknown,
-	apiKey: string | undefined,
-): void {
-	try {
-		sdkEventDebug?.recordError("cloud_run_report", scrubCursorCloudReportingError(error, apiKey));
-	} catch {
-		// Debug reporting must never affect provider execution.
-	}
-}
-
 export interface AwaitFinalizeCursorRunOutcomeParams {
 	run: Awaited<ReturnType<SDKAgent["send"]>>;
 	prepared: CursorProviderTurnPrepareResult;
@@ -134,12 +110,10 @@ export interface AwaitFinalizeCursorRunOutcomeParams {
 
 export interface FinalizedCursorRunOutcome {
 	outcome: CursorRunOutcome;
-	displayOnlyTraceBlock?: string;
 }
 
 /** Single wait/finalize path for SDK runs: wait, debug capture, transcript replay, incomplete tools, artifacts, context cache. */
 export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorRunOutcomeParams): Promise<FinalizedCursorRunOutcome> {
-	const apiKey = params.resolvedApiKey ?? params.optionsApiKey;
 	const waitResult = params.waitResult ?? (await params.run.wait());
 	const outcome = buildCursorRunOutcomeFromWait({
 		waitResult,
@@ -153,49 +127,17 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 	const billed = await attachCursorSdkBilledTurnUsage({
 		agent: params.prepared.agent,
 		agentId: params.run.agentId,
-		runtime: params.prepared.runtimeTarget,
-		runId: params.run.id,
 	});
 	params.prepared.runtime.billedTurnUsage = billed.turn;
 	if (params.prepared.runtime.liveRun) {
 		params.prepared.runtime.liveRun.billedTurnUsage = billed.turn;
 	}
-	let displayOnlyTraceBlock: string | undefined;
-	if (params.prepared.runtimeTarget === "cloud" && isCursorRunFinishedSuccessfully(outcome)) {
-		let report: CursorCloudRunReport = { agentId: params.run.agentId, runId: params.run.id, branches: [] };
-		try {
-			report = await collectCursorCloudRunReport({
-				agent: params.prepared.agent,
-				run: params.run,
-				waitResult,
-				apiKey,
-				agentUsage: billed.agentUsage,
-			});
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			recordCursorCloudLifecycleRun(report, { apiKey });
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			params.sdkEventDebug?.recordProviderEvent("cloud_run_report", report);
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			displayOnlyTraceBlock = formatCursorCloudRunReport(report, { apiKey });
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-	}
 	try {
 		params.sdkEventDebug?.recordWaitResult(waitResult);
 	} catch {
 		// Debug reporting must never affect provider execution.
 	}
-	if (params.prepared.runtimeTarget === "local" && isCursorRunFinishedSuccessfully(outcome)) {
+	if (isCursorRunFinishedSuccessfully(outcome)) {
 		await replayCursorTranscriptWebToolCalls(
 			params.run.agentId,
 			params.prepared.cwd,
@@ -211,7 +153,7 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 	} catch {
 		// Debug artifact failures must never affect provider execution.
 	}
-	if (params.prepared.runtimeTarget === "local" && params.cacheContextWindow !== false) {
+	if (params.cacheContextWindow !== false) {
 		await cacheSdkContextWindow(
 			params.contextWindowAgentId ?? params.run.agentId,
 			params.modelId,
@@ -219,5 +161,5 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 			params.prepared.sessionAgentLease.store,
 		);
 	}
-	return { outcome, displayOnlyTraceBlock };
+	return { outcome };
 }

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

@@ -1,8 +1,8 @@
 import type { Context, SimpleStreamOptions } from "@earendil-works/pi-ai";
-import type { AgentModeOption, ModelSelection, SDKAgent } from "@cursor/sdk";
+import type { AgentModeOption, ModelSelection } 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 { ensureCursorRipgrepPath, ensureCursorTreeSitterVendorDir } from "./cursor-sdk-platform-package.js";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-sdk-output-filter.js";
 import {
 	acquireSessionCursorAgent,
@@ -31,33 +31,21 @@ import { resolveEffectiveCursorConfig } from "./cursor-runtime-state.js";
 import { buildCursorBridgeExcludeToolNames, type CursorResolvedSdkConfig } from "./cursor-config.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
 import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
-import {
-	formatCursorCloudPreflightError,
-	buildCursorCloudAgentOptions,
-	preflightCursorCloudRuntime,
-} from "./cursor-cloud-options.js";
-import { inspectCursorCloudLocalState } from "./cursor-cloud-local-state.js";
-import { getCursorSessionName, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
+import { getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
 import {
 	buildCursorToolManifestText,
 	resolveCursorToolManifestEnabled,
 } from "./cursor-tool-manifest.js";
 import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display-state.js";
-import {
-	createCursorCloudLifecyclePersistenceError,
-	recordCursorCloudLifecycleSafely,
-} from "./cursor-cloud-lifecycle.js";
 import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import type {
-	CloudCursorProviderTurnPrepareResult,
 	CursorProviderTurnLifecycle,
 	CursorProviderTurnPrepareResult,
 	CursorProviderTurnRunnerParams,
-	LocalCursorProviderTurnPrepareResult,
 } from "./cursor-provider-turn-types.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import type { SessionCursorAgentLease } from "./cursor-session-agent.js";
@@ -78,32 +66,10 @@ interface PrepareCursorProviderTurnContext extends PrepareCursorProviderTurnPara
 	fastEnabled: boolean | undefined;
 }
 
-function buildCursorCloudPromptContext(context: Context, handoff: "fresh" | "bootstrap" | "never"): Context {
-	if (handoff === "bootstrap") return context;
-	for (let index = context.messages.length - 1; index >= 0; index -= 1) {
-		const message = context.messages[index];
-		if (message.role === "user") return { ...context, messages: [message] };
-	}
-	return { ...context, messages: context.messages.slice(-1) };
-}
-
-const CLOUD_SEND_PLAN: CursorSessionSendPlan = { mode: "bootstrap", resetAgent: false, reason: "initial" };
-
 export function resolveCursorProviderTurnConfig(cwd: string) {
 	return resolveEffectiveCursorConfig({ cwd, projectTrusted: getCursorSessionProjectTrusted() });
 }
 
-function buildCloudCursorProviderTurnLifecycle(agent: SDKAgent): CursorProviderTurnLifecycle {
-	return {
-		trackRunCompletion: () => {},
-		commitSend: () => {},
-		abandon: async () => {},
-		dispose: async () => {
-			await agent[Symbol.asyncDispose]?.();
-		},
-	};
-}
-
 function buildLocalCursorProviderTurnLifecycle(
 	lease: SessionCursorAgentLease,
 	scopeKey: string,
@@ -116,129 +82,9 @@ function buildLocalCursorProviderTurnLifecycle(
 	};
 }
 
-async function prepareCursorCloudProviderTurn(
-	prepareParams: PrepareCursorProviderTurnContext,
-): Promise<CloudCursorProviderTurnPrepareResult> {
-	const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
-	const { model, context, options } = params;
-
-	let restoreCursorSdkOutputFilter: (() => void) | undefined;
-	let cloudAgentForCleanup: SDKAgent | undefined;
-	let completed = false;
-
-	try {
-		const preflight = preflightCursorCloudRuntime({
-			resolvedConfig,
-			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));
-		if (getPendingCursorLiveRun(context) || getActiveCursorLiveRunForCurrentScope()) {
-			throw new Error("Cursor cloud runtime cannot start while a local Cursor live run is pending; finish or abort the local run, then retry.");
-		}
-
-		const { Agent } = await loadCursorSdk();
-		restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
-		const promptOptions = {
-			...getCursorPromptOptions(model),
-			agentMode,
-			includePiBridgeGuidance: false,
-			includePiAskQuestionGuidance: false,
-		};
-		const prompt = buildCursorPrompt(
-			buildCursorCloudPromptContext(context, resolvedConfig.cloud.contextHandoff.value),
-			promptOptions,
-		);
-		const promptInputTokens = estimateCursorPromptTokens(prompt, promptOptions);
-		const agent = await suppressCursorSdkOutput(() =>
-			Agent.create(buildCursorCloudAgentOptions({
-				apiKey: resolvedApiKey,
-				modelSelection: selection,
-				agentMode,
-				resolvedConfig,
-				name: getCursorSessionName(),
-			})),
-		);
-		cloudAgentForCleanup = agent;
-		if (!recordCursorCloudLifecycleSafely({ agentId: agent.agentId }, resolvedApiKey)) {
-			throw createCursorCloudLifecyclePersistenceError(agent.agentId, "intent", undefined, resolvedApiKey);
-		}
-		sdkEventDebug?.recordProviderMeta({ runtime: "cloud", cloudAgentId: agent.agentId, phase: "agent_created" });
-		throwIfAborted();
-
-		const textDeltas: string[] = [];
-		const nativeReplayId = createCursorNativeReplayId();
-		const turnCoordinator = new CursorSdkTurnCoordinator({
-			stream: params.stream,
-			partial: params.partial,
-			cwd,
-			resolvedApiKey,
-			useNativeToolReplay: false,
-			nativeReplayId,
-			textDeltas,
-			debugRecorder: sdkEventDebug,
-		});
-		sdkEventDebug?.recordProviderMeta({
-			runtime: "cloud",
-			cloudAgentId: agent.agentId,
-			model: {
-				id: model.id,
-				provider: model.provider,
-				api: model.api,
-				reasoning: options?.reasoning ?? "off",
-				fastEnabled,
-				selection,
-			},
-			contextHandoff: resolvedConfig.cloud.contextHandoff.value,
-			sendPlan: CLOUD_SEND_PLAN,
-			promptOptions,
-			agentMode,
-			localForce: false,
-		});
-
-		completed = true;
-		cloudAgentForCleanup = undefined;
-		return {
-			runtimeTarget: "cloud",
-			agent,
-			cwd,
-			payload: {
-				text: prompt.text,
-				images: prompt.images.length > 0 ? prompt.images : undefined,
-			},
-			meta: {
-				sendPlan: CLOUD_SEND_PLAN,
-				prompt,
-				bootstrap: true,
-				promptInputTokens,
-				useNativeToolReplay: false,
-				bridgeEnabled: false,
-				nativeReplayId,
-				agentMode,
-				modelSelection: selection,
-			},
-			contextWindowAgentId: agent.agentId,
-			textDeltas,
-			restoreCursorSdkOutputFilter,
-			lifecycle: buildCloudCursorProviderTurnLifecycle(agent),
-			runtime: { kind: "direct", turnCoordinator },
-		};
-	} finally {
-		if (!completed) {
-			await cloudAgentForCleanup?.[Symbol.asyncDispose]?.().catch(() => {});
-			restoreCursorSdkOutputFilter?.();
-		}
-	}
-}
-
 async function prepareCursorLocalProviderTurn(
 	prepareParams: PrepareCursorProviderTurnContext,
-): Promise<LocalCursorProviderTurnPrepareResult> {
+): Promise<CursorProviderTurnPrepareResult> {
 	const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
 	const { model, context, options } = params;
 
@@ -249,6 +95,7 @@ async function prepareCursorLocalProviderTurn(
 
 	try {
 		ensureCursorRipgrepPath();
+		ensureCursorTreeSitterVendorDir();
 		const localSafety = {
 			autoReview: resolvedConfig.local.autoReview.value,
 			sandboxEnabled: resolvedConfig.local.sandboxEnabled.value,
@@ -398,7 +245,6 @@ async function prepareCursorLocalProviderTurn(
 
 		completed = true;
 		return {
-			runtimeTarget: "local",
 			agent,
 			cwd,
 			payload: sendPayload,
@@ -439,21 +285,18 @@ async function prepareCursorLocalProviderTurn(
 	}
 }
 
-/** Resolves the runtime target from the caller-supplied snapshot and dispatches to the owning branch. */
 export async function prepareCursorProviderTurn(
 	prepareParams: PrepareCursorProviderTurnParams,
 ): Promise<CursorProviderTurnPrepareResult> {
-	const { params, resolvedConfig } = prepareParams;
+	const { params } = prepareParams;
 	const { model, options } = params;
 
 	const agentMode = getCursorProviderAgentModeOrThrow();
-	const fastEnabled = resolvedConfig.runtime.value === "cloud" ? undefined : getEffectiveFastForModelId(model.id);
+	const fastEnabled = getEffectiveFastForModelId(model.id);
 	const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 	const context: PrepareCursorProviderTurnContext = { ...prepareParams, agentMode, selection, fastEnabled };
 
-	return resolvedConfig.runtime.value === "cloud"
-		? prepareCursorCloudProviderTurn(context)
-		: prepareCursorLocalProviderTurn(context);
+	return prepareCursorLocalProviderTurn(context);
 }
 
 export function requireCursorApiKey(options: SimpleStreamOptions | undefined): string {