pi-cursor-sdk 0.4.0 → 0.5.0

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

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, SessionEntry } from "@earendil-works/pi-coding-agent";
 import { isCursorLocalAgentId } from "./cursor-session-agent-resume.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
 import { asRecord } from "./cursor-record-utils.js";
 
 export const CURSOR_SESSION_AGENT_LINEAGE_ENTRY_TYPE = "cursor-sdk-agent-lineage";
@@ -33,10 +33,12 @@ interface CursorSessionAgentLineageState {
 	recordedAgentIds: Set<string>;
 }
 
-const state: CursorSessionAgentLineageState = {
+let state: CursorSessionAgentLineageState = {
 	recordedAgentIds: new Set(),
 };
 
+const statesByScope = new Map<string, CursorSessionAgentLineageState>();
+
 export function parseCursorSessionAgentLineageEntryData(value: unknown): CursorSessionAgentLineageEntryData | undefined {
 	const record = asRecord(value);
 	if (
@@ -77,10 +79,14 @@ function readRecordedAgentIds(entries: readonly SessionEntry[], sessionId: strin
 }
 
 /** Best-effort forensic lineage at the local Agent.send() boundary. Independent of resume. */
-export function recordCursorSessionAgentLineage(agentId: string): void {
-	const { appendEntry, sessionId, sessionFile, scopeKey, cwd } = state;
+export function recordCursorSessionAgentLineage(agentId: string, turnScopeKey?: string): void {
+	const sessionState = turnScopeKey === undefined
+		? state
+		: statesByScope.get(turnScopeKey) ?? (state.scopeKey === turnScopeKey ? state : undefined);
+	if (!sessionState) return;
+	const { appendEntry, sessionId, sessionFile, scopeKey, cwd } = sessionState;
 	if (!appendEntry || !sessionId || !scopeKey || !cwd) return;
-	if (!isCursorLocalAgentId(agentId) || state.recordedAgentIds.has(agentId)) return;
+	if (!isCursorLocalAgentId(agentId) || sessionState.recordedAgentIds.has(agentId)) return;
 	const data: CursorSessionAgentLineageEntryData = {
 		version: LINEAGE_ENTRY_VERSION,
 		runtime: "local",
@@ -93,7 +99,7 @@ export function recordCursorSessionAgentLineage(agentId: string): void {
 	};
 	try {
 		appendEntry<CursorSessionAgentLineageEntryData>(CURSOR_SESSION_AGENT_LINEAGE_ENTRY_TYPE, data);
-		state.recordedAgentIds.add(agentId);
+		sessionState.recordedAgentIds.add(agentId);
 	} catch {
 		// Lineage is forensic metadata; a failed stock pi append must not affect the session.
 	}
@@ -105,15 +111,22 @@ interface CursorSessionAgentLineageExtensionApi {
 }
 
 export function registerCursorSessionAgentLineage(pi: CursorSessionAgentLineageExtensionApi): void {
+	const sessionState: CursorSessionAgentLineageState = { recordedAgentIds: new Set() };
 	pi.on("session_start", (_event, ctx) => {
-		state.appendEntry = pi.appendEntry;
-		state.sessionId = ctx.sessionManager.getSessionId();
-		state.sessionFile = ctx.sessionManager.getSessionFile() ?? undefined;
-		state.scopeKey = getCursorSessionScopeKey();
-		state.cwd = ctx.cwd;
-		state.recordedAgentIds = readRecordedAgentIds(ctx.sessionManager.getEntries(), state.sessionId);
+		state = sessionState;
+		const record = sessionState;
+		if (record.scopeKey && statesByScope.get(record.scopeKey) === record) statesByScope.delete(record.scopeKey);
+		record.appendEntry = pi.appendEntry;
+		record.sessionId = ctx.sessionManager.getSessionId();
+		record.sessionFile = ctx.sessionManager.getSessionFile() ?? undefined;
+		record.scopeKey = getCursorSessionScopeSnapshot(pi).scopeKey;
+		statesByScope.set(record.scopeKey, record);
+		record.cwd = ctx.cwd;
+		record.recordedAgentIds = readRecordedAgentIds(ctx.sessionManager.getEntries(), record.sessionId);
 	});
 	pi.on("session_shutdown", () => {
+		const state = sessionState;
+		if (state.scopeKey && statesByScope.get(state.scopeKey) === state) statesByScope.delete(state.scopeKey);
 		state.appendEntry = undefined;
 		state.sessionId = undefined;
 		state.sessionFile = undefined;
@@ -124,6 +137,7 @@ export function registerCursorSessionAgentLineage(pi: CursorSessionAgentLineageE
 }
 
 function resetStateForTests(): void {
+	statesByScope.clear();
 	state.appendEntry = undefined;
 	state.sessionId = undefined;
 	state.sessionFile = undefined;

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

@@ -3,7 +3,7 @@ import { execFileSync } from "node:child_process";
 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 { getCursorSessionScopeSnapshot, 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";
@@ -73,7 +73,7 @@ interface CursorSessionResumeState {
 	unownedUserEntryIds: Set<string>;
 }
 
-const state: CursorSessionResumeState = {
+let lastBoundState: CursorSessionResumeState = {
 	scopeKey: getCursorSessionScopeKey(),
 	cwd: process.cwd(),
 	branchPathHash: EMPTY_BRANCH_HASH,
@@ -81,17 +81,13 @@ const state: CursorSessionResumeState = {
 	unownedUserEntryIds: new Set(),
 };
 
-// Compaction summarizer sends commit a one-message resume handle. Drop it so the
-// next normal turn_end cannot persist that lineage (#223).
-let resumeHandlePersistSuppressed = false;
+const statesByScope = new Map<string, CursorSessionResumeState>();
 
-export function suppressCursorSessionAgentResumeHandlePersist(): void {
-	resumeHandlePersistSuppressed = true;
-	state.pendingHandle = undefined;
-}
-
-export function allowCursorSessionAgentResumeHandlePersist(): void {
-	resumeHandlePersistSuppressed = false;
+function getResumeState(scopeKey?: string): CursorSessionResumeState {
+	if (scopeKey !== undefined) {
+		return statesByScope.get(scopeKey) ?? lastBoundState;
+	}
+	return lastBoundState;
 }
 
 function hashParts(parts: readonly string[]): string {
@@ -211,7 +207,8 @@ function matchesResumeScope(data: CursorSessionAgentResumeEntryData, scope: Curs
 function matchesCurrentSession(
 	data: CursorSessionAgentResumeEntryData,
 	branchPathHash: string,
-	compactionGeneration = state.compactionGeneration,
+	compactionGeneration: number,
+	state: CursorSessionResumeState,
 ): boolean {
 	return matchesResumeScope(data, state) &&
 		data.compactionGeneration === compactionGeneration &&
@@ -333,19 +330,19 @@ export function readResumableCursorSessionAgentIds(
 	return [...agentIds].sort((a, b) => a.localeCompare(b));
 }
 
-function canRestoreHandleSpanEntry(entry: SessionEntry): boolean {
+function canRestoreHandleSpanEntry(entry: SessionEntry, state: CursorSessionResumeState): boolean {
 	if (entry.type === "message" && entry.message.role === "user") return !state.unownedUserEntryIds.has(entry.id);
 	return canResumeHandleSpanEntry(entry);
 }
 
-function restoreFromBranch(branch: readonly SessionEntry[], allEntries: readonly SessionEntry[] = branch): void {
+function restoreFromBranch(branch: readonly SessionEntry[], allEntries: readonly SessionEntry[], state: CursorSessionResumeState): void {
 	const resumeIndex = indexLatestResumeEntries(allEntries);
 	let fold: ResumeBranchFoldState = { branchPathHash: EMPTY_BRANCH_HASH, compactionGeneration: 0 };
 	let lastBranchHandle: CursorSessionAgentResumeEntryData | undefined;
 	for (const entry of branch) {
 		const next = advanceResumeBranchState(entry, fold, resumeIndex, {
-			matchesEntry: matchesCurrentSession,
-			canSpanEntry: canRestoreHandleSpanEntry,
+			matchesEntry: (data, hash, generation) => matchesCurrentSession(data, hash, generation, state),
+			canSpanEntry: (entry) => canRestoreHandleSpanEntry(entry, state),
 		});
 		if (next.activeHandle && next.activeHandle !== fold.activeHandle) lastBranchHandle = next.activeHandle;
 		fold = next;
@@ -356,7 +353,9 @@ function restoreFromBranch(branch: readonly SessionEntry[], allEntries: readonly
 	state.lastBranchHandle = lastBranchHandle;
 }
 
-export function getMatchingCursorSessionAgentResumeHandle(poolKey: string): CursorSessionAgentResumeEntryData | undefined {
+export function getMatchingCursorSessionAgentResumeHandle(poolKey: string, scopeKey?: string): CursorSessionAgentResumeEntryData | undefined {
+	const state = getResumeState(scopeKey);
+	if (scopeKey !== undefined && state.scopeKey !== scopeKey) return undefined;
 	const handle = state.activeHandle;
 	if (!handle || !isCursorLocalAgentId(handle.agentId)) return undefined;
 	if (handle.poolKey !== poolKey) return undefined;
@@ -372,8 +371,9 @@ export function getMatchingCursorSessionAgentResumeHandle(poolKey: string): Curs
 	};
 }
 
-export function persistCursorSessionAgentResumeHandle(input: PendingCursorSessionAgentResumeHandle): void {
-	if (resumeHandlePersistSuppressed) return;
+export function persistCursorSessionAgentResumeHandle(input: PendingCursorSessionAgentResumeHandle, scopeKey?: string): void {
+	const state = getResumeState(scopeKey);
+	if (scopeKey !== undefined && state.scopeKey !== scopeKey) return;
 	if (!isCursorLocalAgentId(input.agentId)) return;
 	state.pendingHandle = {
 		runtime: input.runtime,
@@ -384,13 +384,8 @@ export function persistCursorSessionAgentResumeHandle(input: PendingCursorSessio
 	};
 }
 
-function flushPendingCursorSessionAgentResumeHandle(branch: readonly SessionEntry[]): void {
-	if (resumeHandlePersistSuppressed) {
-		state.pendingHandle = undefined;
-		restoreFromBranch(branch);
-		return;
-	}
-	restoreFromBranch(branch);
+function flushPendingCursorSessionAgentResumeHandle(branch: readonly SessionEntry[], state: CursorSessionResumeState): void {
+	restoreFromBranch(branch, branch, state);
 	const pending = state.pendingHandle;
 	state.pendingHandle = undefined;
 	if (!pending || !state.appendEntry) return;
@@ -432,14 +427,22 @@ interface CursorSessionAgentResumeExtensionApi {
 }
 
 export function registerCursorSessionAgentResume(pi: CursorSessionAgentResumeExtensionApi): void {
-	state.appendEntry = pi.appendEntry;
+	const sessionState: CursorSessionResumeState = {
+		appendEntry: pi.appendEntry, scopeKey: getCursorSessionScopeSnapshot(pi).scopeKey,
+		cwd: process.cwd(), branchPathHash: EMPTY_BRANCH_HASH,
+		compactionGeneration: 0, unownedUserEntryIds: new Set(),
+	};
+	const state = sessionState;
 	const restoreFromSessionManager = (sessionManager: { getBranch(): SessionEntry[]; getEntries(): SessionEntry[] }): void => {
 		const branch = sessionManager.getBranch();
 		const entries = sessionManager.getEntries();
-		restoreFromBranch(branch, entries.length > 0 ? entries : branch);
+		restoreFromBranch(branch, entries.length > 0 ? entries : branch, state);
 	};
 	pi.on("session_start", (_event, ctx) => {
-		state.scopeKey = getCursorSessionScopeKey();
+		if (statesByScope.get(state.scopeKey) === state) statesByScope.delete(state.scopeKey);
+		state.scopeKey = getCursorSessionScopeSnapshot(pi).scopeKey;
+		statesByScope.set(state.scopeKey, state);
+		lastBoundState = state;
 		state.sessionFile = ctx.sessionManager.getSessionFile?.() ?? undefined;
 		state.sessionId = ctx.sessionManager.getSessionId?.() ?? undefined;
 		state.cwd = ctx.cwd;
@@ -452,7 +455,7 @@ export function registerCursorSessionAgentResume(pi: CursorSessionAgentResumeExt
 		restoreFromSessionManager(ctx.sessionManager);
 	});
 	pi.on("turn_end", (_event, ctx) => {
-		flushPendingCursorSessionAgentResumeHandle(ctx.sessionManager.getBranch());
+		flushPendingCursorSessionAgentResumeHandle(ctx.sessionManager.getBranch(), state);
 	});
 	pi.on("session_tree", (_event, ctx) => {
 		for (const entry of ctx.sessionManager.getBranch()) {
@@ -460,9 +463,14 @@ export function registerCursorSessionAgentResume(pi: CursorSessionAgentResumeExt
 		}
 		restoreFromSessionManager(ctx.sessionManager);
 	});
+	pi.on("session_before_compact", () => {
+		state.pendingHandle = undefined;
+	});
+	pi.on("session_compact_failed", () => {
+		state.pendingHandle = undefined;
+	});
 	pi.on("session_compact", (event, ctx) => {
 		state.pendingHandle = undefined;
-		resumeHandlePersistSuppressed = false;
 		const branch = ctx.sessionManager.getBranch();
 		if (branch.length > 0) {
 			restoreFromSessionManager(ctx.sessionManager);
@@ -473,13 +481,19 @@ export function registerCursorSessionAgentResume(pi: CursorSessionAgentResumeExt
 		state.compactionGeneration += 1;
 		state.branchPathHash = hashBranchStep(state.branchPathHash, event.compactionEntry);
 	});
+	pi.on("session_shutdown", () => {
+		if (statesByScope.get(state.scopeKey) === state) statesByScope.delete(state.scopeKey);
+		state.appendEntry = undefined;
+		state.pendingHandle = undefined;
+	});
 }
 
 function setStateForTests(next: Partial<CursorSessionResumeState>): void {
-	Object.assign(state, next);
+	Object.assign(getResumeState(), next);
 }
 
 function resetStateForTests(): void {
+	const state = lastBoundState;
 	state.appendEntry = undefined;
 	state.scopeKey = getCursorSessionScopeKey();
 	state.sessionFile = undefined;
@@ -492,7 +506,7 @@ function resetStateForTests(): void {
 	state.lastBranchHandle = undefined;
 	state.pendingHandle = undefined;
 	state.unownedUserEntryIds = new Set();
-	resumeHandlePersistSuppressed = false;
+	statesByScope.clear();
 }
 
 export const __testUtils = {
@@ -500,6 +514,5 @@ export const __testUtils = {
 	hashBranchStep,
 	reset: resetStateForTests,
 	set: setStateForTests,
-	state,
-	isResumeHandlePersistSuppressed: () => resumeHandlePersistSuppressed,
+	get state() { return getResumeState(); },
 };

package/src/cursor-session-agent.ts

@@ -3,11 +3,12 @@ import type { AgentModeOption, LocalAgentOptions, LocalAgentStore, ModelSelectio
 import type { Context } from "@earendil-works/pi-ai";
 import {
 	getRegisteredCursorPiToolBridge,
+	type CursorPiToolBridge,
 	type CursorPiBridgeToolRequest,
 	type CursorPiToolBridgeRun,
 } from "./cursor-pi-tool-bridge.js";
 import { computeCursorContextFingerprint } from "./context.js";
-import { getCursorSessionFile, getCursorSessionScopeGeneration, getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionFile, getCursorSessionScopeGeneration, getCursorSessionScopeKey, type CursorTurnScope } from "./cursor-session-scope.js";
 import {
 	getMatchingCursorSessionAgentResumeHandle,
 	persistCursorSessionAgentResumeHandle,
@@ -121,6 +122,8 @@ function rethrowSupersededWhenReplacedByDifferentPoolKey(scopeKey: string, poolK
 }
 
 interface SessionCursorAgentCreateParams {
+	scope?: CursorTurnScope;
+	bridge?: CursorPiToolBridge;
 	apiKey: string;
 	agentMode: AgentModeOption;
 	cwd: string;
@@ -205,8 +208,7 @@ function buildApiKeyPoolKeyFingerprint(apiKey: string): string {
 	return createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
 }
 
-function buildBridgePoolKeySuffix(): string {
-	const registeredBridge = getRegisteredCursorPiToolBridge();
+function buildBridgePoolKeySuffix(registeredBridge: CursorPiToolBridge | undefined): string {
 	if (!registeredBridge) return "bridge:absent";
 	return registeredBridge.getToolSurfaceSignature();
 }
@@ -224,7 +226,7 @@ function buildSessionAgentPoolKey(scopeKey: string, params: SessionCursorAgentCr
 				? "http1:on"
 				: "http1:off",
 		buildApiKeyPoolKeyFingerprint(params.apiKey),
-		buildBridgePoolKeySuffix(),
+		buildBridgePoolKeySuffix("bridge" in params ? params.bridge : getRegisteredCursorPiToolBridge()),
 	].join("\0");
 }
 
@@ -309,7 +311,7 @@ function commitSessionAgentSendForLease(
 			poolKey: entry.poolKey,
 			sendState: entry.sendState,
 			storeIdentity: entry.sessionStore.identity,
-		});
+		}, scopeKey);
 	}
 }
 
@@ -445,7 +447,7 @@ async function createSessionAgentEntry(
 	let bridgeRun: CursorPiToolBridgeRun | undefined;
 	let sessionStore: OpenCursorSessionStore | undefined;
 	try {
-		const registeredBridge = getRegisteredCursorPiToolBridge();
+		const registeredBridge = params.bridge;
 		if (registeredBridge) {
 			bridgeRun = await registeredBridge.createRun({
 				onToolRequest: params.onBridgeToolRequest,
@@ -466,7 +468,7 @@ async function createSessionAgentEntry(
 			createAgent ??= sdk.Agent.create;
 			resumeAgent ??= sdk.Agent.resume;
 		}
-		const resumeHandle = resumeEligible ? getMatchingCursorSessionAgentResumeHandle(resolvedPoolKey) : undefined;
+		const resumeHandle = resumeEligible ? getMatchingCursorSessionAgentResumeHandle(resolvedPoolKey, scopeKey) : undefined;
 		const storeSelection = await openCursorSessionStoreForScope({
 			cwd: params.cwd,
 			scopeKey,
@@ -546,9 +548,10 @@ export function invalidateSessionAgent(
 	if (options?.deadTransport) deadTransportScopeKeys.add(scopeKey);
 }
 
-export async function acquireSessionCursorAgent(params: SessionCursorAgentCreateParams): Promise<SessionCursorAgentLease> {
-	const scopeKey = getCursorSessionScopeKey();
-	const persistentStore = getCursorSessionFile() !== undefined;
+export async function acquireSessionCursorAgent(input: SessionCursorAgentCreateParams): Promise<SessionCursorAgentLease> {
+	const params = { ...input, bridge: "bridge" in input ? input.bridge : getRegisteredCursorPiToolBridge() };
+	const scopeKey = params.scope?.scopeKey ?? getCursorSessionScopeKey();
+	const persistentStore = (params.scope ? params.scope.sessionFile : getCursorSessionFile()) !== undefined;
 
 	while (true) {
 		assertScopeAcceptsAcquire(scopeKey);

package/src/cursor-session-compaction-prep.ts

@@ -1,19 +1,14 @@
 import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import { resetSessionCursorAgent } from "./cursor-session-agent.js";
-import { suppressCursorSessionAgentResumeHandlePersist } from "./cursor-session-agent-resume.js";
 import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
 
 /**
- * Prepare the pooled Cursor session agent for pi compaction summarization.
- * Releases any scoped live-run drain state still tied to the pooled agent, then
- * disposes the pool entry so summarization acquires a clean SDK agent.
- * Suppresses local-resume handle persist so the summarizer send cannot leak
- * a one-message handle into the next normal turn (#223).
+ * Release scoped conversation runs and reset the pool before compaction.
+ * Summary execution owns a separate temporary agent, never this pool.
  */
 export async function prepareCursorSessionForCompaction(
 	scopeKey: string = getCursorSessionScopeKey(),
 ): Promise<void> {
-	suppressCursorSessionAgentResumeHandlePersist();
 	while (true) {
 		const run = cursorLiveRuns.getActiveForScope(scopeKey);
 		if (!run || run.disposed) break;

package/src/cursor-session-scope.ts

@@ -1,12 +1,13 @@
 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 type { ExtensionHandler, ProjectTrustHandler, SessionInfoChangedEvent, SessionStartEvent, SessionShutdownEvent } 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;
+	on(event: "session_shutdown", handler: ExtensionHandler<SessionShutdownEvent>): void;
 }
 
 const ANONYMOUS_SESSION_SCOPE_KEY = "__anonymous__";
@@ -15,6 +16,16 @@ export const MAX_CURSOR_SESSION_NAME_LENGTH = 100;
 
 type CursorSessionScopeChangeHandler = (previousScopeKey: string) => Promise<void> | void;
 
+export interface CursorTurnScope {
+	readonly cwd: string;
+	readonly scopeKey: string;
+	readonly sessionFile: string | undefined;
+	readonly sessionId: string | undefined;
+	readonly sessionName: string | undefined;
+	readonly projectTrusted: boolean;
+	readonly generation: number;
+}
+
 const state = {
 	sessionCwd: process.cwd(),
 	sessionFile: undefined as string | undefined,
@@ -23,44 +34,67 @@ const state = {
 	projectTrusted: false,
 	sessionGeneration: 0,
 };
-
-const scopeGenerations = new Map<string, number>([[ANONYMOUS_SESSION_SCOPE_KEY, state.sessionGeneration]]);
+type ScopeRecord = typeof state;
+const scopes = new Map<object, ScopeRecord>();
+const scopeChangeHandlers = new Map<object, CursorSessionScopeChangeHandler>();
+const scopeGenerations = new Map<string, number>([[ANONYMOUS_SESSION_SCOPE_KEY, 0]]);
 const projectTrustResolutionCwds = new Set<string>();
 let nextSessionGeneration = 1;
-let scopeChangeHandler: CursorSessionScopeChangeHandler | undefined;
 
-/**
- * Pi session file when known; used to scope reused Cursor SDK agents to one pi session.
- */
+function scopeKeyFor(record: ScopeRecord): string {
+	if (record.sessionFile) return record.sessionFile;
+	if (record.sessionId) return `${EPHEMERAL_SESSION_SCOPE_PREFIX}${record.sessionId}`;
+	return ANONYMOUS_SESSION_SCOPE_KEY;
+}
+
+export function cursorSessionScopeKeyForManager(manager: {
+	getSessionFile?(): string | undefined | null;
+	getSessionId?(): string | undefined;
+}): string {
+	return manager.getSessionFile?.() ?? (manager.getSessionId?.()
+		? `${EPHEMERAL_SESSION_SCOPE_PREFIX}${manager.getSessionId()}`
+		: ANONYMOUS_SESSION_SCOPE_KEY);
+}
+
+export function getCursorSessionScopeSnapshot(pi?: object): CursorTurnScope {
+	if (!pi && scopes.size > 1) throw new Error("Cursor provider ownership requires a session-bound provider closure when multiple extensions are loaded.");
+	const record = pi ? scopes.get(pi) : state;
+	if (!record) throw new Error("Cursor session binding is no longer active.");
+	const scopeKey = scopeKeyFor(record);
+	return Object.freeze({
+		cwd: record.sessionCwd,
+		scopeKey,
+		sessionFile: record.sessionFile,
+		sessionId: record.sessionId,
+		sessionName: record.sessionName,
+		projectTrusted: record.projectTrusted,
+		generation: getCursorSessionScopeGeneration(scopeKey),
+	});
+}
+
+export function hasLiveCursorSessions(): boolean {
+	return scopes.size > 0;
+}
+
 export function getCursorSessionFile(): string | undefined {
 	return state.sessionFile;
 }
 
-/**
- * Stable scope key for session-agent pooling. Falls back to a process-local anonymous key
- * before the first session_start (tests and early startup).
- */
+/** Stable pool key, with process-local anonymous fallback before session_start. */
 export function getCursorSessionScopeKey(): string {
-	if (state.sessionFile) return state.sessionFile;
-	if (state.sessionId) return `${EPHEMERAL_SESSION_SCOPE_PREFIX}${state.sessionId}`;
-	return ANONYMOUS_SESSION_SCOPE_KEY;
+	return scopeKeyFor(state);
 }
 
 export function getCursorSessionScopeGeneration(scopeKey: string = getCursorSessionScopeKey()): number {
 	return scopeGenerations.get(scopeKey) ?? 0;
 }
 
-/**
- * Pi session cwd when known; falls back to process.cwd() before session_start.
- * Updated on session_start only until pi threads cwd into streamSimple—mid-session cwd
- * changes without a new session_start event are not reflected here.
- */
 export function getCursorSessionCwd(): string {
 	return state.sessionCwd;
 }
 
-export function getCursorSessionProjectTrusted(): boolean {
-	return state.projectTrusted;
+export function getCursorSessionProjectTrusted(pi?: object): boolean {
+	return pi ? scopes.get(pi)?.projectTrusted === true : state.projectTrusted;
 }
 
 export function getCursorSessionName(): string | undefined {
@@ -84,9 +118,8 @@ function setCursorSessionScope(
 	state.sessionId = sessionId;
 	state.sessionName = normalizeCursorSessionName(sessionName);
 	state.projectTrusted = projectTrusted;
-	state.sessionGeneration = nextSessionGeneration;
-	nextSessionGeneration += 1;
-	scopeGenerations.set(getCursorSessionScopeKey(), state.sessionGeneration);
+	state.sessionGeneration = nextSessionGeneration++;
+	scopeGenerations.set(scopeKeyFor(state), state.sessionGeneration);
 }
 
 function recordProjectTrustResolution(cwd: string): void {
@@ -98,43 +131,58 @@ function isCliProjectTrustApproved(args = process.argv.slice(2)): boolean {
 }
 
 function resetCursorSessionScope(): void {
-	state.sessionCwd = process.cwd();
-	state.sessionFile = undefined;
-	state.sessionId = undefined;
-	state.sessionName = undefined;
-	state.projectTrusted = false;
-	state.sessionGeneration = 0;
+	Object.assign(state, {
+		sessionCwd: process.cwd(), sessionFile: undefined, sessionId: undefined,
+		sessionName: undefined, projectTrusted: false, sessionGeneration: 0,
+	});
 	nextSessionGeneration = 1;
 	scopeGenerations.clear();
-	scopeGenerations.set(ANONYMOUS_SESSION_SCOPE_KEY, state.sessionGeneration);
+	scopeGenerations.set(ANONYMOUS_SESSION_SCOPE_KEY, 0);
 	projectTrustResolutionCwds.clear();
+	scopes.clear();
+	scopeChangeHandlers.clear();
 }
 
-export function onCursorSessionScopeKeyChange(handler: CursorSessionScopeChangeHandler): void {
-	scopeChangeHandler = handler;
+export function onCursorSessionScopeKeyChange(pi: object, handler: CursorSessionScopeChangeHandler): void {
+	scopeChangeHandlers.set(pi, handler);
 }
 
 export function registerCursorSessionScope(pi: CursorSessionScopeExtensionApi): void {
+	// A fresh binding has no previous pooled scope to steal from the last-bound mirror.
+	const record: ScopeRecord = {
+		sessionCwd: process.cwd(), sessionFile: undefined, sessionId: undefined,
+		sessionName: undefined, projectTrusted: false, sessionGeneration: 0,
+	};
+	scopes.set(pi, record);
+	const trustedCwds = new Set<string>();
 	pi.on("project_trust", (event) => {
-		recordProjectTrustResolution(event.cwd);
+		trustedCwds.add(resolve(event.cwd));
 		return { trusted: "undecided" };
 	});
 	pi.on("session_start", async (_event, ctx) => {
-		const previousScopeKey = getCursorSessionScopeKey();
+		const previousScopeKey = scopeKeyFor(record);
+		const wasBound = record.sessionGeneration > 0;
 		setCursorSessionScope(
 			ctx.cwd,
 			ctx.sessionManager?.getSessionFile?.() ?? undefined,
 			ctx.sessionManager?.getSessionId?.() ?? undefined,
 			ctx.isProjectTrusted?.() === true
-				&& (projectTrustResolutionCwds.has(resolve(ctx.cwd)) || isCliProjectTrustApproved()),
+				&& (trustedCwds.has(resolve(ctx.cwd)) || projectTrustResolutionCwds.has(resolve(ctx.cwd)) || isCliProjectTrustApproved()),
 			ctx.sessionManager?.getSessionName?.() ?? undefined,
 		);
-		if (previousScopeKey !== getCursorSessionScopeKey()) {
-			await scopeChangeHandler?.(previousScopeKey);
+		Object.assign(record, state);
+		scopes.set(pi, record);
+		if (wasBound && previousScopeKey !== scopeKeyFor(record)) {
+			await scopeChangeHandlers.get(pi)?.(previousScopeKey);
 		}
 	});
 	pi.on("session_info_changed", (event) => {
-		state.sessionName = normalizeCursorSessionName(event.name);
+		record.sessionName = normalizeCursorSessionName(event.name);
+		Object.assign(state, record);
+	});
+	pi.on("session_shutdown", () => {
+		scopes.delete(pi);
+		scopeChangeHandlers.delete(pi);
 	});
 }
 

package/src/cursor-session-settings.ts

@@ -0,0 +1,72 @@
+import type { AgentModeOption } from "@cursor/sdk";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CursorExplicitSdkConfig, CursorRuntime } from "./cursor-config.js";
+import { cursorSessionScopeKeyForManager, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
+
+export type CursorCliModeState =
+	| { kind: "unset" }
+	| { kind: "valid"; mode: AgentModeOption }
+	| { kind: "invalid"; raw: string; message: string };
+
+function createCliSettings() {
+	return {
+		forceFast: false, forceNoFast: false,
+		mode: { kind: "unset" } as CursorCliModeState,
+		config: {} as CursorExplicitSdkConfig,
+		cloudEnvNames: undefined as string | undefined,
+		localForceConsumed: false,
+	};
+}
+
+function createSettings() {
+	return {
+		fast: new Map<string, boolean>(),
+		mode: undefined as AgentModeOption | undefined,
+		runtime: undefined as CursorRuntime | undefined,
+		cloudAcknowledged: false,
+		http1: undefined as boolean | undefined,
+		projectTrusted: false,
+		cli: createCliSettings(),
+	};
+}
+const settings = new Map<string, ReturnType<typeof createSettings>>();
+let cliOwners = new WeakMap<object, ReturnType<typeof createCliSettings>>();
+let legacySettings = createSettings();
+
+export function getCursorSessionSettings(scopeKey?: string) {
+	if (scopeKey === undefined) return legacySettings;
+	let value = settings.get(scopeKey);
+	if (!value) {
+		value = createSettings();
+		settings.set(scopeKey, value);
+	}
+	return value;
+}
+
+export function cursorSettingsScopeForContext(ctx: Partial<Pick<ExtensionContext, "sessionManager">>): string | undefined {
+	const manager = ctx.sessionManager;
+	return manager ? cursorSessionScopeKeyForManager(manager) : undefined;
+}
+
+export function registerCursorSessionSettings(pi: Pick<ExtensionAPI, "on">): void {
+	let scopeKey: string | undefined;
+	let cli = createCliSettings();
+	pi.on("session_start", (_event, ctx) => {
+		if (scopeKey) settings.delete(scopeKey);
+		scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager);
+		legacySettings = getCursorSessionSettings(scopeKey);
+		// Reload creates a new ExtensionAPI but retains the same public manager.
+		// Keep the run's one-shot CLI consumption without retaining dead managers.
+		cli = cliOwners.get(ctx.sessionManager) ?? cli;
+		cliOwners.set(ctx.sessionManager, cli);
+		legacySettings.cli = cli;
+		legacySettings.projectTrusted = getCursorSessionProjectTrusted(pi);
+	});
+	pi.on("session_shutdown", () => { if (scopeKey) settings.delete(scopeKey); });
+}
+
+export function resetCursorSessionSettingsForTests(): void {
+	settings.clear();
+	cliOwners = new WeakMap();
+	legacySettings = createSettings();
+}