pi-cursor-sdk 0.4.0 → 0.5.0

package/dist/cursor-session-agent-lineage.js

@@ -1,5 +1,5 @@
 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";
 const LINEAGE_ENTRY_VERSION = 1;
@@ -9,9 +9,10 @@ function isIsoTimestamp(value) {
     const timestamp = Date.parse(value);
     return !Number.isNaN(timestamp) && new Date(timestamp).toISOString() === value;
 }
-const state = {
+let state = {
     recordedAgentIds: new Set(),
 };
+const statesByScope = new Map();
 export function parseCursorSessionAgentLineageEntryData(value) {
     const record = asRecord(value);
     if (record?.version !== LINEAGE_ENTRY_VERSION ||
@@ -48,11 +49,16 @@ function readRecordedAgentIds(entries, sessionId) {
     }));
 }
 /** Best-effort forensic lineage at the local Agent.send() boundary. Independent of resume. */
-export function recordCursorSessionAgentLineage(agentId) {
-    const { appendEntry, sessionId, sessionFile, scopeKey, cwd } = state;
+export function recordCursorSessionAgentLineage(agentId, turnScopeKey) {
+    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))
+    if (!isCursorLocalAgentId(agentId) || sessionState.recordedAgentIds.has(agentId))
         return;
     const data = {
         version: LINEAGE_ENTRY_VERSION,
@@ -66,22 +72,31 @@ export function recordCursorSessionAgentLineage(agentId) {
     };
     try {
         appendEntry(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.
     }
 }
 export function registerCursorSessionAgentLineage(pi) {
+    const sessionState = { 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;
@@ -91,6 +106,7 @@ export function registerCursorSessionAgentLineage(pi) {
     });
 }
 function resetStateForTests() {
+    statesByScope.clear();
     state.appendEntry = undefined;
     state.sessionId = undefined;
     state.sessionFile = undefined;

package/dist/cursor-session-agent-resume.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { asRecord } from "./cursor-record-utils.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { getCursorSessionScopeSnapshot, getCursorSessionScopeKey } from "./cursor-session-scope.js";
 export const CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE = "cursor-sdk-agent-resume";
 const LEGACY_RESUME_ENTRY_VERSION = 1;
 const RESUME_ENTRY_VERSION = 2;
@@ -11,22 +11,19 @@ const EMPTY_BRANCH_HASH = hashParts(["cursor-sdk-agent-resume-branch", "v1"]);
 export function isCursorLocalAgentId(value) {
     return typeof value === "string" && value.length <= MAX_LOCAL_AGENT_ID_LENGTH && /^agent-[A-Za-z0-9_-]+$/.test(value);
 }
-const state = {
+let lastBoundState = {
     scopeKey: getCursorSessionScopeKey(),
     cwd: process.cwd(),
     branchPathHash: EMPTY_BRANCH_HASH,
     compactionGeneration: 0,
     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;
-export function suppressCursorSessionAgentResumeHandlePersist() {
-    resumeHandlePersistSuppressed = true;
-    state.pendingHandle = undefined;
-}
-export function allowCursorSessionAgentResumeHandlePersist() {
-    resumeHandlePersistSuppressed = false;
+const statesByScope = new Map();
+function getResumeState(scopeKey) {
+    if (scopeKey !== undefined) {
+        return statesByScope.get(scopeKey) ?? lastBoundState;
+    }
+    return lastBoundState;
 }
 function hashParts(parts) {
     const hash = createHash("sha256");
@@ -142,7 +139,7 @@ function matchesResumeScope(data, scope) {
         data.cwd === scope.cwd &&
         data.repoRoot === scope.repoRoot;
 }
-function matchesCurrentSession(data, branchPathHash, compactionGeneration = state.compactionGeneration) {
+function matchesCurrentSession(data, branchPathHash, compactionGeneration, state) {
     return matchesResumeScope(data, state) &&
         data.compactionGeneration === compactionGeneration &&
         data.branchPathHash === branchPathHash;
@@ -244,19 +241,19 @@ export function readResumableCursorSessionAgentIds(entries, scope) {
     }
     return [...agentIds].sort((a, b) => a.localeCompare(b));
 }
-function canRestoreHandleSpanEntry(entry) {
+function canRestoreHandleSpanEntry(entry, state) {
     if (entry.type === "message" && entry.message.role === "user")
         return !state.unownedUserEntryIds.has(entry.id);
     return canResumeHandleSpanEntry(entry);
 }
-function restoreFromBranch(branch, allEntries = branch) {
+function restoreFromBranch(branch, allEntries, state) {
     const resumeIndex = indexLatestResumeEntries(allEntries);
     let fold = { branchPathHash: EMPTY_BRANCH_HASH, compactionGeneration: 0 };
     let lastBranchHandle;
     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;
@@ -267,7 +264,10 @@ function restoreFromBranch(branch, allEntries = branch) {
     state.activeHandle = fold.activeHandle;
     state.lastBranchHandle = lastBranchHandle;
 }
-export function getMatchingCursorSessionAgentResumeHandle(poolKey) {
+export function getMatchingCursorSessionAgentResumeHandle(poolKey, scopeKey) {
+    const state = getResumeState(scopeKey);
+    if (scopeKey !== undefined && state.scopeKey !== scopeKey)
+        return undefined;
     const handle = state.activeHandle;
     if (!handle || !isCursorLocalAgentId(handle.agentId))
         return undefined;
@@ -290,8 +290,9 @@ export function getMatchingCursorSessionAgentResumeHandle(poolKey) {
         sendState: { ...handle.sendState },
     };
 }
-export function persistCursorSessionAgentResumeHandle(input) {
-    if (resumeHandlePersistSuppressed)
+export function persistCursorSessionAgentResumeHandle(input, scopeKey) {
+    const state = getResumeState(scopeKey);
+    if (scopeKey !== undefined && state.scopeKey !== scopeKey)
         return;
     if (!isCursorLocalAgentId(input.agentId))
         return;
@@ -303,13 +304,8 @@ export function persistCursorSessionAgentResumeHandle(input) {
         storeIdentity: { ...input.storeIdentity },
     };
 }
-function flushPendingCursorSessionAgentResumeHandle(branch) {
-    if (resumeHandlePersistSuppressed) {
-        state.pendingHandle = undefined;
-        restoreFromBranch(branch);
-        return;
-    }
-    restoreFromBranch(branch);
+function flushPendingCursorSessionAgentResumeHandle(branch, state) {
+    restoreFromBranch(branch, branch, state);
     const pending = state.pendingHandle;
     state.pendingHandle = undefined;
     if (!pending || !state.appendEntry)
@@ -347,14 +343,23 @@ function flushPendingCursorSessionAgentResumeHandle(branch) {
     }
 }
 export function registerCursorSessionAgentResume(pi) {
-    state.appendEntry = pi.appendEntry;
+    const sessionState = {
+        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) => {
         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;
@@ -366,7 +371,7 @@ export function registerCursorSessionAgentResume(pi) {
         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()) {
@@ -375,9 +380,14 @@ export function registerCursorSessionAgentResume(pi) {
         }
         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);
@@ -388,11 +398,18 @@ export function registerCursorSessionAgentResume(pi) {
         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) {
-    Object.assign(state, next);
+    Object.assign(getResumeState(), next);
 }
 function resetStateForTests() {
+    const state = lastBoundState;
     state.appendEntry = undefined;
     state.scopeKey = getCursorSessionScopeKey();
     state.sessionFile = undefined;
@@ -405,13 +422,12 @@ function resetStateForTests() {
     state.lastBranchHandle = undefined;
     state.pendingHandle = undefined;
     state.unownedUserEntryIds = new Set();
-    resumeHandlePersistSuppressed = false;
+    statesByScope.clear();
 }
 export const __testUtils = {
     EMPTY_BRANCH_HASH,
     hashBranchStep,
     reset: resetStateForTests,
     set: setStateForTests,
-    state,
-    isResumeHandlePersistSuppressed: () => resumeHandlePersistSuppressed,
+    get state() { return getResumeState(); },
 };

package/dist/cursor-session-agent.js

@@ -82,8 +82,7 @@ function buildLocalSafetyPoolKey(localSafety) {
 function buildApiKeyPoolKeyFingerprint(apiKey) {
     return createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
 }
-function buildBridgePoolKeySuffix() {
-    const registeredBridge = getRegisteredCursorPiToolBridge();
+function buildBridgePoolKeySuffix(registeredBridge) {
     if (!registeredBridge)
         return "bridge:absent";
     return registeredBridge.getToolSurfaceSignature();
@@ -101,7 +100,7 @@ function buildSessionAgentPoolKey(scopeKey, params) {
                 ? "http1:on"
                 : "http1:off",
         buildApiKeyPoolKeyFingerprint(params.apiKey),
-        buildBridgePoolKeySuffix(),
+        buildBridgePoolKeySuffix("bridge" in params ? params.bridge : getRegisteredCursorPiToolBridge()),
     ].join("\0");
 }
 async function disposePoolEntry(entry, options) {
@@ -179,7 +178,7 @@ function commitSessionAgentSendForLease(scopeKey, poolKey, instanceId, context,
             poolKey: entry.poolKey,
             sendState: entry.sendState,
             storeIdentity: entry.sessionStore.identity,
-        });
+        }, scopeKey);
     }
 }
 function normalizeRunCompletion(completion) {
@@ -279,7 +278,7 @@ async function createSessionAgentEntry(scopeKey, persistentStore, instanceId, se
     let bridgeRun;
     let sessionStore;
     try {
-        const registeredBridge = getRegisteredCursorPiToolBridge();
+        const registeredBridge = params.bridge;
         if (registeredBridge) {
             bridgeRun = await registeredBridge.createRun({
                 onToolRequest: params.onBridgeToolRequest,
@@ -299,7 +298,7 @@ async function createSessionAgentEntry(scopeKey, persistentStore, instanceId, se
             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,
@@ -373,9 +372,10 @@ export function invalidateSessionAgent(scopeKey = getCursorSessionScopeKey(), op
     if (options?.deadTransport)
         deadTransportScopeKeys.add(scopeKey);
 }
-export async function acquireSessionCursorAgent(params) {
-    const scopeKey = getCursorSessionScopeKey();
-    const persistentStore = getCursorSessionFile() !== undefined;
+export async function acquireSessionCursorAgent(input) {
+    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);
         if (invalidatedScopeKeys.has(scopeKey)) {

package/dist/cursor-session-compaction-prep.js

@@ -1,16 +1,11 @@
 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 = getCursorSessionScopeKey()) {
-    suppressCursorSessionAgentResumeHandlePersist();
     while (true) {
         const run = cursorLiveRuns.getActiveForScope(scopeKey);
         if (!run || run.disposed)

package/dist/cursor-session-scope.js

@@ -12,40 +12,58 @@ const state = {
     projectTrusted: false,
     sessionGeneration: 0,
 };
-const scopeGenerations = new Map([[ANONYMOUS_SESSION_SCOPE_KEY, state.sessionGeneration]]);
+const scopes = new Map();
+const scopeChangeHandlers = new Map();
+const scopeGenerations = new Map([[ANONYMOUS_SESSION_SCOPE_KEY, 0]]);
 const projectTrustResolutionCwds = new Set();
 let nextSessionGeneration = 1;
-let scopeChangeHandler;
-/**
- * Pi session file when known; used to scope reused Cursor SDK agents to one pi session.
- */
+function scopeKeyFor(record) {
+    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) {
+    return manager.getSessionFile?.() ?? (manager.getSessionId?.()
+        ? `${EPHEMERAL_SESSION_SCOPE_PREFIX}${manager.getSessionId()}`
+        : ANONYMOUS_SESSION_SCOPE_KEY);
+}
+export function getCursorSessionScopeSnapshot(pi) {
+    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() {
+    return scopes.size > 0;
+}
 export function getCursorSessionFile() {
     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() {
-    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 = getCursorSessionScopeKey()) {
     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() {
     return state.sessionCwd;
 }
-export function getCursorSessionProjectTrusted() {
-    return state.projectTrusted;
+export function getCursorSessionProjectTrusted(pi) {
+    return pi ? scopes.get(pi)?.projectTrusted === true : state.projectTrusted;
 }
 export function getCursorSessionName() {
     return state.sessionName;
@@ -61,9 +79,8 @@ function setCursorSessionScope(cwd, sessionFile, sessionId, projectTrusted = fal
     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) {
     projectTrustResolutionCwds.add(resolve(cwd));
@@ -72,35 +89,50 @@ function isCliProjectTrustApproved(args = process.argv.slice(2)) {
     return parseArgs(args).projectTrustOverride === true;
 }
 function resetCursorSessionScope() {
-    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) {
-    scopeChangeHandler = handler;
+export function onCursorSessionScopeKeyChange(pi, handler) {
+    scopeChangeHandlers.set(pi, handler);
 }
 export function registerCursorSessionScope(pi) {
+    // A fresh binding has no previous pooled scope to steal from the last-bound mirror.
+    const record = {
+        sessionCwd: process.cwd(), sessionFile: undefined, sessionId: undefined,
+        sessionName: undefined, projectTrusted: false, sessionGeneration: 0,
+    };
+    scopes.set(pi, record);
+    const trustedCwds = new Set();
     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()), ctx.sessionManager?.getSessionName?.() ?? undefined);
-        if (previousScopeKey !== getCursorSessionScopeKey()) {
-            await scopeChangeHandler?.(previousScopeKey);
+            && (trustedCwds.has(resolve(ctx.cwd)) || projectTrustResolutionCwds.has(resolve(ctx.cwd)) || isCliProjectTrustApproved()), ctx.sessionManager?.getSessionName?.() ?? undefined);
+        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);
     });
 }
 export const __testUtils = {

package/dist/cursor-session-settings.js

@@ -0,0 +1,61 @@
+import { cursorSessionScopeKeyForManager, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
+function createCliSettings() {
+    return {
+        forceFast: false, forceNoFast: false,
+        mode: { kind: "unset" },
+        config: {},
+        cloudEnvNames: undefined,
+        localForceConsumed: false,
+    };
+}
+function createSettings() {
+    return {
+        fast: new Map(),
+        mode: undefined,
+        runtime: undefined,
+        cloudAcknowledged: false,
+        http1: undefined,
+        projectTrusted: false,
+        cli: createCliSettings(),
+    };
+}
+const settings = new Map();
+let cliOwners = new WeakMap();
+let legacySettings = createSettings();
+export function getCursorSessionSettings(scopeKey) {
+    if (scopeKey === undefined)
+        return legacySettings;
+    let value = settings.get(scopeKey);
+    if (!value) {
+        value = createSettings();
+        settings.set(scopeKey, value);
+    }
+    return value;
+}
+export function cursorSettingsScopeForContext(ctx) {
+    const manager = ctx.sessionManager;
+    return manager ? cursorSessionScopeKeyForManager(manager) : undefined;
+}
+export function registerCursorSessionSettings(pi) {
+    let scopeKey;
+    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() {
+    settings.clear();
+    cliOwners = new WeakMap();
+    legacySettings = createSettings();
+}