pi-cursor-sdk 0.1.62 → 0.3.6

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

@@ -0,0 +1,221 @@
+import { classifyCursorConnectError, isCursorSdkAbortConnectError, isCursorSdkConnectionStalledError } from "./cursor-provider-errors.js";
+// Cursor SDK controlled-exec tasks can reject after their originating provider turn
+// has ended. The exact closed-writable failure is therefore session-scoped; existing
+// ConnectRPC suppression remains scoped to active provider turns.
+const activeProviderTurns = new Set();
+const activeSessions = new Set();
+let activeLifecycleSessionGuard;
+let originalProcessEmit;
+let cursorProcessEmit;
+let bunUnhandledRejectionListenerInstalled = false;
+function hasActiveGuard() {
+    return activeProviderTurns.size > 0 || activeSessions.size > 0;
+}
+function hasActiveAbortSuppression() {
+    for (const turn of activeProviderTurns) {
+        if (turn.suppressAbortErrors)
+            return true;
+    }
+    return false;
+}
+function isCursorProvenance(source) {
+    return source === "cursor-sdk-stack" || source === "cursor-extension-connect-stack" || source === "cursor-backend-details";
+}
+function isCursorSdkWriteIterableClosedError(error) {
+    return (error instanceof Error &&
+        error.name === "WriteIterableClosedError" &&
+        error.message === "WritableIterable is closed" &&
+        /(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(error.stack ?? ""));
+}
+// The Cursor SDK aborts an in-flight controlled-exec turn via its internal
+// `AbortController.abort()` (user interrupt or stall-detector cancellation),
+// which surfaces as a raw `DOMException [AbortError]` rather than a
+// `ConnectError`. `classifyCursorConnectError` returns undefined for it, so it
+// otherwise falls through the emit patch and terminates the process. A
+// DOMException is not `instanceof Error`, so match structurally on the
+// `AbortError` name plus the same `@cursor/sdk/dist` stack provenance the
+// WriteIterableClosedError recognizer uses, keeping unrelated AbortErrors fatal.
+function isCursorSdkAbortError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const { name, stack } = error;
+    return (name === "AbortError" &&
+        typeof stack === "string" &&
+        /(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(stack));
+}
+// The exact observed incident: the Cursor SDK 1.0.23 local shell executor writes a
+// spawned child's stdin without a stream 'error' listener, so a child exiting while
+// a write is in flight surfaces a raw `write EPIPE` uncaught exception whose stack
+// is exactly the single async pipe-write completion frame. Installed 1.0.27 attaches
+// a no-op `error` listener before that write; keep this guard as defense in depth.
+// Pi's own piped-stdout or dead-terminal EPIPE normally surfaces through the
+// synchronous write-dispatch path with multiple frames (afterWriteDispatched /
+// Socket._writeGeneric) and must stay fatal per Unix convention, so anything beyond
+// this one-frame contract is rejected.
+const OBSERVED_CLOSED_PIPE_STACK_FRAME = /^\s+at WriteWrap\.onWriteComplete \[as oncomplete\] \(node:internal\/stream_base_commons:\d+:\d+\)$/;
+function isObservedLocalTransportClosedPipeWriteError(error) {
+    if (!(error instanceof Error) || error.name !== "Error")
+        return false;
+    const { code, syscall } = error;
+    if (code !== "EPIPE" || syscall !== "write" || !error.message.startsWith("write EPIPE"))
+        return false;
+    const frames = (error.stack ?? "").split("\n").filter((line) => /^\s+at /.test(line));
+    return frames.length === 1 && OBSERVED_CLOSED_PIPE_STACK_FRAME.test(frames[0] ?? "");
+}
+// Contained only while a provider turn that declared a local transport is active;
+// each contained turn invalidates its own session-agent scope for recreation.
+function containLocalTransportClosedPipeError() {
+    let contained = false;
+    for (const turn of [...activeProviderTurns]) {
+        if (!turn.onLocalTransportClosedPipe)
+            continue;
+        contained = true;
+        try {
+            turn.onLocalTransportClosedPipe();
+        }
+        catch {
+            // stale-agent invalidation must not throw inside process error handling
+        }
+    }
+    return contained;
+}
+function shouldSuppressProcessError(event, args) {
+    if (event !== "uncaughtException" && event !== "unhandledRejection")
+        return false;
+    const error = args[0];
+    if (isObservedLocalTransportClosedPipeWriteError(error)) {
+        return containLocalTransportClosedPipeError();
+    }
+    if (isCursorSdkWriteIterableClosedError(error))
+        return activeSessions.size > 0;
+    // SDK stall timers and inter-turn teardown aborts never call suppressAbortErrors();
+    // any active provider turn or session is enough — stack provenance already gates SDK-only AbortErrors.
+    if (isCursorSdkAbortError(error))
+        return hasActiveGuard();
+    // RetriableError "Connection stalled" / "Connection stalled repeatedly" is not a ConnectError; suppress during active turns only.
+    if (isCursorSdkConnectionStalledError(error))
+        return activeProviderTurns.size > 0;
+    const classification = classifyCursorConnectError(error);
+    if (!classification)
+        return false;
+    if (classification.kind === "abort")
+        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() {
+    if (cursorProcessEmit) {
+        if (process.emit === cursorProcessEmit)
+            return;
+        if (process.emit !== originalProcessEmit)
+            return;
+        cursorProcessEmit = undefined;
+        originalProcessEmit = undefined;
+    }
+    const forwardEmit = process.emit;
+    originalProcessEmit = forwardEmit;
+    cursorProcessEmit = function patchedCursorSdkProcessErrorEmit(event, ...args) {
+        if (shouldSuppressProcessError(event, args))
+            return true;
+        return forwardEmit.call(this, event, ...args);
+    };
+    process.emit = cursorProcessEmit;
+}
+function isBunRuntime() {
+    return typeof process.versions.bun === "string";
+}
+function handleBunUnhandledRejection(error) {
+    if (shouldSuppressProcessError("unhandledRejection", [error]))
+        return;
+    // Without another rejection listener, retain Bun's default fatal behavior.
+    if (process.listenerCount("unhandledRejection") === 1)
+        throw error;
+}
+function installBunUnhandledRejectionListener() {
+    if (!isBunRuntime() || bunUnhandledRejectionListenerInstalled)
+        return;
+    process.prependListener("unhandledRejection", handleBunUnhandledRejection);
+    bunUnhandledRejectionListenerInstalled = true;
+}
+function uninstallBunUnhandledRejectionListenerIfIdle() {
+    if (hasActiveGuard() || !bunUnhandledRejectionListenerInstalled)
+        return;
+    process.off("unhandledRejection", handleBunUnhandledRejection);
+    bunUnhandledRejectionListenerInstalled = false;
+}
+function uninstallProcessHooksIfIdle() {
+    if (hasActiveGuard())
+        return;
+    uninstallBunUnhandledRejectionListenerIfIdle();
+    if (!originalProcessEmit || !cursorProcessEmit || process.emit !== cursorProcessEmit)
+        return;
+    process.emit = originalProcessEmit;
+    originalProcessEmit = undefined;
+    cursorProcessEmit = undefined;
+}
+function installProcessHooks() {
+    installProcessEmitPatch();
+    installBunUnhandledRejectionListener();
+}
+export const __testUtils = {
+    activeProviderTurnCount: () => activeProviderTurns.size,
+    activeSessionCount: () => activeSessions.size,
+    resetLifecycleSessionGuard() {
+        activeLifecycleSessionGuard?.dispose();
+        activeLifecycleSessionGuard = undefined;
+    },
+};
+export { isCursorSdkAbortConnectError };
+export function installCursorSdkProcessErrorGuard() {
+    const token = { suppressAbortErrors: false };
+    activeProviderTurns.add(token);
+    installProcessHooks();
+    let disposed = false;
+    return {
+        suppressAbortErrors() {
+            if (disposed)
+                return;
+            token.suppressAbortErrors = true;
+        },
+        containLocalTransportClosedPipe(onClosedPipe) {
+            if (disposed)
+                return;
+            token.onLocalTransportClosedPipe = onClosedPipe;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            activeProviderTurns.delete(token);
+            uninstallProcessHooksIfIdle();
+        },
+    };
+}
+export function installCursorSdkSessionProcessErrorGuard() {
+    const token = {};
+    activeSessions.add(token);
+    installProcessHooks();
+    let disposed = false;
+    return {
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            activeSessions.delete(token);
+            uninstallProcessHooksIfIdle();
+        },
+    };
+}
+export function registerCursorSdkSessionProcessErrorGuard(pi) {
+    pi.on("session_start", () => {
+        activeLifecycleSessionGuard?.dispose();
+        activeLifecycleSessionGuard = installCursorSdkSessionProcessErrorGuard();
+    });
+    pi.on("session_shutdown", () => {
+        activeLifecycleSessionGuard?.dispose();
+        activeLifecycleSessionGuard = undefined;
+    });
+}

package/dist/cursor-sdk-runtime.js

@@ -0,0 +1,3 @@
+export async function loadCursorSdk() {
+    return import("@cursor/sdk");
+}

package/dist/cursor-sensitive-text.js

@@ -0,0 +1,23 @@
+import { asRecord } from "./cursor-record-utils.js";
+/** Provider-facing wrapper; canonical scrubbing lives in shared/cursor-sensitive-text.mjs. */
+import { scrubSensitiveText as scrubSensitiveTextJs } from "../shared/cursor-sensitive-text.mjs";
+export function scrubSensitiveText(text, apiKey) {
+    return scrubSensitiveTextJs(text, apiKey);
+}
+function scrubDisplayValue(value, apiKey) {
+    if (typeof value === "string")
+        return scrubSensitiveText(value, apiKey);
+    if (Array.isArray(value))
+        return value.map((entry) => scrubDisplayValue(entry, apiKey));
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => [key, scrubDisplayValue(entry, apiKey)]));
+}
+export function scrubPiToolDisplay(display, apiKey) {
+    return {
+        ...display,
+        args: scrubDisplayValue(display.args, apiKey),
+        result: scrubDisplayValue(display.result, apiKey),
+    };
+}

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

