pi-cursor-sdk 0.4.0 → 0.5.2

package/dist/cursor-sdk-process-error-guard.js

@@ -4,7 +4,7 @@ import { classifyCursorConnectError, isCursorSdkAbortConnectError, isCursorSdkCo
 // ConnectRPC suppression remains scoped to active provider turns.
 const activeProviderTurns = new Set();
 const activeSessions = new Set();
-let activeLifecycleSessionGuard;
+const lifecycleSessionGuards = new Map();
 let originalProcessEmit;
 let cursorProcessEmit;
 let bunUnhandledRejectionListenerInstalled = false;
@@ -19,7 +19,7 @@ function hasActiveAbortSuppression() {
     return false;
 }
 function isCursorProvenance(source) {
-    return source === "cursor-sdk-stack" || source === "cursor-extension-connect-stack" || source === "cursor-backend-details";
+    return source === "cursor-sdk-stack" || source === "cursor-backend-details";
 }
 function isCursorSdkWriteIterableClosedError(error) {
     return (error instanceof Error &&
@@ -63,8 +63,6 @@ function shouldSuppressProcessError(event, args) {
         return hasActiveAbortSuppression();
     if (activeProviderTurns.size === 0)
         return false;
-    if (classification.kind === "network")
-        return isCursorProvenance(classification.source) || classification.source === "connect-node-stack";
     return isCursorProvenance(classification.source);
 }
 function installProcessEmitPatch() {
@@ -125,8 +123,9 @@ export const __testUtils = {
     activeProviderTurnCount: () => activeProviderTurns.size,
     activeSessionCount: () => activeSessions.size,
     resetLifecycleSessionGuard() {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = undefined;
+        for (const guard of lifecycleSessionGuards.values())
+            guard.dispose();
+        lifecycleSessionGuards.clear();
     },
 };
 export { isCursorSdkAbortConnectError };
@@ -167,11 +166,11 @@ export function installCursorSdkSessionProcessErrorGuard() {
 }
 export function registerCursorSdkSessionProcessErrorGuard(pi) {
     pi.on("session_start", () => {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = installCursorSdkSessionProcessErrorGuard();
+        lifecycleSessionGuards.get(pi)?.dispose();
+        lifecycleSessionGuards.set(pi, installCursorSdkSessionProcessErrorGuard());
     });
     pi.on("session_shutdown", () => {
-        activeLifecycleSessionGuard?.dispose();
-        activeLifecycleSessionGuard = undefined;
+        lifecycleSessionGuards.get(pi)?.dispose();
+        lifecycleSessionGuards.delete(pi);
     });
 }

package/dist/cursor-sdk-runtime.js

@@ -1,3 +1,15 @@
+// Vendor env must initialize before the static @cursor/sdk import below so
+// tree-sitter natives resolve when Pi lives outside this package's node_modules.
+import "./cursor-sdk-vendor-env.js";
+import * as CursorSdk from "@cursor/sdk";
+/**
+ * Load the Cursor SDK module.
+ *
+ * Uses a static import so Pi's compiled-Bun extension graph includes @cursor/sdk
+ * (a runtime dynamic bare import is omitted from that graph; see #228).
+ * `loadCursorSdk` remains async for call-site compatibility and so vendor-env
+ * side effects (imported above) always run before callers receive the module.
+ */
 export async function loadCursorSdk() {
-    return import("@cursor/sdk");
+    return CursorSdk;
 }

package/dist/cursor-sdk-vendor-env.js

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveCursorSdkPlatformPackageDirectory } from "./cursor-ripgrep-path.js";
+/**
+ * Ensure CURSOR_TREE_SITTER_VENDOR_DIR is set before @cursor/sdk first loads.
+ * Must run as a side effect of importing this module (before a static SDK import).
+ */
+export function ensureCursorTreeSitterVendorDir() {
+    if (process.env.CURSOR_TREE_SITTER_VENDOR_DIR !== undefined)
+        return;
+    const packageDirectory = resolveCursorSdkPlatformPackageDirectory();
+    if (!packageDirectory)
+        return;
+    const vendor = join(packageDirectory, "vendor");
+    if (existsSync(join(vendor, "tree-sitter", "index.js")) &&
+        existsSync(join(vendor, "tree-sitter-bash", "index.js"))) {
+        process.env.CURSOR_TREE_SITTER_VENDOR_DIR = vendor;
+    }
+}
+ensureCursorTreeSitterVendorDir();

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

@@ -2,9 +2,9 @@ import { asRecord, getString } from "./cursor-record-utils.js";
 import { fsyncExistingRegularFile } from "./cursor-durable-fs.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager } from "./cursor-session-scope.js";
 import { CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE, isCursorLocalAgentId, parseCursorSessionAgentResumeEntryData, readResumableCursorSessionAgentIds, resolveCursorSessionRepoRoot, } from "./cursor-session-agent-resume.js";
-import { cursorSessionStoreIdentitiesEqual, getCursorSessionStoreIdentities, openCursorSessionStore, } from "./cursor-session-store.js";
+import { withCursorSessionStoreIdentities, openCursorSessionStore, resolveCursorSessionStoreIdentity, } from "./cursor-session-store.js";
 export const CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE = "cursor-sdk-agent-cleanup";
 class InvalidCursorSessionStoreIdentityError extends Error {
 }
@@ -41,7 +41,7 @@ function getCurrentCleanupScope(ctx) {
     const sessionId = ctx.sessionManager.getSessionId();
     const repoRoot = resolveCursorSessionRepoRoot(ctx.cwd);
     return {
-        scopeKey: getCursorSessionScopeKey(),
+        scopeKey: cursorSessionScopeKeyForManager(ctx.sessionManager),
         ...(sessionFile ? { sessionFile } : {}),
         ...(sessionId ? { sessionId } : {}),
         cwd: ctx.cwd,
@@ -202,7 +202,7 @@ function appendDurableCleanupEntry(pi, ctx, data) {
         return false;
     return fsyncExistingRegularFile(sessionFile);
 }
-export async function runCursorSessionAgentCleanupCommand(pi, args, ctx) {
+export async function runCursorSessionAgentCleanupCommand(pi, args, ctx, storeRoot) {
     const usage = "Usage: /cursor-local-resume-cleanup [--dry-run|--yes]";
     const tokens = args.trim().split(/\s+/).filter(Boolean);
     const dryRun = tokens.length === 0 || (tokens.length === 1 && tokens[0] === "--dry-run");
@@ -236,7 +236,7 @@ export async function runCursorSessionAgentCleanupCommand(pi, args, ctx) {
         }
         return;
     }
-    if (!appendDurableCleanupEntry(pi, ctx, { action: "delete", phase: "intent", ...baseEntry })) {
+    if (!scope.sessionFile || !appendDurableCleanupEntry(pi, ctx, { action: "delete", phase: "intent", ...baseEntry })) {
         ctx.ui.notify("Cleanup intent could not be durably recorded. No agents were deleted.", "error");
         return;
     }
@@ -244,31 +244,34 @@ export async function runCursorSessionAgentCleanupCommand(pi, args, ctx) {
     const failedAgentIds = [];
     const openedStores = new Map();
     try {
-        const operations = await getSdkOperations();
-        const identities = await getCursorSessionStoreIdentities(ctx.cwd, scope.scopeKey, scope.sessionFile !== undefined);
-        for (const candidate of plan.candidates) {
-            const { agentId } = candidate;
-            try {
-                const identity = candidate.storeIdentity ?? identities.defaultStore;
-                if (!cursorSessionStoreIdentitiesEqual(identity, identities.defaultStore) &&
-                    !cursorSessionStoreIdentitiesEqual(identity, identities.sessionStore))
-                    throw new InvalidCursorSessionStoreIdentityError("Recorded Cursor local store identity is not valid for this pi session");
-                let openedStore = openedStores.get(identity.stateRoot);
-                if (!openedStore) {
-                    openedStore = await openCursorSessionStore(ctx.cwd, identity);
-                    openedStores.set(identity.stateRoot, openedStore);
+        await withCursorSessionStoreIdentities(ctx.cwd, scope.scopeKey, storeRoot, async (identities) => {
+            const operations = await getSdkOperations();
+            for (const candidate of plan.candidates) {
+                const { agentId } = candidate;
+                try {
+                    const identity = await resolveCursorSessionStoreIdentity({
+                        cwd: ctx.cwd, scopeKey: scope.scopeKey,
+                        identities, recordedIdentity: candidate.storeIdentity, agentId,
+                    });
+                    if (!identity)
+                        throw new InvalidCursorSessionStoreIdentityError("Recorded Cursor local store identity is not valid for this pi session");
+                    let openedStore = openedStores.get(identity.stateRoot);
+                    if (!openedStore) {
+                        openedStore = await openCursorSessionStore(ctx.cwd, identity, identities.workspaceRoot, identities.storeRoot);
+                        openedStores.set(identity.stateRoot, openedStore);
+                    }
+                    await operations.delete(agentId, { cwd: ctx.cwd, store: openedStore.store });
+                    deletedAgentIds.push(agentId);
+                }
+                catch (error) {
+                    failedAgentIds.push({
+                        agentId,
+                        error: scrubSensitiveText(getString(asRecord(error), "message") ?? String(error)),
+                        ...(error instanceof InvalidCursorSessionStoreIdentityError ? { retryable: false } : {}),
+                    });
                 }
-                await operations.delete(agentId, { cwd: ctx.cwd, store: openedStore.store });
-                deletedAgentIds.push(agentId);
-            }
-            catch (error) {
-                failedAgentIds.push({
-                    agentId,
-                    error: scrubSensitiveText(getString(asRecord(error), "message") ?? String(error)),
-                    ...(error instanceof InvalidCursorSessionStoreIdentityError ? { retryable: false } : {}),
-                });
             }
-        }
+        });
     }
     catch (error) {
         const message = scrubSensitiveText(getString(asRecord(error), "message") ?? String(error));

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

@@ -1,32 +1,41 @@
 import { clearCursorSdkHttp1 } from "./cursor-http1.js";
-import { onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager, hasLiveCursorSessions, onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
 import { disposeSessionCursorAgent, invalidateSessionAgent, resetSessionCursorAgent, } from "./cursor-session-agent.js";
 export function registerCursorSessionAgentLifecycle(pi) {
-    onCursorSessionScopeKeyChange(async (previousScopeKey) => {
+    let scopeKey;
+    pi.on("session_start", (_event, ctx) => { scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager); });
+    onCursorSessionScopeKeyChange(pi, async (previousScopeKey) => {
         await disposeSessionCursorAgent(previousScopeKey);
     });
     pi.on("session_shutdown", async (event) => {
         try {
+            if (scopeKey === undefined)
+                return;
             if (event.reason === "reload") {
-                await resetSessionCursorAgent();
+                await resetSessionCursorAgent(scopeKey);
                 return;
             }
-            await disposeSessionCursorAgent();
+            await disposeSessionCursorAgent(scopeKey);
         }
         finally {
-            clearCursorSdkHttp1();
+            if (!hasLiveCursorSessions())
+                clearCursorSdkHttp1();
         }
     });
     pi.on("session_compact", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
     pi.on("session_before_tree", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
     pi.on("session_tree", async () => {
-        await resetSessionCursorAgent();
+        if (scopeKey !== undefined)
+            await resetSessionCursorAgent(scopeKey);
     });
     pi.on("model_select", () => {
-        invalidateSessionAgent();
+        if (scopeKey !== undefined)
+            invalidateSessionAgent(scopeKey);
     });
 }

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(); },
 };