pi-cursor-sdk 0.1.37 → 0.1.39

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

@@ -13,7 +13,7 @@ import {
 	type IncompleteCursorToolRunOutcome,
 } from "./cursor-incomplete-tool-visibility.js";
 import { getToolName } from "./cursor-transcript-utils.js";
-import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getNormalizedCursorToolName } from "./cursor-tool-visibility.js";
 import { buildCursorPiToolDisplay } from "./cursor-tool-transcript.js";
 import { getField } from "./cursor-record-utils.js";
 import { CursorTurnDisplayRouter } from "./cursor-provider-turn-display-router.js";
@@ -24,6 +24,7 @@ import {
 import { resolveCursorToolCompletion } from "./cursor-provider-turn-sdk-normalizer.js";
 import {
 	CursorShellOutputTracker,
+	formatCursorShellOutputProgressText,
 	getCursorShellOutputDelta,
 	isCursorShellToolCall,
 } from "./cursor-provider-turn-shell-output.js";
@@ -32,10 +33,6 @@ import {
 	getToolFingerprint,
 } from "./cursor-provider-turn-tool-ledger.js";
 
-function getNormalizedCursorToolName(toolCall: unknown): string {
-	return classifyCursorToolVisibility(toolCall).normalizedName;
-}
-
 export interface CursorSdkTurnCoordinatorOptions {
 	stream: AssistantMessageEventStream;
 	partial: AssistantMessage;
@@ -207,11 +204,24 @@ export class CursorSdkTurnCoordinator {
 				identity: resolution.identity,
 				source: resolution.source,
 			});
+			if (resolution.matchedStartedCallId && resolution.matchedStartedCallId !== update.callId) {
+				this.ledger.recordCompletedIdentity(`cursor-tool:${resolution.matchedStartedCallId}`);
+			}
 			return;
 		}
 		if (update.type === "shell-output-delta") {
 			const delta = getCursorShellOutputDelta(update);
-			if (delta) this.shellOutput.appendShellOutputDelta(delta);
+			if (delta) {
+				const progress = this.shellOutput.appendShellOutputDelta(delta);
+				const progressText = progress ? formatCursorShellOutputProgressText(progress, this.resolvedApiKey) : undefined;
+				if (progressText) {
+					if (this.liveRun) {
+						cursorLiveRuns.queueEvent(this.liveRun, { type: "thinking-delta", text: progressText });
+					} else {
+						this.contentEmitter.appendThinkingDelta(progressText);
+					}
+				}
+			}
 			return;
 		}
 		if (update.type === "summary") {

package/src/cursor-provider-turn-display-router.ts

@@ -10,7 +10,11 @@ import {
 	type IncompleteCursorToolDiscardReason,
 } from "./cursor-incomplete-tool-visibility.js";
 import { scrubPiToolDisplay, scrubSensitiveText } from "./cursor-sensitive-text.js";
-import { buildCursorPiToolDisplay, formatCursorToolTranscript, getCursorCreatePlanText } from "./cursor-tool-transcript.js";
+import {
+	buildCursorPiToolDisplay,
+	formatCursorToolTranscript,
+	getCursorCreatePlanText,
+} from "./cursor-tool-transcript.js";
 import { getToolName } from "./cursor-transcript-utils.js";
 import type { CursorPartialContentEmitter } from "./cursor-partial-content-emitter.js";
 import type { CursorToolDisplaySource } from "./cursor-provider-turn-tool-ledger.js";

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

@@ -1,10 +1,10 @@
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import {
+	cursorLiveRuns,
 	drainCursorLiveRunTurn,
 	flushPendingCursorLiveRunTraceEventsToStream,
 	settleCursorLiveToolBatch,
 } from "./cursor-provider-live-run-drain.js";
-import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
 	type IncompleteCursorToolRunOutcomeInput,

package/src/cursor-provider-turn-lifecycle-emitter.ts

@@ -8,13 +8,9 @@ import {
 	formatCursorToolLifecycleProgressText,
 	isCursorToolLifecycleEligible,
 } from "./cursor-tool-lifecycle.js";
-import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getNormalizedCursorToolName } from "./cursor-tool-visibility.js";
 import { getStartedToolCallFingerprint } from "./cursor-provider-turn-tool-ledger.js";
 
