pi-cursor-sdk 0.1.60 → 0.1.61

package/src/cursor-session-agent-resume.ts

@@ -4,10 +4,12 @@ import type { ExtensionAPI, SessionEntry } from "@earendil-works/pi-coding-agent
 import type { SessionCursorAgentSendState } from "./cursor-session-agent.js";
 import { asRecord } from "./cursor-record-utils.js";
 import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import type { CursorSessionStoreIdentity } from "./cursor-session-store.js";
 
 export const CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE = "cursor-sdk-agent-resume";
 
-const RESUME_ENTRY_VERSION = 1;
+const LEGACY_RESUME_ENTRY_VERSION = 1;
+const RESUME_ENTRY_VERSION = 2;
 const MAX_LOCAL_AGENT_ID_LENGTH = 256;
 const EMPTY_BRANCH_HASH = hashParts(["cursor-sdk-agent-resume-branch", "v1"]);
 
@@ -24,8 +26,13 @@ export interface CursorSessionAgentResumeScope {
 	repoRoot?: string;
 }
 
+export interface CursorSessionAgentCleanupCandidate {
+	agentId: string;
+	storeIdentity?: CursorSessionStoreIdentity;
+}
+
 export interface CursorSessionAgentResumeEntryData {
-	version: 1;
+	version: 1 | 2;
 	runtime: "local";
 	agentId: string;
 	scopeKey: string;
@@ -38,7 +45,9 @@ export interface CursorSessionAgentResumeEntryData {
 	compactionGeneration: number;
 	sendState: SessionCursorAgentSendState;
 	createdAt: string;
+	storeIdentity?: CursorSessionStoreIdentity;
 	cleanupCandidateAgentIds?: string[];
+	cleanupCandidates?: CursorSessionAgentCleanupCandidate[];
 }
 
 interface PendingCursorSessionAgentResumeHandle {
@@ -46,6 +55,7 @@ interface PendingCursorSessionAgentResumeHandle {
 	agentId: string;
 	poolKey: string;
 	sendState: SessionCursorAgentSendState;
+	storeIdentity: CursorSessionStoreIdentity;
 }
 
 interface CursorSessionResumeState {
@@ -109,10 +119,31 @@ function isSendState(value: unknown): value is SessionCursorAgentSendState {
 		typeof record.incrementalSendCount === "number";
 }
 
+function parseStoreIdentity(value: unknown): CursorSessionStoreIdentity | undefined {
+	const record = asRecord(value);
+	if (record?.version !== 1 || typeof record.stateRoot !== "string" || !record.stateRoot) return undefined;
+	return { version: 1, stateRoot: record.stateRoot };
+}
+
+function parseCleanupCandidates(value: unknown): CursorSessionAgentCleanupCandidate[] | undefined {
+	if (!Array.isArray(value)) return undefined;
+	const candidates = value.flatMap((item): CursorSessionAgentCleanupCandidate[] => {
+		const record = asRecord(item);
+		if (!isCursorLocalAgentId(record?.agentId)) return [];
+		const storeIdentity = record.storeIdentity === undefined ? undefined : parseStoreIdentity(record.storeIdentity);
+		if (record.storeIdentity !== undefined && !storeIdentity) return [];
+		return [{ agentId: record.agentId, ...(storeIdentity ? { storeIdentity } : {}) }];
+	});
+	return candidates.length ? candidates : undefined;
+}
+
 export function parseCursorSessionAgentResumeEntryData(value: unknown): CursorSessionAgentResumeEntryData | undefined {
 	const record = asRecord(value);
 	if (!record) return undefined;
-	if (record.version !== RESUME_ENTRY_VERSION || record.runtime !== "local") return undefined;
+	if (
+		(record.version !== LEGACY_RESUME_ENTRY_VERSION && record.version !== RESUME_ENTRY_VERSION) ||
+		record.runtime !== "local"
+	) return undefined;
 	if (
 		!isCursorLocalAgentId(record.agentId) ||
 		typeof record.scopeKey !== "string" ||
@@ -126,11 +157,14 @@ export function parseCursorSessionAgentResumeEntryData(value: unknown): CursorSe
 	if (record.sessionFile !== undefined && typeof record.sessionFile !== "string") return undefined;
 	if (record.sessionId !== undefined && typeof record.sessionId !== "string") return undefined;
 	if (record.repoRoot !== undefined && typeof record.repoRoot !== "string") return undefined;
+	const storeIdentity = parseStoreIdentity(record.storeIdentity);
+	if (record.version === RESUME_ENTRY_VERSION && !storeIdentity) return undefined;
 	const cleanupCandidateAgentIds = Array.isArray(record.cleanupCandidateAgentIds)
 		? record.cleanupCandidateAgentIds.filter(isCursorLocalAgentId)
 		: undefined;
+	const cleanupCandidates = parseCleanupCandidates(record.cleanupCandidates);
 	return {
-		version: RESUME_ENTRY_VERSION,
+		version: record.version,
 		runtime: "local",
 		agentId: record.agentId,
 		scopeKey: record.scopeKey,
@@ -147,7 +181,9 @@ export function parseCursorSessionAgentResumeEntryData(value: unknown): CursorSe
 			incrementalSendCount: record.sendState.incrementalSendCount,
 		},
 		createdAt: record.createdAt,
+		...(storeIdentity ? { storeIdentity } : {}),
 		...(cleanupCandidateAgentIds?.length ? { cleanupCandidateAgentIds: [...new Set(cleanupCandidateAgentIds)] } : {}),
+		...(cleanupCandidates ? { cleanupCandidates } : {}),
 	};
 }
 
@@ -330,6 +366,7 @@ export function persistCursorSessionAgentResumeHandle(input: PendingCursorSessio
 		agentId: input.agentId,
 		poolKey: input.poolKey,
 		sendState: { ...input.sendState },
+		storeIdentity: { ...input.storeIdentity },
 	};
 }
 
@@ -338,8 +375,13 @@ function flushPendingCursorSessionAgentResumeHandle(branch: readonly SessionEntr
 	const pending = state.pendingHandle;
 	state.pendingHandle = undefined;
 	if (!pending || !state.appendEntry) return;
-	const previousAgentId = state.activeHandle?.agentId ?? state.lastBranchHandle?.agentId;
-	const cleanupCandidateAgentIds = previousAgentId && previousAgentId !== pending.agentId ? [previousAgentId] : undefined;
+	const previousHandle = state.activeHandle ?? state.lastBranchHandle;
+	const cleanupCandidates = state.sessionFile && previousHandle && previousHandle.agentId !== pending.agentId
+		? [{
+				agentId: previousHandle.agentId,
+				...(previousHandle.storeIdentity ? { storeIdentity: { ...previousHandle.storeIdentity } } : {}),
+			}]
+		: undefined;
 	const data: CursorSessionAgentResumeEntryData = {
 		version: RESUME_ENTRY_VERSION,
 		runtime: pending.runtime,
@@ -354,7 +396,8 @@ function flushPendingCursorSessionAgentResumeHandle(branch: readonly SessionEntr
 		compactionGeneration: state.compactionGeneration,
 		sendState: { ...pending.sendState },
 		createdAt: new Date().toISOString(),
-		...(cleanupCandidateAgentIds ? { cleanupCandidateAgentIds } : {}),
+		storeIdentity: { ...pending.storeIdentity },
+		...(cleanupCandidates ? { cleanupCandidates } : {}),
 	};
 	try {
 		state.appendEntry<CursorSessionAgentResumeEntryData>(CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE, data);

package/src/cursor-session-agent.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import type { AgentModeOption, LocalAgentOptions, ModelSelection, SDKAgent, SettingSource } from "@cursor/sdk";
+import type { AgentModeOption, LocalAgentOptions, LocalAgentStore, ModelSelection, SDKAgent, SettingSource } from "@cursor/sdk";
 import type { Context } from "@earendil-works/pi-ai/compat";
 import {
 	getRegisteredCursorPiToolBridge,
@@ -7,13 +7,20 @@ import {
 	type CursorPiToolBridgeRun,
 } from "./cursor-pi-tool-bridge.js";
 import { computeCursorContextFingerprint } from "./context.js";
-import { getCursorSessionScopeGeneration, getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionFile, getCursorSessionScopeGeneration, getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import {
 	getMatchingCursorSessionAgentResumeHandle,
 	persistCursorSessionAgentResumeHandle,
 } from "./cursor-session-agent-resume.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
 import { loadCursorSdk, type CursorSdkModule } from "./cursor-sdk-runtime.js";
+import {
+	cursorSessionStoreIdentitiesEqual,
+	openCursorSessionStore,
+	openCursorSessionStoreForScope,
+	type CursorSessionStoreIdentity,
+	type OpenCursorSessionStore,
+} from "./cursor-session-store.js";
 
 export interface SessionCursorAgentSendState {
 	bootstrapped: boolean;
@@ -27,6 +34,8 @@ export interface SessionCursorAgentLease {
 	instanceId: number;
 	agent: SDKAgent;
 	bridgeRun?: CursorPiToolBridgeRun;
+	store: LocalAgentStore;
+	storeIdentity: CursorSessionStoreIdentity;
 	sendState: SessionCursorAgentSendState;
 	created: boolean;
 	resumed?: boolean;
@@ -52,6 +61,7 @@ interface SessionCursorAgentReadyEntry extends SessionCursorAgentPoolEntryBase {
 	status: "ready";
 	agent: SDKAgent;
 	bridgeRun?: CursorPiToolBridgeRun;
+	sessionStore: OpenCursorSessionStore;
 	resumeEnabled: boolean;
 	resumed: boolean;
 	resumeNotice?: string;
@@ -61,6 +71,7 @@ interface SessionCursorAgentBusyEntry extends SessionCursorAgentPoolEntryBase {
 	status: "busy";
 	agent: SDKAgent;
 	bridgeRun?: CursorPiToolBridgeRun;
+	sessionStore: OpenCursorSessionStore;
 	resumeEnabled: boolean;
 	resumed: boolean;
 	resumeNotice?: string;
@@ -116,6 +127,7 @@ interface SessionCursorAgentCreateParams {
 	modelSelection: ModelSelection;
 	settingSources?: SettingSource[];
 	localSafety?: CursorLocalSafetyOptions;
+	useHttp1ForAgent?: boolean;
 	onBridgeToolRequest?: (request: CursorPiBridgeToolRequest) => void;
 	debugRecorder?: CursorSdkEventDebugRecorder;
 	localResume?: boolean;
@@ -131,6 +143,7 @@ let deadTransportAgentDisposeTimeoutMs = 3000;
 const terminalDisposedScopeGenerations = new Map<string, number>();
 const scopeCreationGenerations = new Map<string, number>();
 const EMPTY_POOL_STATE: SessionCursorAgentPoolState = { status: "empty" };
+const LOCAL_RESUME_FALLBACK_NOTICE = "Could not resume prior Cursor agent; continuing from current pi transcript in a new Cursor agent.";
 let nextSessionAgentInstanceId = 1;
 
 export interface CursorLocalSafetyOptions {
@@ -142,9 +155,11 @@ export function buildCursorLocalAgentOptions(options: {
 	cwd: string;
 	settingSources?: SettingSource[];
 	localSafety?: CursorLocalSafetyOptions;
+	store?: LocalAgentStore;
 }): LocalAgentOptions {
 	return {
 		cwd: options.cwd,
+		...(options.store ? { store: options.store } : {}),
 		...(options.settingSources ? { settingSources: options.settingSources } : {}),
 		...(options.localSafety?.autoReview === true ? { autoReview: true } : {}),
 		...(options.localSafety?.sandboxEnabled === true ? { sandboxOptions: { enabled: true } } : {}),
@@ -203,6 +218,11 @@ function buildSessionAgentPoolKey(scopeKey: string, params: SessionCursorAgentCr
 		buildModelPoolKey(params.modelSelection),
 		buildSettingSourcesPoolKey(params.settingSources),
 		buildLocalSafetyPoolKey(params.localSafety),
+		params.useHttp1ForAgent === undefined
+			? "http1:default"
+			: params.useHttp1ForAgent
+				? "http1:on"
+				: "http1:off",
 		buildApiKeyPoolKeyFingerprint(params.apiKey),
 		buildBridgePoolKeySuffix(),
 	].join("\0");
@@ -229,6 +249,7 @@ async function disposePoolEntry(entry: SessionCursorAgentPoolEntry, options?: {
 	} catch {
 		// disposal failure should not block session replacement
 	}
+	await entry.sessionStore.dispose().catch(() => undefined);
 }
 
 async function disposePoolEntryForScope(scopeKey: string, options?: { terminal?: boolean }): Promise<void> {
@@ -287,6 +308,7 @@ function commitSessionAgentSendForLease(
 			agentId: entry.agent.agentId,
 			poolKey: entry.poolKey,
 			sendState: entry.sendState,
+			storeIdentity: entry.sessionStore.identity,
 		});
 	}
 }
@@ -371,6 +393,8 @@ function leaseFromEntry(
 		instanceId: entry.instanceId,
 		agent: entry.agent,
 		bridgeRun: entry.bridgeRun,
+		store: entry.sessionStore.store,
+		storeIdentity: entry.sessionStore.identity,
 		sendState: entry.sendState,
 		created,
 		resumed: entry.resumed,
@@ -413,84 +437,98 @@ async function tryLeaseReadyEntry(
 
 async function createSessionAgentEntry(
 	scopeKey: string,
+	persistentStore: boolean,
 	instanceId: number,
 	sendState: SessionCursorAgentSendState,
 	params: SessionCursorAgentCreateParams,
 ): Promise<SessionCursorAgentReadyEntry> {
-	const registeredBridge = getRegisteredCursorPiToolBridge();
 	let bridgeRun: CursorPiToolBridgeRun | undefined;
-	if (registeredBridge) {
-		bridgeRun = await registeredBridge.createRun({
-			onToolRequest: params.onBridgeToolRequest,
-			debugRecorder: params.debugRecorder,
-		});
-		if (!bridgeRun.enabled || !bridgeRun.mcpServers) {
-			await bridgeRun.dispose();
-			bridgeRun = undefined;
+	let sessionStore: OpenCursorSessionStore | undefined;
+	try {
+		const registeredBridge = getRegisteredCursorPiToolBridge();
+		if (registeredBridge) {
+			bridgeRun = await registeredBridge.createRun({
+				onToolRequest: params.onBridgeToolRequest,
+				debugRecorder: params.debugRecorder,
+			});
+			if (!bridgeRun.enabled || !bridgeRun.mcpServers) {
+				await bridgeRun.dispose();
+				bridgeRun = undefined;
+			}
 		}
-	}
 
-	const resolvedPoolKey = buildSessionAgentPoolKey(scopeKey, params);
-	const resumeEligible = params.localResume === true && !params.forceCreate;
-	let createAgent = params.createAgent;
-	let resumeAgent = params.resumeAgent;
-	if (!createAgent || (resumeEligible && !resumeAgent)) {
-		const sdk = await loadCursorSdk();
-		createAgent ??= sdk.Agent.create;
-		resumeAgent ??= sdk.Agent.resume;
-	}
-	const agentOptions = {
-		apiKey: params.apiKey,
-		model: params.modelSelection,
-		mode: params.agentMode,
-		local: buildCursorLocalAgentOptions({
-			cwd: params.cwd,
-			settingSources: params.settingSources,
-			localSafety: params.localSafety,
-		}),
-		...(bridgeRun?.mcpServers ? { mcpServers: bridgeRun.mcpServers } : {}),
-	};
-	let agent: SDKAgent | undefined;
-	let effectiveSendState = sendState;
-	let resumed = false;
-	let resumeNotice: string | undefined;
-	const resumeHandle = resumeEligible ? getMatchingCursorSessionAgentResumeHandle(resolvedPoolKey) : undefined;
-	if (resumeHandle && resumeAgent) {
-		try {
-			agent = await resumeAgent(resumeHandle.agentId, agentOptions);
-			effectiveSendState = { ...resumeHandle.sendState };
-			resumed = true;
-		} catch {
-			resumeNotice = "Could not resume prior Cursor agent; continuing from current pi transcript in a new Cursor agent.";
+		const resolvedPoolKey = buildSessionAgentPoolKey(scopeKey, params);
+		const resumeEligible = params.localResume === true && !params.forceCreate;
+		let createAgent = params.createAgent;
+		let resumeAgent = params.resumeAgent;
+		if (!createAgent || (resumeEligible && !resumeAgent)) {
+			const sdk = await loadCursorSdk();
+			createAgent ??= sdk.Agent.create;
+			resumeAgent ??= sdk.Agent.resume;
 		}
-	}
-	try {
-		agent ??= await createAgent(agentOptions);
-	} catch (error) {
-		if (bridgeRun) {
-			bridgeRun.cancel("Cursor session agent create failed");
+		const resumeHandle = resumeEligible ? getMatchingCursorSessionAgentResumeHandle(resolvedPoolKey) : undefined;
+		const storeSelection = await openCursorSessionStoreForScope({
+			cwd: params.cwd,
+			scopeKey,
+			persistent: persistentStore,
+			hasResumeHandle: resumeHandle !== undefined,
+			resumeIdentity: resumeHandle?.storeIdentity,
+		});
+		sessionStore = storeSelection.sessionStore;
+		const { identities } = storeSelection;
+		const resumeAttemptAllowed = storeSelection.resumeAttemptAllowed;
+		let resumeNotice = storeSelection.resumeFallback ? LOCAL_RESUME_FALLBACK_NOTICE : undefined;
+		const buildAgentOptions = () => ({
+			apiKey: params.apiKey,
+			model: params.modelSelection,
+			mode: params.agentMode,
+			local: buildCursorLocalAgentOptions({
+				cwd: params.cwd,
+				settingSources: params.settingSources,
+				localSafety: params.localSafety,
+				store: sessionStore!.store,
+			}),
+			...(bridgeRun?.mcpServers ? { mcpServers: bridgeRun.mcpServers } : {}),
+		});
+		let agent: SDKAgent | undefined;
+		let effectiveSendState = sendState;
+		let resumed = false;
+		if (resumeHandle && resumeAttemptAllowed && resumeAgent) {
 			try {
-				await bridgeRun.dispose();
+				agent = await resumeAgent(resumeHandle.agentId, buildAgentOptions());
+				effectiveSendState = { ...resumeHandle.sendState };
+				resumed = true;
 			} catch {
-				// bridge disposal failure should not mask agent create failure
+				if (persistentStore) resumeNotice = LOCAL_RESUME_FALLBACK_NOTICE;
+				if (!cursorSessionStoreIdentitiesEqual(sessionStore.identity, identities.sessionStore)) {
+					await sessionStore.dispose().catch(() => undefined);
+					sessionStore = await openCursorSessionStore(params.cwd, identities.sessionStore);
+				}
 			}
 		}
+		agent ??= await createAgent(buildAgentOptions());
+		if (!agent) throw new Error("Cursor SDK agent creation returned no agent");
+		if (!sessionStore) throw new Error("Cursor SDK session store was not opened");
+
+		return {
+			status: "ready",
+			poolKey: resolvedPoolKey,
+			instanceId,
+			scopeKey,
+			agent,
+			bridgeRun,
+			sessionStore,
+			sendState: effectiveSendState,
+			resumeEnabled: params.localResume === true,
+			resumed,
+			...(resumeNotice ? { resumeNotice } : {}),
+		};
+	} catch (error) {
+		bridgeRun?.cancel("Cursor session agent create failed");
+		await bridgeRun?.dispose().catch(() => undefined);
+		await sessionStore?.dispose().catch(() => undefined);
 		throw error;
 	}
-	if (!agent) throw new Error("Cursor SDK agent creation returned no agent");
-
-	return {
-		status: "ready",
-		poolKey: resolvedPoolKey,
-		instanceId,
-		scopeKey,
-		agent,
-		bridgeRun,
-		sendState: effectiveSendState,
-		resumeEnabled: params.localResume === true,
-		resumed,
-		...(resumeNotice ? { resumeNotice } : {}),
-	};
 }
 
 export {
@@ -510,6 +548,7 @@ export function invalidateSessionAgent(
 
 export async function acquireSessionCursorAgent(params: SessionCursorAgentCreateParams): Promise<SessionCursorAgentLease> {
 	const scopeKey = getCursorSessionScopeKey();
+	const persistentStore = getCursorSessionFile() !== undefined;
 
 	while (true) {
 		assertScopeAcceptsAcquire(scopeKey);
@@ -559,7 +598,7 @@ export async function acquireSessionCursorAgent(params: SessionCursorAgentCreate
 		const instanceId = allocateSessionAgentInstanceId();
 		const sendState = createInitialSendState();
 		let placeholder: SessionCursorAgentCreatingEntry;
-		const creating = createSessionAgentEntry(scopeKey, instanceId, sendState, params).then(async (createdEntry) => {
+		const creating = createSessionAgentEntry(scopeKey, persistentStore, instanceId, sendState, params).then(async (createdEntry) => {
 			const stillCurrent =
 				sessionAgentsByScope.get(scopeKey) === placeholder &&
 				getScopeCreationGeneration(scopeKey) === placeholder.creationGeneration;

package/src/cursor-session-scope.ts

@@ -1,7 +1,10 @@
-import type { ExtensionHandler, SessionInfoChangedEvent, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+import { resolve } from "node:path";
+import { parseArgs } from "@earendil-works/pi-coding-agent";
+import type { ExtensionHandler, ProjectTrustHandler, SessionInfoChangedEvent, SessionStartEvent } from "@earendil-works/pi-coding-agent";
 import { truncateCursorDisplayLine } from "./cursor-display-text.js";
 
 interface CursorSessionScopeExtensionApi {
+	on(event: "project_trust", handler: ProjectTrustHandler): void;
 	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
 	on(event: "session_info_changed", handler: ExtensionHandler<SessionInfoChangedEvent>): void;
 }
@@ -22,6 +25,7 @@ const state = {
 };
 
 const scopeGenerations = new Map<string, number>([[ANONYMOUS_SESSION_SCOPE_KEY, state.sessionGeneration]]);
+const projectTrustResolutionCwds = new Set<string>();
 let nextSessionGeneration = 1;
 let scopeChangeHandler: CursorSessionScopeChangeHandler | undefined;
 
@@ -85,6 +89,14 @@ function setCursorSessionScope(
 	scopeGenerations.set(getCursorSessionScopeKey(), state.sessionGeneration);
 }
 
+function recordProjectTrustResolution(cwd: string): void {
+	projectTrustResolutionCwds.add(resolve(cwd));
+}
+
+function isCliProjectTrustApproved(args = process.argv.slice(2)): boolean {
+	return parseArgs(args).projectTrustOverride === true;
+}
+
 function resetCursorSessionScope(): void {
 	state.sessionCwd = process.cwd();
 	state.sessionFile = undefined;
@@ -95,6 +107,7 @@ function resetCursorSessionScope(): void {
 	nextSessionGeneration = 1;
 	scopeGenerations.clear();
 	scopeGenerations.set(ANONYMOUS_SESSION_SCOPE_KEY, state.sessionGeneration);
+	projectTrustResolutionCwds.clear();
 }
 
 export function onCursorSessionScopeKeyChange(handler: CursorSessionScopeChangeHandler): void {
@@ -102,13 +115,18 @@ export function onCursorSessionScopeKeyChange(handler: CursorSessionScopeChangeH
 }
 
 export function registerCursorSessionScope(pi: CursorSessionScopeExtensionApi): void {
+	pi.on("project_trust", (event) => {
+		recordProjectTrustResolution(event.cwd);
+		return { trusted: "undecided" };
+	});
 	pi.on("session_start", async (_event, ctx) => {
 		const previousScopeKey = getCursorSessionScopeKey();
 		setCursorSessionScope(
 			ctx.cwd,
 			ctx.sessionManager?.getSessionFile?.() ?? undefined,
 			ctx.sessionManager?.getSessionId?.() ?? undefined,
-			ctx.isProjectTrusted?.() === true,
+			ctx.isProjectTrusted?.() === true
+				&& (projectTrustResolutionCwds.has(resolve(ctx.cwd)) || isCliProjectTrustApproved()),
 			ctx.sessionManager?.getSessionName?.() ?? undefined,
 		);
 		if (previousScopeKey !== getCursorSessionScopeKey()) {
@@ -124,5 +142,7 @@ export const __testUtils = {
 	ANONYMOUS_SESSION_SCOPE_KEY,
 	EPHEMERAL_SESSION_SCOPE_PREFIX,
 	set: setCursorSessionScope,
+	recordProjectTrustResolution,
+	isCliProjectTrustApproved,
 	reset: resetCursorSessionScope,
 };

package/src/cursor-session-store.ts

@@ -0,0 +1,155 @@
+import { createHash, randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, toNamespacedPath } from "node:path";
+import type { LocalAgentStore } from "@cursor/sdk";
+import { loadCursorSdk } from "./cursor-sdk-runtime.js";
+
+export interface CursorSessionStoreIdentity {
+	readonly version: 1;
+	readonly stateRoot: string;
+}
+
+export interface OpenCursorSessionStore {
+	identity: CursorSessionStoreIdentity;
+	store: LocalAgentStore;
+	dispose(): Promise<void>;
+}
+
+export interface CursorSessionStoreSelection {
+	sessionStore: OpenCursorSessionStore;
+	identities: {
+		defaultStore: CursorSessionStoreIdentity;
+		sessionStore: CursorSessionStoreIdentity;
+	};
+	resumeAttemptAllowed: boolean;
+	resumeFallback: boolean;
+}
+
+interface CursorSessionStoreSdkOperations {
+	getDefaultStateRoot(cwd: string): string | Promise<string>;
+	openSqliteStore(options: { workspaceRef: string; stateRoot: string }): Promise<LocalAgentStore & { dispose(): Promise<void> }>;
+}
+
+let sdkOperationsForTests: CursorSessionStoreSdkOperations | undefined;
+
+export function hashCursorSessionStoreScope(scopeKey: string): string {
+	return createHash("sha256")
+		.update("pi-cursor-sdk-session-store\0")
+		.update(scopeKey)
+		.digest("hex")
+		.slice(0, 32);
+}
+
+export function buildCursorSessionStateRoot(defaultStateRoot: string, scopeKey: string, persistent: boolean): string {
+	const baseRoot = persistent ? defaultStateRoot : join(tmpdir(), `pi-cursor-sdk-${randomUUID()}`);
+	return join(baseRoot, "pi-sessions", hashCursorSessionStoreScope(scopeKey));
+}
+
+async function getSdkOperations(): Promise<CursorSessionStoreSdkOperations> {
+	if (sdkOperationsForTests) return sdkOperationsForTests;
+	const [{ getDefaultSdkStateRoot }, { SqliteLocalAgentStore }] = await Promise.all([
+		loadCursorSdk(),
+		import("@cursor/sdk/sqlite"),
+	]);
+	return {
+		getDefaultStateRoot: getDefaultSdkStateRoot,
+		openSqliteStore: (options) => SqliteLocalAgentStore.open(options),
+	};
+}
+
+export async function getCursorSessionStoreIdentities(
+	cwd: string,
+	scopeKey: string,
+	persistent: boolean,
+): Promise<{ defaultStore: CursorSessionStoreIdentity; sessionStore: CursorSessionStoreIdentity }> {
+	const defaultStateRoot = await (await getSdkOperations()).getDefaultStateRoot(cwd);
+	return {
+		defaultStore: { version: 1, stateRoot: defaultStateRoot },
+		sessionStore: {
+			version: 1,
+			stateRoot: buildCursorSessionStateRoot(defaultStateRoot, scopeKey, persistent),
+		},
+	};
+}
+
+export function cursorSessionStoreIdentitiesEqual(
+	left: CursorSessionStoreIdentity,
+	right: CursorSessionStoreIdentity,
+): boolean {
+	return left.version === right.version && left.stateRoot === right.stateRoot;
+}
+
+async function openOwnedCursorSessionStore(
+	cwd: string,
+	identity: CursorSessionStoreIdentity,
+	removalRoot?: string,
+): Promise<OpenCursorSessionStore> {
+	const openedIdentity = Object.freeze({ ...identity });
+	let store: LocalAgentStore & { dispose(): Promise<void> };
+	try {
+		store = await (await getSdkOperations()).openSqliteStore({
+			workspaceRef: cwd,
+			stateRoot: toNamespacedPath(openedIdentity.stateRoot),
+		});
+	} catch (error) {
+		if (removalRoot) await rm(removalRoot, { recursive: true, force: true }).catch(() => undefined);
+		throw error;
+	}
+	return {
+		identity: openedIdentity,
+		store,
+		dispose: async () => {
+			try {
+				await store.dispose();
+			} finally {
+				if (removalRoot) await rm(removalRoot, { recursive: true, force: true });
+			}
+		},
+	};
+}
+
+export function openCursorSessionStore(
+	cwd: string,
+	identity: CursorSessionStoreIdentity,
+): Promise<OpenCursorSessionStore> {
+	return openOwnedCursorSessionStore(cwd, identity);
+}
+
+export async function openCursorSessionStoreForScope(options: {
+	cwd: string;
+	scopeKey: string;
+	persistent: boolean;
+	hasResumeHandle: boolean;
+	resumeIdentity?: CursorSessionStoreIdentity;
+}): Promise<CursorSessionStoreSelection> {
+	const identities = await getCursorSessionStoreIdentities(options.cwd, options.scopeKey, options.persistent);
+	const requestedResumeIdentity = options.hasResumeHandle
+		? options.resumeIdentity ?? (options.persistent ? identities.defaultStore : undefined)
+		: undefined;
+	const resumableIdentities = options.persistent
+		? [identities.defaultStore, identities.sessionStore]
+		: [identities.sessionStore];
+	const resumeIdentity = requestedResumeIdentity && resumableIdentities
+		.find((identity) => cursorSessionStoreIdentitiesEqual(identity, requestedResumeIdentity));
+	let resumeAttemptAllowed = options.hasResumeHandle && resumeIdentity !== undefined;
+	let resumeFallback = options.persistent && options.hasResumeHandle && !resumeIdentity;
+	const selectedIdentity = resumeIdentity ?? identities.sessionStore;
+	const removalRoot = options.persistent ? undefined : dirname(dirname(identities.sessionStore.stateRoot));
+	let sessionStore: OpenCursorSessionStore;
+	try {
+		sessionStore = await openOwnedCursorSessionStore(options.cwd, selectedIdentity, removalRoot);
+	} catch (error) {
+		if (!resumeIdentity || cursorSessionStoreIdentitiesEqual(resumeIdentity, identities.sessionStore)) throw error;
+		resumeAttemptAllowed = false;
+		resumeFallback = true;
+		sessionStore = await openOwnedCursorSessionStore(options.cwd, identities.sessionStore);
+	}
+	return { sessionStore, identities, resumeAttemptAllowed, resumeFallback };
+}
+
+export const __testUtils = {
+	setSdkOperations(operations: CursorSessionStoreSdkOperations | undefined): void {
+		sdkOperationsForTests = operations;
+	},
+};