@@ -0,0 +1,311 @@
+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 { 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";
+export const CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE = "cursor-sdk-agent-cleanup";
+class InvalidCursorSessionStoreIdentityError extends Error {
+}
+// ponytail: grows for the process lifetime, but its ceiling is the exact agent IDs this process
+// attempted to delete (never global) — it only fills the gap until this process exits; the durable
+// intent entry, not this Set, is the authority a restarted process relies on to block retries.
+// Tests must call __testUtils.reset() between cases.
+const nondurableCleanupResultAgentIds = new Set();
+let appendDurabilityForTests;
+let sdkOperationsForTests;
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function readResumeEntries(entries) {
+    const records = [];
+    for (const entry of entries) {
+        if (entry.type !== "custom" || entry.customType !== CURSOR_SESSION_AGENT_RESUME_ENTRY_TYPE)
+            continue;
+        const data = parseCursorSessionAgentResumeEntryData(entry.data);
+        if (data)
+            records.push(data);
+    }
+    return records;
+}
+function resumeEntryMatchesCleanupScope(data, scope) {
+    return data.scopeKey === scope.scopeKey &&
+        data.sessionFile === scope.sessionFile &&
+        data.sessionId === scope.sessionId &&
+        data.cwd === scope.cwd &&
+        data.repoRoot === scope.repoRoot;
+}
+function getCurrentCleanupScope(ctx) {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    const sessionId = ctx.sessionManager.getSessionId();
+    const repoRoot = resolveCursorSessionRepoRoot(ctx.cwd);
+    return {
+        scopeKey: getCursorSessionScopeKey(),
+        ...(sessionFile ? { sessionFile } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        cwd: ctx.cwd,
+        ...(repoRoot ? { repoRoot } : {}),
+    };
+}
+function parseCleanupEntryData(value) {
+    const record = asRecord(value);
+    if (!record || (record.action !== "dry-run" && record.action !== "delete") || record.runtime !== "local")
+        return undefined;
+    if (typeof record.timestamp !== "string")
+        return undefined;
+    if (record.phase !== undefined && record.phase !== "intent" && record.phase !== "result")
+        return undefined;
+    if (record.action === "dry-run" && record.phase !== undefined)
+        return undefined;
+    const candidateAgentIds = Array.isArray(record.candidateAgentIds) ? record.candidateAgentIds.filter((id) => typeof id === "string") : [];
+    const protectedAgentIds = Array.isArray(record.protectedAgentIds) ? record.protectedAgentIds.filter((id) => typeof id === "string") : undefined;
+    const deletedAgentIds = Array.isArray(record.deletedAgentIds) ? record.deletedAgentIds.filter((id) => typeof id === "string") : undefined;
+    const failedAgentIds = Array.isArray(record.failedAgentIds)
+        ? record.failedAgentIds.flatMap((item) => {
+            const failure = asRecord(item);
+            return isCursorLocalAgentId(failure?.agentId) && typeof failure.error === "string"
+                ? [{ agentId: failure.agentId, error: failure.error, ...(failure.retryable === false ? { retryable: false } : {}) }]
+                : [];
+        })
+        : undefined;
+    return {
+        action: record.action,
+        ...(record.phase ? { phase: record.phase } : {}),
+        runtime: "local",
+        timestamp: record.timestamp,
+        candidateAgentIds: uniqueSorted(candidateAgentIds.filter(isCursorLocalAgentId)),
+        ...(protectedAgentIds?.length ? { protectedAgentIds: uniqueSorted(protectedAgentIds.filter(isCursorLocalAgentId)) } : {}),
+        ...(deletedAgentIds?.length ? { deletedAgentIds: uniqueSorted(deletedAgentIds.filter(isCursorLocalAgentId)) } : {}),
+        ...(failedAgentIds?.length ? { failedAgentIds } : {}),
+    };
+}
+function readUnavailableAgentIds(entries) {
+    const deleted = new Set();
+    const pending = new Set();
+    const permanentlyFailed = new Set();
+    for (const entry of entries) {
+        if (entry.type !== "custom" || entry.customType !== CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE)
+            continue;
+        const data = parseCleanupEntryData(entry.data);
+        if (data?.action !== "delete")
+            continue;
+        if (data.phase === "intent") {
+            for (const agentId of data.candidateAgentIds) {
+                if (!deleted.has(agentId))
+                    pending.add(agentId);
+            }
+            continue;
+        }
+        for (const agentId of data.deletedAgentIds ?? []) {
+            deleted.add(agentId);
+            pending.delete(agentId);
+        }
+        if (data.phase === "result") {
+            for (const failure of data.failedAgentIds ?? []) {
+                pending.delete(failure.agentId);
+                if (failure.retryable === false)
+                    permanentlyFailed.add(failure.agentId);
+            }
+        }
+    }
+    return new Set([...deleted, ...pending, ...permanentlyFailed, ...nondurableCleanupResultAgentIds]);
+}
+function readLatestBranchAgentId(branch, scope) {
+    return readResumeEntries(branch).filter((entry) => resumeEntryMatchesCleanupScope(entry, scope)).at(-1)?.agentId;
+}
+function readCursorSessionAgentCleanupPlanDetails(entries, branch, scope) {
+    const unavailable = readUnavailableAgentIds(entries);
+    const latestBranchAgentId = readLatestBranchAgentId(branch, scope);
+    const protectedAgentIds = new Set(readResumableCursorSessionAgentIds(entries, scope));
+    if (latestBranchAgentId && isCursorLocalAgentId(latestBranchAgentId))
+        protectedAgentIds.add(latestBranchAgentId);
+    const candidates = new Map();
+    for (const resume of readResumeEntries(entries)) {
+        if (!resumeEntryMatchesCleanupScope(resume, scope))
+            continue;
+        const recordedCandidates = [
+            ...(resume.cleanupCandidateAgentIds ?? []).map((agentId) => ({ agentId })),
+            ...(resume.cleanupCandidates ?? []),
+        ];
+        for (const candidate of recordedCandidates) {
+            if (!isCursorLocalAgentId(candidate.agentId) || protectedAgentIds.has(candidate.agentId) || unavailable.has(candidate.agentId))
+                continue;
+            const existing = candidates.get(candidate.agentId);
+            if (!existing?.storeIdentity || candidate.storeIdentity)
+                candidates.set(candidate.agentId, candidate);
+        }
+    }
+    return {
+        candidates: [...candidates.values()].sort((left, right) => left.agentId.localeCompare(right.agentId)),
+        candidateAgentIds: uniqueSorted([...candidates.values()].map((candidate) => candidate.agentId)),
+        protectedAgentIds: uniqueSorted(protectedAgentIds),
+    };
+}
+export function readCursorSessionAgentCleanupPlan(entries, branch, scope) {
+    const { candidates: _, ...plan } = readCursorSessionAgentCleanupPlanDetails(entries, branch, scope);
+    return plan;
+}
+function formatCleanupPlan(plan) {
+    if (plan.candidateAgentIds.length === 0)
+        return "No recorded superseded local Cursor SDK agents are cleanup-eligible.";
+    return [
+        "Recorded superseded local Cursor SDK agents eligible for cleanup:",
+        ...plan.candidateAgentIds.map((agentId) => `- ${agentId}`),
+        "Run /cursor-local-resume-cleanup --yes to delete exactly these recorded agent IDs.",
+    ].join("\n");
+}
+async function getSdkOperations() {
+    if (sdkOperationsForTests)
+        return sdkOperationsForTests;
+    const { Agent } = await loadCursorSdk();
+    return {
+        delete: (agentId, options) => Agent.delete(agentId, options),
+    };
+}
+function cleanupEntryVerificationKey(data) {
+    return JSON.stringify({
+        action: data.action,
+        phase: data.phase,
+        runtime: data.runtime,
+        timestamp: data.timestamp,
+        candidateAgentIds: data.candidateAgentIds,
+        protectedAgentIds: data.protectedAgentIds ?? [],
+        deletedAgentIds: data.deletedAgentIds ?? [],
+        failedAgentIds: data.failedAgentIds ?? [],
+    });
+}
+function cleanupEntriesMatch(left, right) {
+    return cleanupEntryVerificationKey(left) === cleanupEntryVerificationKey(right);
+}
+function appendCleanupEntry(pi, data) {
+    pi.appendEntry(CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE, data);
+}
+function appendDurableCleanupEntry(pi, ctx, data) {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    const previousEntryId = ctx.sessionManager.getBranch().at(-1)?.id;
+    try {
+        appendCleanupEntry(pi, data);
+    }
+    catch {
+        return false;
+    }
+    if (appendDurabilityForTests)
+        return appendDurabilityForTests(data);
+    const anchor = ctx.sessionManager.getBranch().at(-1);
+    const persisted = anchor?.type === "custom" &&
+        anchor.customType === CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE &&
+        anchor.id !== previousEntryId
+        ? parseCleanupEntryData(anchor.data)
+        : undefined;
+    if (!sessionFile || !persisted || !cleanupEntriesMatch(persisted, data))
+        return false;
+    return fsyncExistingRegularFile(sessionFile);
+}
+export async function runCursorSessionAgentCleanupCommand(pi, args, ctx) {
+    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");
+    const deleteNow = tokens.length === 1 && tokens[0] === "--yes";
+    if (!dryRun && !deleteNow) {
+        ctx.ui.notify(`Invalid Cursor local resume cleanup arguments. ${usage}`, "error");
+        return;
+    }
+    const entries = ctx.sessionManager.getEntries();
+    const branch = ctx.sessionManager.getBranch();
+    const scope = getCurrentCleanupScope(ctx);
+    const plan = readCursorSessionAgentCleanupPlanDetails(entries, branch, scope);
+    const baseEntry = {
+        runtime: "local",
+        timestamp: new Date().toISOString(),
+        candidateAgentIds: plan.candidateAgentIds,
+        ...(plan.protectedAgentIds.length ? { protectedAgentIds: plan.protectedAgentIds } : {}),
+    };
+    if (dryRun) {
+        appendCleanupEntry(pi, { action: "dry-run", ...baseEntry });
+        ctx.ui.notify(formatCleanupPlan(plan), "info");
+        return;
+    }
+    if (plan.candidateAgentIds.length === 0) {
+        try {
+            appendCleanupEntry(pi, { action: "delete", phase: "result", ...baseEntry, deletedAgentIds: [] });
+            ctx.ui.notify("No recorded superseded local Cursor SDK agents to delete.", "info");
+        }
+        catch {
+            ctx.ui.notify("No agents were deleted, but the no-op cleanup result could not be recorded.", "error");
+        }
+        return;
+    }
+    if (!appendDurableCleanupEntry(pi, ctx, { action: "delete", phase: "intent", ...baseEntry })) {
+        ctx.ui.notify("Cleanup intent could not be durably recorded. No agents were deleted.", "error");
+        return;
+    }
+    const deletedAgentIds = [];
+    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 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));
+        failedAgentIds.push(...plan.candidateAgentIds.map((agentId) => ({ agentId, error: message })));
+    }
+    finally {
+        await Promise.all([...openedStores.values()].map((store) => store.dispose().catch(() => undefined)));
+    }
+    if (!appendDurableCleanupEntry(pi, ctx, {
+        action: "delete",
+        phase: "result",
+        ...baseEntry,
+        deletedAgentIds,
+        ...(failedAgentIds.length ? { failedAgentIds } : {}),
+    })) {
+        for (const agentId of plan.candidateAgentIds)
+            nondurableCleanupResultAgentIds.add(agentId);
+        ctx.ui.notify(`Deleted ${deletedAgentIds.length} recorded local Cursor SDK agent(s). The cleanup ledger is partial because its result could not be durably recorded; the durable intent blocks automatic retries.`, "error");
+        return;
+    }
+    if (failedAgentIds.length > 0) {
+        ctx.ui.notify(`Deleted ${deletedAgentIds.length} recorded local Cursor SDK agent(s); ${failedAgentIds.length} failed.`, "error");
+        return;
+    }
+    ctx.ui.notify(`Deleted ${deletedAgentIds.length} recorded local Cursor SDK agent(s).`, "info");
+}
+export const __testUtils = {
+    reset: () => {
+        nondurableCleanupResultAgentIds.clear();
+        appendDurabilityForTests = undefined;
+        sdkOperationsForTests = undefined;
+    },
+    setAppendDurability: (appendDurability) => {
+        appendDurabilityForTests = appendDurability;
+    },
+    setSdkOperations: (operations) => {
+        sdkOperationsForTests = operations;
+    },
+    parseCleanupEntryData,
+};

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

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