pi-cursor-sdk 0.1.56 → 0.1.57

package/src/cursor-session-scope.ts

@@ -1,11 +1,14 @@
-import type { ExtensionHandler, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import type { ExtensionHandler, SessionInfoChangedEvent, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
 
 interface CursorSessionScopeExtensionApi {
 	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
+	on(event: "session_info_changed", handler: ExtensionHandler<SessionInfoChangedEvent>): void;
 }
 
 const ANONYMOUS_SESSION_SCOPE_KEY = "__anonymous__";
 const EPHEMERAL_SESSION_SCOPE_PREFIX = "__ephemeral__:";
+export const MAX_CURSOR_SESSION_NAME_LENGTH = 100;
 
 type CursorSessionScopeChangeHandler = (previousScopeKey: string) => Promise<void> | void;
 
@@ -13,6 +16,8 @@ const state = {
 	sessionCwd: process.cwd(),
 	sessionFile: undefined as string | undefined,
 	sessionId: undefined as string | undefined,
+	sessionName: undefined as string | undefined,
+	projectTrusted: false,
 	sessionGeneration: 0,
 };
 
@@ -50,10 +55,31 @@ export function getCursorSessionCwd(): string {
 	return state.sessionCwd;
 }
 
-function setCursorSessionScope(cwd: string, sessionFile: string | undefined, sessionId?: string): void {
+export function getCursorSessionProjectTrusted(): boolean {
+	return state.projectTrusted;
+}
+
+export function getCursorSessionName(): string | undefined {
+	return state.sessionName;
+}
+
+function normalizeCursorSessionName(name: string | undefined): string | undefined {
+	if (name === undefined) return undefined;
+	return truncateCursorDisplayLine(name, MAX_CURSOR_SESSION_NAME_LENGTH) || undefined;
+}
+
+function setCursorSessionScope(
+	cwd: string,
+	sessionFile: string | undefined,
+	sessionId?: string,
+	projectTrusted = false,
+	sessionName?: string,
+): void {
 	state.sessionCwd = cwd;
 	state.sessionFile = sessionFile;
 	state.sessionId = sessionId;
+	state.sessionName = normalizeCursorSessionName(sessionName);
+	state.projectTrusted = projectTrusted;
 	state.sessionGeneration = nextSessionGeneration;
 	nextSessionGeneration += 1;
 	scopeGenerations.set(getCursorSessionScopeKey(), state.sessionGeneration);
@@ -63,6 +89,8 @@ function resetCursorSessionScope(): void {
 	state.sessionCwd = process.cwd();
 	state.sessionFile = undefined;
 	state.sessionId = undefined;
+	state.sessionName = undefined;
+	state.projectTrusted = false;
 	state.sessionGeneration = 0;
 	nextSessionGeneration = 1;
 	scopeGenerations.clear();
@@ -80,11 +108,16 @@ export function registerCursorSessionScope(pi: CursorSessionScopeExtensionApi):
 			ctx.cwd,
 			ctx.sessionManager?.getSessionFile?.() ?? undefined,
 			ctx.sessionManager?.getSessionId?.() ?? undefined,
+			ctx.isProjectTrusted?.() === true,
+			ctx.sessionManager?.getSessionName?.() ?? undefined,
 		);
 		if (previousScopeKey !== getCursorSessionScopeKey()) {
 			await scopeChangeHandler?.(previousScopeKey);
 		}
 	});
+	pi.on("session_info_changed", (event) => {
+		state.sessionName = normalizeCursorSessionName(event.name);
+	});
 }
 
 export const __testUtils = {

package/src/cursor-session-send-policy.ts

@@ -13,7 +13,7 @@ export const MAX_COMPLETED_INCREMENTAL_SENDS_BEFORE_REBOOTSTRAP = 20;
 
 export type CursorSessionSendMode = "bootstrap" | "incremental";
 
-export type CursorSessionSendReason = "initial" | "context_divergence" | "incremental_threshold" | "incremental";
+export type CursorSessionSendReason = "initial" | "context_divergence" | "incremental_threshold" | "process_resume" | "incremental";
 
 export interface CursorSessionSendPlan {
 	mode: CursorSessionSendMode;

package/src/cursor-skill-tool.ts

@@ -9,9 +9,11 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { arePiToolsDisabled } from "./cursor-active-tools.js";
+import type { CursorRuntime } from "./cursor-config.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";
+import { resolveEffectiveCursorConfigForContext } from "./cursor-runtime-state.js";
 
 export const CURSOR_ACTIVATE_SKILL_TOOL_NAME = "cursor_activate_skill";
 export const CURSOR_ACTIVATE_SKILL_MCP_NAME = "pi__cursor_activate_skill";
@@ -57,13 +59,24 @@ function getAvailableSkillNames(): string[] {
 	return [...currentSkillsByName.keys()].sort();
 }
 
-function shouldExposeSkillTool(model: ExtensionContext["model"]): boolean {
-	return isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
+function resolveEffectiveRuntimeForSkillLifecycle(
+	cursorModel: boolean,
+	ctx: Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "isProjectTrusted">>,
+): CursorRuntime {
+	return cursorModel ? resolveEffectiveCursorConfigForContext(ctx).runtime.value : "local";
 }
 
-function syncCursorSkillToolForModel(pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">, model: ExtensionContext["model"]): void {
+function shouldExposeSkillTool(model: ExtensionContext["model"], runtime: CursorRuntime): boolean {
+	return runtime === "local" && isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
+}
+
+function syncCursorSkillToolForModel(
+	pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">,
+	model: ExtensionContext["model"],
+	runtime: CursorRuntime,
+): void {
 	const activeToolNames = new Set(pi.getActiveTools());
-	const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model);
+	const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model, runtime);
 	const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
 	if (shouldBeActive === alreadyActive) return;
 	if (shouldBeActive) {
@@ -101,8 +114,10 @@ export function resolveCursorSkillSystemPrompt(
 	systemPrompt: string,
 	model: ExtensionContext["model"],
 	systemPromptOptions?: BuildSystemPromptOptions,
+	runtime: CursorRuntime = "local",
 ): string {
 	if (!isCursorModel(model)) return systemPrompt;
+	if (runtime === "cloud") return systemPrompt.replace(AVAILABLE_SKILLS_SECTION_PATTERN, "");
 	const skills = getVisibleSkills(systemPromptOptions?.skills);
 	if (skills.length === 0) return systemPrompt;
 	const replacement = formatCursorSkillsForPrompt(skills);
@@ -216,9 +231,9 @@ export function registerCursorSkillTool(pi: CursorSkillToolExtensionApi): void {
 		},
 	});
 
-	const clearSkillsAndSync = (model: ExtensionContext["model"]): void => {
+	const clearSkillsAndSync = (model: ExtensionContext["model"], runtime: CursorRuntime = "local"): void => {
 		setCurrentSkills([]);
-		syncCursorSkillToolForModel(pi, model);
+		syncCursorSkillToolForModel(pi, model, runtime);
 	};
 
 	registerCursorModelLifecycle(pi, {
@@ -229,17 +244,21 @@ export function registerCursorSkillTool(pi: CursorSkillToolExtensionApi): void {
 			clearSkillsAndSync(event.model);
 		},
 		turnStart: (_event, ctx) => {
-			if (!isCursorModel(ctx.model)) setCurrentSkills([]);
-			syncCursorSkillToolForModel(pi, ctx.model);
+			const cursorModel = isCursorModel(ctx.model);
+			const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
+			if (!cursorModel || runtime === "cloud") setCurrentSkills([]);
+			syncCursorSkillToolForModel(pi, ctx.model, runtime);
 		},
 		beforeAgentStart: (event, ctx) => {
-			if (isCursorModel(ctx.model)) {
+			const cursorModel = isCursorModel(ctx.model);
+			const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
+			if (cursorModel && runtime === "local") {
 				setCurrentSkills(event.systemPromptOptions?.skills);
 			} else {
 				setCurrentSkills([]);
 			}
-			syncCursorSkillToolForModel(pi, ctx.model);
-			const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions);
+			syncCursorSkillToolForModel(pi, ctx.model, runtime);
+			const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions, runtime);
 			if (resolved === event.systemPrompt) return undefined;
 			return { systemPrompt: resolved };
 		},

package/src/cursor-state.ts

@@ -1,13 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
 import type { AgentModeOption } from "@cursor/sdk";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 import {
 	buildCursorToolManifestText,
 	CURSOR_TOOL_MANIFEST_ENV,
 	resolveCursorToolManifestEnabled,
 } from "./cursor-tool-manifest.js";
+import { runCursorSessionAgentCleanupCommand } from "./cursor-session-agent-cleanup.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
 	CURSOR_PI_TOOL_BRIDGE_ENV,
@@ -22,11 +20,39 @@ import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
 import { asRecord } from "./cursor-record-utils.js";
 import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { refreshSessionCursorAgentConfig } from "./cursor-session-agent.js";
 import { getCursorModelMetadata } from "./model-discovery.js";
+import {
+	cursorFastDefaultsFromConfig,
+	getCursorSdkUserConfigPath,
+	loadCursorSdkUserConfig,
+	resolveCursorFastDefault,
+	saveCursorSdkUserConfig,
+	withCursorFastDefaults,
+	type CursorSdkConfig,
+} from "./cursor-config.js";
+import {
+	consumeCursorLocalForceOverride,
+	CURSOR_RUNTIME_ENTRY_TYPE,
+	formatCursorStatus,
+	getCursorCliConfig,
+	getCursorSessionConfig,
+	registerCursorCloudRuntimeControls,
+	resetCursorRuntimeStateForTests,
+	resolveCursorStatusRuntime,
+	restoreCursorCliState,
+	restoreSessionCursorRuntimeState,
+	type CursorRuntimeStateExtensionApi,
+} from "./cursor-runtime-state.js";
+
+export {
+	consumeCursorLocalForceOverride,
+	getCursorCliConfig,
+	getCursorSessionConfig,
+} from "./cursor-runtime-state.js";
 
 const FAST_ENTRY_TYPE = "cursor-fast-state";
 const MODE_ENTRY_TYPE = "cursor-mode-state";
-const GLOBAL_CONFIG_FILE = "cursor-sdk.json";
 
 export type CursorAgentMode = AgentModeOption;
 
@@ -42,14 +68,10 @@ interface CursorModeEntryData {
 	mode: AgentModeOption;
 }
 
-interface CursorGlobalConfig {
-	fastDefaults?: Record<string, boolean>;
-}
-
 type CursorRuntimeControlsExtensionApi = Pick<
 	ExtensionAPI,
 	"appendEntry" | "getFlag" | "registerFlag" | "registerCommand" | "on" | "getActiveTools" | "getAllTools"
->;
+> & CursorRuntimeStateExtensionApi;
 
 type CursorCliModeState =
 	| { kind: "unset" }
@@ -88,47 +110,22 @@ function isCursorModeEntryData(value: unknown): value is CursorModeEntryData {
 	return isCursorAgentMode(asRecord(value)?.mode);
 }
 
-function parseCursorGlobalConfig(value: unknown): CursorGlobalConfig | undefined {
-	const record = asRecord(value);
-	if (!record) return undefined;
-	const { fastDefaults } = record;
-	if (fastDefaults === undefined) return {};
-	const fastDefaultsRecord = asRecord(fastDefaults);
-	if (!fastDefaultsRecord) return undefined;
-	return {
-		fastDefaults: Object.fromEntries(
-			Object.entries(fastDefaultsRecord).filter((entry): entry is [string, boolean] => typeof entry[1] === "boolean"),
-		),
-	};
-}
-
 function getConfigPath(): string {
-	return join(getAgentDir(), GLOBAL_CONFIG_FILE);
+	return getCursorSdkUserConfigPath();
 }
 
 function loadGlobalFastPreferences(): Map<string, boolean> {
-	const path = getConfigPath();
-	if (!existsSync(path)) return new Map();
-	try {
-		const parsed = parseCursorGlobalConfig(JSON.parse(readFileSync(path, "utf-8")));
-		return new Map(Object.entries(parsed?.fastDefaults ?? {}));
-	} catch {
-		return new Map();
-	}
+	return cursorFastDefaultsFromConfig(loadCursorSdkUserConfig());
 }
 
 function saveGlobalFastPreferences(): void {
-	const path = getConfigPath();
-	mkdirSync(dirname(path), { recursive: true });
-	const config: CursorGlobalConfig = {
-		fastDefaults: Object.fromEntries([...globalFastPreferences.entries()].sort(([a], [b]) => a.localeCompare(b))),
-	};
-	writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+	const currentConfig: CursorSdkConfig = loadCursorSdkUserConfig();
+	saveCursorSdkUserConfig(withCursorFastDefaults(currentConfig, globalFastPreferences));
 }
 
-function restoreSessionFastPreferences(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
+function restoreSessionFastPreferences(branch: readonly SessionEntry[]): void {
 	sessionFastPreferences.clear();
-	for (const entry of ctx.sessionManager.getBranch()) {
+	for (const entry of branch) {
 		if (entry.type !== "custom" || entry.customType !== FAST_ENTRY_TYPE) continue;
 		if (isCursorFastEntryData(entry.data)) {
 			const modelId = getCursorFastEntryModelId(entry.data);
@@ -137,9 +134,9 @@ function restoreSessionFastPreferences(ctx: { sessionManager: Pick<ExtensionCont
 	}
 }
 
-function restoreSessionCursorMode(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
+function restoreSessionCursorMode(branch: readonly SessionEntry[]): void {
 	sessionCursorAgentMode = undefined;
-	for (const entry of ctx.sessionManager.getBranch()) {
+	for (const entry of branch) {
 		if (entry.type !== "custom" || entry.customType !== MODE_ENTRY_TYPE) continue;
 		if (isCursorModeEntryData(entry.data)) {
 			sessionCursorAgentMode = entry.data.mode;
@@ -147,6 +144,13 @@ function restoreSessionCursorMode(ctx: { sessionManager: Pick<ExtensionContext["
 	}
 }
 
+function restoreSessionCursorPreferences(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
+	const branch = ctx.sessionManager.getBranch();
+	restoreSessionCursorRuntimeState(branch);
+	restoreSessionFastPreferences(branch);
+	restoreSessionCursorMode(branch);
+}
+
 function getFastPreferenceModelId(metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>): string {
 	return metadata.selectionModelId || metadata.baseModelId;
 }
@@ -155,23 +159,25 @@ function getVirtualFastBaseModelId(modelId: string): string {
 	return modelId.replace(/:(?:fast|slow)$/, "");
 }
 
-function getStoredFastPreference(metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>): boolean | undefined {
+function getMapFastPreference(
+	map: Map<string, boolean>,
+	metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>,
+): boolean | undefined {
 	const preferenceModelId = getFastPreferenceModelId(metadata);
-	return (
-		sessionFastPreferences.get(preferenceModelId) ??
-		(preferenceModelId !== metadata.baseModelId ? sessionFastPreferences.get(metadata.baseModelId) : undefined) ??
-		globalFastPreferences.get(preferenceModelId) ??
-		(preferenceModelId !== metadata.baseModelId ? globalFastPreferences.get(metadata.baseModelId) : undefined)
-	);
+	return map.get(preferenceModelId) ?? (preferenceModelId !== metadata.baseModelId ? map.get(metadata.baseModelId) : undefined);
 }
 
 function getEffectiveFast(modelId: string): boolean | undefined {
 	const metadata = getCursorModelMetadata(modelId);
 	if (!metadata?.supportsFast) return undefined;
-	if (cliForceNoFast) return false;
-	if (cliForceFast) return true;
-	if (metadata.fastOverride !== undefined) return metadata.fastOverride;
-	return getStoredFastPreference(metadata) ?? metadata.defaultFast;
+	return resolveCursorFastDefault({
+		cliForceNoFast,
+		cliForceFast,
+		aliasOverride: metadata.fastOverride,
+		sessionValue: getMapFastPreference(sessionFastPreferences, metadata),
+		userValue: getMapFastPreference(globalFastPreferences, metadata),
+		modelDefault: metadata.defaultFast,
+	}).value;
 }
 
 function formatInvalidCursorMode(raw: string): string {
@@ -203,25 +209,24 @@ export function getCursorProviderAgentModeOrThrow(): AgentModeOption {
 	return resolution.mode;
 }
 
-function formatCursorStatus(fast: boolean | undefined): string {
-	const parts = [fast === true ? "cursor-fast:on" : fast === false ? "cursor-fast:off" : "cursor-fast:n/a"];
-	const modeResolution = resolveCursorAgentMode();
-	if (modeResolution.kind === "invalid") {
-		parts.push("mode invalid");
-	} else if (modeResolution.mode === "plan") {
-		parts.push("plan");
-	}
-	return parts.join(" · ");
-}
+type CursorStatusContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "isProjectTrusted">>;
 
-function updateCursorStatus(ctx: Pick<ExtensionContext, "model" | "ui">, model = ctx.model): void {
+function updateCursorStatus(ctx: CursorStatusContext & Pick<ExtensionContext, "model" | "ui">, model = ctx.model): void {
 	if (!model || !isCursorModel(model)) {
 		ctx.ui.setStatus("cursor", undefined);
 		return;
 	}
 	const metadata = getCursorModelMetadata(model.id);
-	const fast = metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
-	ctx.ui.setStatus("cursor", formatCursorStatus(fast));
+	const resolution = resolveCursorStatusRuntime(ctx);
+	const modeResolution = resolveCursorAgentMode();
+	const mode = modeResolution.kind === "invalid" ? "invalid" : modeResolution.mode;
+	if (resolution.kind === "invalid") {
+		ctx.ui.setStatus("cursor", formatCursorStatus("invalid", undefined, mode));
+		return;
+	}
+	const runtime = resolution.runtime.value;
+	const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
+	ctx.ui.setStatus("cursor", formatCursorStatus(runtime, fast, mode));
 }
 
 function getCurrentCursorMetadata(ctx: Pick<ExtensionContext, "model">) {
@@ -345,6 +350,8 @@ export function getEffectiveFastForModelId(modelId: string): boolean | undefined
 }
 
 export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtensionApi): void {
+	registerCursorCloudRuntimeControls(pi, { refreshStatus: updateCursorStatus });
+
 	pi.registerFlag("cursor-fast", {
 		description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
 		type: "boolean",
@@ -411,6 +418,35 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 		},
 	});
 
+	pi.registerCommand("cursor-local-resume-cleanup", {
+		description: "Dry-run or delete recorded superseded local Cursor SDK agents",
+		handler: async (args, ctx) => {
+			await runCursorSessionAgentCleanupCommand(pi, args, ctx);
+		},
+	});
+
+	pi.registerCommand("cursor-refresh-config", {
+		description: "Refresh filesystem Cursor config in the current pooled SDK agent",
+		handler: async (_args, ctx) => {
+			if (!isCursorModel(ctx.model)) {
+				ctx.ui.notify("Cursor config refresh is available only for Cursor models.", "info");
+				return;
+			}
+			try {
+				const result = await refreshSessionCursorAgentConfig();
+				const messages: Record<typeof result, string> = {
+					reloaded: "Cursor SDK agent config refreshed.",
+					"no-agent": "No Cursor SDK agent exists yet; config will load on the next Cursor run.",
+					busy: "Cursor SDK agent is still finalizing a run; retry /cursor-refresh-config after it finishes.",
+					unsupported: "Current Cursor SDK agent does not support config reload.",
+				};
+				ctx.ui.notify(messages[result], result === "reloaded" ? "info" : "warning");
+			} catch (error) {
+				ctx.ui.notify(`Failed to refresh Cursor config: ${error instanceof Error ? error.message : String(error)}`, "error");
+			}
+		},
+	});
+
 	pi.registerCommand("cursor-mode", {
 		description: "Set Cursor SDK conversation mode: agent or plan",
 		handler: async (args, ctx) => {
@@ -452,13 +488,18 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 		},
 	});
 
+	pi.on("session_tree", (_event, ctx) => {
+		restoreSessionCursorPreferences(ctx);
+		updateCursorStatus(ctx);
+	});
+
 	registerCursorModelLifecycle(pi, {
 		sessionStart: (_event, ctx) => {
 			globalFastPreferences = loadGlobalFastPreferences();
 			cliForceFast = pi.getFlag("cursor-fast") === true;
 			cliForceNoFast = pi.getFlag("cursor-no-fast") === true;
-			restoreSessionFastPreferences(ctx);
-			restoreSessionCursorMode(ctx);
+			restoreCursorCliState(pi);
+			restoreSessionCursorPreferences(ctx);
 			restoreCliCursorMode(pi.getFlag("cursor-mode"));
 		},
 		sync: (ctx) => {
@@ -471,12 +512,14 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 function resetCursorModeStateForTests(): void {
 	sessionCursorAgentMode = undefined;
 	cliCursorModeState = { kind: "unset" };
+	resetCursorRuntimeStateForTests();
 	invalidCursorModeNotifiedSessionScopeKeys.clear();
 }
 
 export const __testUtils = {
 	FAST_ENTRY_TYPE,
 	MODE_ENTRY_TYPE,
+	RUNTIME_ENTRY_TYPE: CURSOR_RUNTIME_ENTRY_TYPE,
 	DEFAULT_CURSOR_AGENT_MODE,
 	getConfigPath,
 	loadGlobalFastPreferences,

package/src/cursor-usage-accounting.ts

@@ -36,7 +36,7 @@ export function getCursorPromptOptions(model: Model<Api>): CursorUsagePromptOpti
 
 function getNonNegativeTokenCount(record: Record<string, unknown> | undefined, key: string): number | undefined {
 	const value = getNumber(record, key);
-	return value === undefined ? undefined : Math.max(0, Math.floor(value));
+	return value === undefined || value < 0 ? undefined : Math.floor(value);
 }
 
 export function readCursorSdkTurnUsage(value: unknown): CursorSdkTurnUsage | undefined {
@@ -84,12 +84,21 @@ export function estimateCursorContextTotalTokens(partial: AssistantMessage, mode
 	return estimateCursorContextTokens(withAssistantMessage(context, partial), getCursorPromptOptions(model));
 }
 
+export function isCursorSdkUsageSafeForPiMessage(turnUsage: CursorSdkTurnUsage, model: Model<Api>): boolean {
+	const counts = [turnUsage.inputTokens, turnUsage.outputTokens, turnUsage.cacheReadTokens, turnUsage.cacheWriteTokens];
+	return (
+		counts.every((count) => Number.isFinite(count) && count >= 0) &&
+		turnUsage.outputTokens <= model.maxTokens &&
+		turnUsage.inputTokens + turnUsage.outputTokens + turnUsage.cacheReadTokens + turnUsage.cacheWriteTokens <= model.contextWindow
+	);
+}
+
 export function applyCursorSdkUsage(partial: AssistantMessage, turnUsage: CursorSdkTurnUsage): void {
 	partial.usage.input = turnUsage.inputTokens;
 	partial.usage.output = turnUsage.outputTokens;
 	partial.usage.cacheRead = turnUsage.cacheReadTokens;
 	partial.usage.cacheWrite = turnUsage.cacheWriteTokens;
-	partial.usage.totalTokens = turnUsage.inputTokens + turnUsage.outputTokens;
+	partial.usage.totalTokens = turnUsage.inputTokens + turnUsage.outputTokens + turnUsage.cacheReadTokens + turnUsage.cacheWriteTokens;
 }
 
 export function applyCursorApproximateUsage(partial: AssistantMessage, model: Model<Api>, context: Context, sessionInputTokens: number): void {
@@ -111,8 +120,9 @@ export function applyCursorUsage(
 	sessionInputTokens: number,
 	sdkUsage?: { turn?: CursorSdkTurnUsage },
 ): void {
-	if (sdkUsage?.turn) {
-		applyCursorSdkUsage(partial, sdkUsage.turn);
+	const usage = sdkUsage?.turn;
+	if (usage && isCursorSdkUsageSafeForPiMessage(usage, model)) {
+		applyCursorSdkUsage(partial, usage);
 		return;
 	}
 	applyCursorApproximateUsage(partial, model, context, sessionInputTokens);

package/src/index.ts

@@ -7,16 +7,19 @@ import { registerCursorQuestionTool } from "./cursor-question-tool.js";
 import { registerCursorSkillTool } from "./cursor-skill-tool.js";
 import { registerCursorSessionScope } from "./cursor-session-scope.js";
 import { registerCursorSessionAgentLifecycle } from "./cursor-session-agent-lifecycle.js";
+import { registerCursorSessionAgentResume } from "./cursor-session-agent-resume.js";
 import { streamCursorLazy } from "./cursor-provider-lazy.js";
-import { CURSOR_API_KEY_CONFIG_VALUE } from "./cursor-api-key.js";
+import { CURSOR_API_KEY_CONFIG_VALUE, resolveCursorApiKey } from "./cursor-api-key.js";
 import { registerCursorFallbackIssueWarning } from "./cursor-fallback-warning.js";
 import { registerCursorAgentsContextDedup } from "./cursor-agents-context-registration.js";
 import { registerCursorOverflowNormalization } from "./cursor-provider-overflow.js";
+import { registerCursorSdkSessionProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 
 type CursorExtensionApi =
 	& Pick<ExtensionAPI, "registerProvider" | "registerCommand" | "on">
 	& Parameters<typeof registerCursorSessionScope>[0]
 	& Parameters<typeof registerCursorSessionAgentLifecycle>[0]
+	& Parameters<typeof registerCursorSessionAgentResume>[0]
 	& Parameters<typeof registerCursorRuntimeControls>[0]
 	& Parameters<typeof registerCursorNativeToolDisplay>[0]
 	& Parameters<typeof registerCursorQuestionTool>[0]
@@ -24,7 +27,8 @@ type CursorExtensionApi =
 	& Parameters<typeof registerCursorPiToolBridge>[0]
 	& Parameters<typeof registerCursorFallbackIssueWarning>[0]
 	& Parameters<typeof registerCursorAgentsContextDedup>[0]
-	& Parameters<typeof registerCursorOverflowNormalization>[0];
+	& Parameters<typeof registerCursorOverflowNormalization>[0]
+	& Parameters<typeof registerCursorSdkSessionProcessErrorGuard>[0];
 
 function createCursorProviderConfig(models: ProviderModelConfig[]): ProviderConfig {
 	return {
@@ -45,6 +49,7 @@ export default async function (pi: CursorExtensionApi) {
 	// Session cwd must register before other session_start listeners that depend on it.
 	registerCursorSessionScope(pi);
 	registerCursorSessionAgentLifecycle(pi);
+	registerCursorSessionAgentResume(pi);
 	pi.on("session_before_compact", async () => {
 		const { prepareCursorSessionForCompaction } = await import("./cursor-session-compaction-prep.js");
 		await prepareCursorSessionForCompaction();
@@ -71,7 +76,9 @@ export default async function (pi: CursorExtensionApi) {
 		description: "Refresh the live Cursor model catalog without restarting pi",
 		handler: async (_args, ctx) => {
 			let refreshFallbackIssue: CursorModelFallbackIssue | undefined;
+			const apiKey = resolveCursorApiKey(await ctx.modelRegistry.getApiKeyForProvider("cursor"));
 			const refreshedModels = await discoverModels({
+				apiKey,
 				forceRefresh: true,
 				onFallback: (issue) => {
 					refreshFallbackIssue = issue;
@@ -88,4 +95,6 @@ export default async function (pi: CursorExtensionApi) {
 	});
 
 	registerCursorProvider(pi, models);
+	// Register last so session_shutdown cleanup remains protected until other Cursor handlers finish.
+	registerCursorSdkSessionProcessErrorGuard(pi);
 }