-function getNormalizedCursorToolName(toolCall: unknown): string {
-	return classifyCursorToolVisibility(toolCall).normalizedName;
-}
-
 export interface CursorToolLifecycleEmitterOptions {
 	liveRun?: CursorLiveRun;
 	resolvedApiKey?: string;

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

@@ -8,23 +8,27 @@ import {
 	resetSessionCursorAgent,
 } from "./cursor-session-agent.js";
 import type { CursorPiBridgeToolRequest } from "./cursor-pi-tool-bridge.js";
-import { estimateCursorPromptInputTokens, getCursorPromptOptions } from "./cursor-usage-accounting.js";
+import { estimateCursorPromptTokens } from "./context.js";
+import { getCursorPromptOptions } from "./cursor-usage-accounting.js";
 import { getActiveContextToolNames } from "./cursor-context-tools.js";
 import type { CursorLiveRun } from "./cursor-live-run-coordinator.js";
-import { abandonSessionCursorAgent, cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
-import { createCursorNativeReplayId } from "./cursor-provider-live-run-drain.js";
-import { getEffectiveCursorAgentMode, getEffectiveFastForModelId } from "./cursor-state.js";
+import {
+	abandonSessionCursorAgent,
+	createCursorNativeReplayId,
+	cursorLiveRuns,
+} from "./cursor-provider-live-run-drain.js";
+import { getCursorProviderAgentModeOrThrow, getEffectiveFastForModelId } from "./cursor-state.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
 import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
-import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-snapshot.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.js";
+import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display-state.js";
 import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
-import { resolveCursorApiKey } from "./cursor-provider-turn-api-key.js";
+import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import type {
 	CursorProviderTurnPrepareResult,
@@ -53,7 +57,7 @@ export async function prepareCursorProviderTurn(
 
 	try {
 		const fastEnabled = getEffectiveFastForModelId(model.id);
-		const agentMode = getEffectiveCursorAgentMode();
+		const agentMode = getCursorProviderAgentModeOrThrow();
 		const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 		const settingSources = getEffectiveCursorSettingSources();
 		const { Agent } = await loadCursorSdk();
@@ -116,7 +120,7 @@ export async function prepareCursorProviderTurn(
 			images: prompt.images.length > 0 ? prompt.images : undefined,
 		};
 		const sessionBridgeRun = bridgeRun;
-		const promptInputTokens = estimateCursorPromptInputTokens(prompt, promptOptions);
+		const promptInputTokens = estimateCursorPromptTokens(prompt, promptOptions);
 		const useNativeToolReplay = isCursorNativeToolDisplayRuntimeEnabled();
 		const activeToolNames = getActiveContextToolNames(context);
 		sdkEventDebug?.recordProviderMeta({

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

@@ -1,6 +1,6 @@
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run-drain.js";
-import { getCursorSessionCwd } from "./cursor-session-cwd.js";
+import { getCursorSessionCwd } from "./cursor-session-scope.js";
 import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
@@ -17,7 +17,6 @@ import type {
 	CursorProviderTurnSendResult,
 } from "./cursor-provider-turn-types.js";
 
-export { resolveCursorApiKey } from "./cursor-provider-turn-api-key.js";
 export type { CursorProviderTurnRunnerParams } from "./cursor-provider-turn-types.js";
 
 export class CursorProviderTurnRunner {
@@ -34,13 +33,6 @@ export class CursorProviderTurnRunner {
 		if (this.options?.signal?.aborted) throw new CursorLiveRunAbortError();
 	}
 
-	private discardIncompleteTools(
-		prepared: CursorProviderTurnPrepareResult | undefined,
-		outcome: import("./cursor-incomplete-tool-visibility.js").IncompleteCursorToolRunOutcomeInput,
-	): void {
-		discardIncompleteToolsFromPrepared(prepared, outcome);
-	}
-
 	async run(sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>): Promise<void> {
 		const { stream, partial, model, context, options, sdkEventDebugRef } = this.params;
 		let prepared: CursorProviderTurnPrepareResult | undefined;
@@ -94,13 +86,13 @@ export class CursorProviderTurnRunner {
 					send,
 					prepared,
 					modelId: model.id,
-					discardIncompleteTools: (outcome) => this.discardIncompleteTools(prepared, outcome),
+					discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(prepared, outcome),
 				});
 				await emitCursorLiveTurn({
 					params: this.params,
 					prepared,
 					sdkEventDebug: this.sdkEventDebug,
-					discardIncompleteTools: (outcome) => this.discardIncompleteTools(prepared, outcome),
+					discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(prepared, outcome),
 				});
 				return;
 			}

package/src/cursor-provider-turn-sdk-normalizer.ts

@@ -1,4 +1,4 @@
-import { mergeCursorToolCalls } from "./cursor-tool-transcript.js";
+import { asRecord } from "./cursor-record-utils.js";
 import type { CursorLiveRun } from "./cursor-live-run-coordinator.js";
 import {
 	mergeShellOutputDeltasIntoCursorToolCall,
@@ -8,6 +8,22 @@ import type { CursorToolCompletionLedger } from "./cursor-provider-turn-tool-led
 
 export type CursorToolCompletionSource = "delta" | "step";
 
+function mergeCursorToolCalls(startedToolCall: unknown, completedToolCall: unknown): unknown {
+	const started = asRecord(startedToolCall);
+	const completed = asRecord(completedToolCall);
+	if (!started) return completedToolCall;
+	if (!completed) return startedToolCall;
+	return {
+		...started,
+		...completed,
+		name: completed.name ?? started.name,
+		type: completed.type ?? started.type,
+		args: completed.args ?? started.args,
+		input: completed.input ?? started.input,
+		result: completed.result ?? started.result,
+	};
+}
+
 export type ToolCompletionResolution =
 	| { action: "ignore-bridge"; identity?: string }
 	| {
@@ -47,15 +63,22 @@ export function resolveCursorToolCompletion(options: ResolveCursorToolCompletion
 		const callId = options.callId;
 		identity = typeof callId === "string" ? `cursor-tool:${callId}` : undefined;
 		resolvedToolCall = mergeCursorToolCalls(options.startedToolCall, options.toolCall);
-		if (typeof callId === "string") {
+		if (typeof callId === "string" && options.ledger.hasStartedToolCall(callId)) {
 			options.onClearStartedCallId?.(callId);
 			options.ledger.clearStartedToolCall(callId);
+		} else {
+			matchedStartedCallId = options.ledger.removeStartedToolCallForStep(options.toolCall, callId);
+			if (matchedStartedCallId) options.onClearStartedCallId?.(matchedStartedCallId);
 		}
 		resolvedToolCall = mergeShellOutputDeltasIntoCursorToolCall(
 			resolvedToolCall,
-			typeof callId === "string" ? options.shellOutput.takeDeltasForCall(callId) : undefined,
+			matchedStartedCallId
+				? options.shellOutput.takeDeltasForCall(matchedStartedCallId)
+				: typeof callId === "string"
+					? options.shellOutput.takeDeltasForCall(callId)
+					: undefined,
 		);
-		source = identity ? "started" : "fallback";
+		source = identity || matchedStartedCallId ? "started" : "fallback";
 	} else {
 		matchedStartedCallId = options.ledger.removeStartedToolCallForStep(options.toolCall, options.callId);
 		if (matchedStartedCallId) {
@@ -77,7 +100,7 @@ export function resolveCursorToolCompletion(options: ResolveCursorToolCompletion
 	}
 
 	if (options.source === "delta") {
-		return { action: "handle", toolCall: resolvedToolCall, identity, source };
+		return { action: "handle", toolCall: resolvedToolCall, identity, source, matchedStartedCallId };
 	}
 	return {
 		action: "handle",

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

@@ -1,7 +1,7 @@
 import type { SendOptions } from "@cursor/sdk";
+import { countCursorAgentMessages } from "./cursor-agent-message-web-tools.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
-import { getCursorAgentMessageOffset } from "./cursor-provider-turn-message-offset.js";
 import type { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import type {
 	CursorProviderTurnRunnerParams,
@@ -41,7 +41,12 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 	try {
 		abortRegistration?.signal.addEventListener("abort", abortListener, { once: true });
 		throwIfAborted();
-		const cursorAgentMessageOffset = await getCursorAgentMessageOffset(agent.agentId, cwd, sdkEventDebug);
+		let cursorAgentMessageOffset: number | undefined;
+		try {
+			cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd);
+		} catch (error) {
+			sdkEventDebug?.recordError("cursor_agent_message_count", error);
+		}
 		throwIfAborted();
 		sdkEventDebug?.recordSendMeta({
 			mode: meta.sendPlan.mode,

package/src/cursor-provider-turn-shell-output.ts

@@ -1,5 +1,7 @@
 import type { InteractionUpdate } from "@cursor/sdk";
 import { asRecord, getField, hasUsableText } from "./cursor-record-utils.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
 import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
 
 export interface CursorShellOutputDelta {
@@ -12,6 +14,12 @@ export interface CursorShellOutputDeltas {
 	stderr: string[];
 }
 
+export interface CursorShellOutputProgressDelta extends CursorShellOutputDelta {
+	callId: string;
+}
+
+const SHELL_OUTPUT_PROGRESS_MAX_DELTAS_PER_CALL = 3;
+
 export function isCursorShellToolCall(toolCall: unknown): boolean {
 	return classifyCursorToolVisibility(toolCall).normalizedKey === "shell";
 }
@@ -27,6 +35,22 @@ export function getCursorShellOutputDelta(update: InteractionUpdate): CursorShel
 	return { stream: eventCase, data };
 }
 
+function getCursorShellOutputProgressPreview(data: string): string | undefined {
+	return data
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line.length > 0);
+}
+
+export function formatCursorShellOutputProgressText(
+	progress: CursorShellOutputProgressDelta,
+	apiKey?: string,
+): string | undefined {
+	const preview = getCursorShellOutputProgressPreview(progress.data);
+	if (!preview) return undefined;
+	return `Cursor shell ${progress.stream}: ${truncateCursorDisplayLine(scrubSensitiveText(preview, apiKey), 160)}\n`;
+}
+
 export function mergeShellOutputDeltasIntoCursorToolCall(
 	toolCall: unknown,
 	deltas: CursorShellOutputDeltas | undefined,
@@ -65,6 +89,7 @@ export class CursorShellOutputTracker {
 	private readonly activeShellCallIds = new Set<string>();
 	private readonly ambiguousShellOutputCallIds = new Set<string>();
 	private readonly shellOutputDeltasByCallId = new Map<string, CursorShellOutputDeltas>();
+	private readonly shellOutputProgressCountsByCallId = new Map<string, number>();
 
 	onShellToolStarted(callId: string): void {
 		this.activeShellCallIds.add(callId);
@@ -73,29 +98,38 @@ export class CursorShellOutputTracker {
 	onShellToolCleared(callId: string): void {
 		this.activeShellCallIds.delete(callId);
 		this.ambiguousShellOutputCallIds.delete(callId);
+		this.shellOutputProgressCountsByCallId.delete(callId);
 	}
 
-	appendShellOutputDelta(delta: CursorShellOutputDelta): void {
+	appendShellOutputDelta(delta: CursorShellOutputDelta): CursorShellOutputProgressDelta | undefined {
 		if (this.activeShellCallIds.size !== 1) {
 			for (const activeCallId of this.activeShellCallIds) {
 				this.ambiguousShellOutputCallIds.add(activeCallId);
 				this.shellOutputDeltasByCallId.delete(activeCallId);
+				this.shellOutputProgressCountsByCallId.delete(activeCallId);
 			}
-			return;
+			return undefined;
 		}
 		const [callId] = this.activeShellCallIds;
-		if (!callId || this.ambiguousShellOutputCallIds.has(callId)) return;
+		if (!callId || this.ambiguousShellOutputCallIds.has(callId)) return undefined;
 		let deltas = this.shellOutputDeltasByCallId.get(callId);
 		if (!deltas) {
 			deltas = { stdout: [], stderr: [] };
 			this.shellOutputDeltasByCallId.set(callId, deltas);
 		}
 		deltas[delta.stream].push(delta.data);
+
+		if (!getCursorShellOutputProgressPreview(delta.data)) return undefined;
+		const progressCount = this.shellOutputProgressCountsByCallId.get(callId) ?? 0;
+		if (progressCount >= SHELL_OUTPUT_PROGRESS_MAX_DELTAS_PER_CALL) return undefined;
+		this.shellOutputProgressCountsByCallId.set(callId, progressCount + 1);
+		return { ...delta, callId };
 	}
 
 	takeDeltasForCall(callId: string): CursorShellOutputDeltas | undefined {
 		const deltas = this.shellOutputDeltasByCallId.get(callId);
 		this.shellOutputDeltasByCallId.delete(callId);
+		this.shellOutputProgressCountsByCallId.delete(callId);
 		return deltas;
 	}
 
@@ -103,5 +137,6 @@ export class CursorShellOutputTracker {
 		this.activeShellCallIds.clear();
 		this.ambiguousShellOutputCallIds.clear();
 		this.shellOutputDeltasByCallId.clear();
+		this.shellOutputProgressCountsByCallId.clear();
 	}
 }

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

@@ -61,7 +61,7 @@ export type CursorProviderTurnRuntime = DirectCursorProviderTurnRuntime | LiveCu
  * Send, finalize, and cleanup phases receive this immutable object instead of
  * keeping parallel liveRun/turnCoordinator/resource bags in sync by convention.
  */
-export interface PreparedCursorProviderTurn {
+export interface CursorProviderTurnPrepareResult {
 	agent: SDKAgent;
 	cwd: string;
 	payload: CursorProviderTurnSendPayload;
@@ -74,8 +74,6 @@ export interface PreparedCursorProviderTurn {
 	runtime: CursorProviderTurnRuntime;
 }
 
-export type CursorProviderTurnPrepareResult = PreparedCursorProviderTurn;
-
 export interface CursorProviderTurnSend {
 	run: Awaited<ReturnType<SDKAgent["send"]>>;
 	cursorAgentMessageOffset: number | undefined;

package/src/cursor-provider.ts

@@ -8,6 +8,7 @@ import {
 	type SimpleStreamOptions,
 } from "@earendil-works/pi-ai";
 import {
+	cursorLiveRuns,
 	DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS,
 	getPendingCursorLiveRun,
 	hasTrailingUserMessagesAfterToolResults,
@@ -15,12 +16,12 @@ import {
 	resetCursorNativeReplayIdleDisposeMs,
 	setCursorNativeReplayIdleDisposeMs,
 } from "./cursor-provider-live-run-drain.js";
-import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import { disposeAllSessionCursorAgents } from "./cursor-session-agent.js";
 import { attachCursorSdkEventDebugPiStreamTap, type CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
-import { CursorProviderTurnRunner, resolveCursorApiKey } from "./cursor-provider-turn-runner.js";
+import { resolveCursorApiKey } from "./cursor-api-key.js";
+import { CursorProviderTurnRunner } from "./cursor-provider-turn-runner.js";
 
 function makeInitialMessage(model: Model<Api>): AssistantMessage {
 	return {

package/src/cursor-question-tool.ts

@@ -1,8 +1,9 @@
-import type { BeforeAgentStartEvent, ExtensionAPI, ExtensionContext, ExtensionHandler, SessionStartEvent, TurnStartEvent } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { isCursorModel } from "./cursor-model.js";
-import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge.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";
 
@@ -35,12 +36,7 @@ interface CursorQuestionDetails {
 	cancelled: boolean;
 }
 
-interface CursorQuestionToolExtensionApi extends Pick<ExtensionAPI, "getActiveTools" | "registerTool" | "setActiveTools"> {
-	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
-	on(event: "before_agent_start", handler: ExtensionHandler<BeforeAgentStartEvent>): void;
-	on(event: "turn_start", handler: ExtensionHandler<TurnStartEvent>): void;
-	on(event: "model_select", handler: (event: { model: ExtensionContext["model"] }, ctx: ExtensionContext) => Promise<void> | void): void;
-}
+interface CursorQuestionToolExtensionApi extends Pick<ExtensionAPI, "getActiveTools" | "registerTool" | "setActiveTools">, CursorModelLifecycleExtensionApi {}
 
 type RawQuestionOption = string | { label?: string; value?: string; description?: string };
 
@@ -232,16 +228,7 @@ export function registerCursorQuestionTool(pi: CursorQuestionToolExtensionApi):
 		},
 	});
 
-	pi.on("session_start", (_event, ctx) => {
-		syncCursorQuestionToolForModel(pi, ctx.model);
-	});
-	pi.on("before_agent_start", (_event, ctx) => {
+	registerCursorModelLifecycle(pi, (ctx) => {
 		syncCursorQuestionToolForModel(pi, ctx.model);
 	});
-	pi.on("turn_start", (_event, ctx) => {
-		syncCursorQuestionToolForModel(pi, ctx.model);
-	});
-	pi.on("model_select", (event) => {
-		syncCursorQuestionToolForModel(pi, event.model);
-	});
 }

package/src/cursor-record-utils.ts

@@ -10,6 +10,48 @@ export function hasUsableText(value: string | undefined): value is string {
 	return typeof value === "string" && value.trim().length > 0;
 }
 
+export function getString(record: Record<string, unknown> | undefined, key: string): string | undefined {
+	const value = record?.[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+export function getNumber(record: Record<string, unknown> | undefined, key: string): number | undefined {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function getBoolean(record: Record<string, unknown> | undefined, key: string): boolean | undefined {
+	const value = record?.[key];
+	return typeof value === "boolean" ? value : undefined;
+}
+
+export function getRecord(record: Record<string, unknown> | undefined, key: string): Record<string, unknown> | undefined {
+	return asRecord(record?.[key]);
+}
+
+export function getArray(record: Record<string, unknown> | undefined, key: string): unknown[] | undefined {
+	const value = record?.[key];
+	return Array.isArray(value) ? value : undefined;
+}
+
+export function firstNonEmptyString(...values: Array<string | undefined>): string | undefined {
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (trimmed) return trimmed;
+	}
+	return undefined;
+}
+
+export function stringifyUnknown(value: unknown, options: { pretty?: boolean } = {}): string {
+	if (value === undefined) return "";
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value, null, options.pretty ? 2 : undefined) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
 export function getFirstStringByKeys(
 	record: Record<string, unknown> | undefined,
 	keys: readonly string[],