pi-cursor-sdk 0.1.56 → 0.1.57

package/src/cursor-sdk-process-error-guard.ts

@@ -1,22 +1,36 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { classifyCursorConnectError, isCursorSdkAbortConnectError } from "./cursor-provider-errors.js";
 
 interface CursorSdkProcessErrorGuardToken {
 	suppressAbortErrors: boolean;
 }
 
+interface CursorSdkSessionProcessErrorGuardToken {}
+
 export interface CursorSdkProcessErrorGuard {
 	suppressAbortErrors(): void;
 	dispose(): void;
 }
 
+export interface CursorSdkSessionProcessErrorGuard {
+	dispose(): void;
+}
+
 type GenericProcessEmit = (event: string | symbol, ...args: unknown[]) => boolean;
 
-// The local Cursor SDK can surface some ConnectRPC failures as process-level
-// uncaught exceptions/unhandled rejections even when run.wait()/run.cancel() is awaited.
-// Keep suppression scoped to active Cursor provider turns and tightly matched ConnectRPC shapes.
+// 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<CursorSdkProcessErrorGuardToken>();
+const activeSessions = new Set<CursorSdkSessionProcessErrorGuardToken>();
+let activeLifecycleSessionGuard: CursorSdkSessionProcessErrorGuard | undefined;
 let originalProcessEmit: GenericProcessEmit | undefined;
-let captureCallbackInstalled = false;
+let cursorProcessEmit: GenericProcessEmit | undefined;
+let bunUnhandledRejectionListenerInstalled = false;
+
+function hasActiveGuard(): boolean {
+	return activeProviderTurns.size > 0 || activeSessions.size > 0;
+}
 
 function hasActiveAbortSuppression(): boolean {
 	for (const turn of activeProviderTurns) {
@@ -29,63 +43,94 @@ function isCursorProvenance(source: string): boolean {
 	return source === "cursor-sdk-stack" || source === "cursor-extension-connect-stack" || source === "cursor-backend-details";
 }
 
+function isCursorSdkWriteIterableClosedError(error: unknown): boolean {
+	return (
+		error instanceof Error &&
+		error.name === "WriteIterableClosedError" &&
+		error.message === "WritableIterable is closed" &&
+		/(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(error.stack ?? "")
+	);
+}
+
 function shouldSuppressProcessError(event: string | symbol, args: readonly unknown[]): boolean {
 	if (event !== "uncaughtException" && event !== "unhandledRejection") return false;
 	const error = args[0];
+	if (isCursorSdkWriteIterableClosedError(error)) return activeSessions.size > 0;
 	const classification = classifyCursorConnectError(error);
 	if (!classification) return false;
 	if (classification.kind === "abort") return hasActiveAbortSuppression();
 	if (activeProviderTurns.size === 0) return false;
-	// pi's supported Cursor SDK runtime is Node, where the SDK uses connect-node.
 	if (classification.kind === "network") return isCursorProvenance(classification.source) || classification.source === "connect-node-stack";
 	return isCursorProvenance(classification.source);
 }
 
 function installProcessEmitPatch(): void {
-	if (originalProcessEmit) return;
-	originalProcessEmit = process.emit.bind(process) as GenericProcessEmit;
-	process.emit = function patchedCursorSdkProcessErrorEmit(this: NodeJS.Process, event: string | symbol, ...args: unknown[]): boolean {
+	if (cursorProcessEmit) {
+		if (process.emit === cursorProcessEmit) return;
+		if (process.emit !== originalProcessEmit) return;
+		cursorProcessEmit = undefined;
+		originalProcessEmit = undefined;
+	}
+	const forwardEmit = process.emit as GenericProcessEmit;
+	originalProcessEmit = forwardEmit;
+	cursorProcessEmit = function patchedCursorSdkProcessErrorEmit(this: NodeJS.Process, event: string | symbol, ...args: unknown[]): boolean {
 		if (shouldSuppressProcessError(event, args)) return true;
-		return originalProcessEmit!(event, ...args);
-	} as typeof process.emit;
+		return forwardEmit.call(this, event, ...args);
+	};
+	process.emit = cursorProcessEmit as typeof process.emit;
 }
 
-function installCaptureCallbackIfAvailable(): void {
-	if (captureCallbackInstalled || process.hasUncaughtExceptionCaptureCallback()) return;
-	process.setUncaughtExceptionCaptureCallback((error: Error) => {
-		if (shouldSuppressProcessError("uncaughtException", [error])) return;
-		uninstallCaptureCallbackIfIdle(true);
-		if (originalProcessEmit?.("uncaughtException", error)) return;
-		throw error;
-	});
-	captureCallbackInstalled = true;
+function isBunRuntime(): boolean {
+	return typeof (process.versions as { bun?: string }).bun === "string";
+}
+
+function handleBunUnhandledRejection(error: unknown): void {
+	if (shouldSuppressProcessError("unhandledRejection", [error])) return;
+	// Without another rejection listener, retain Bun's default fatal behavior.
+	if (process.listenerCount("unhandledRejection") === 1) throw error;
+}
+
+function installBunUnhandledRejectionListener(): void {
+	if (!isBunRuntime() || bunUnhandledRejectionListenerInstalled) return;
+	process.prependListener("unhandledRejection", handleBunUnhandledRejection);
+	bunUnhandledRejectionListenerInstalled = true;
 }
 
-function uninstallCaptureCallbackIfIdle(force = false): void {
-	if (!captureCallbackInstalled) return;
-	if (!force && activeProviderTurns.size > 0) return;
-	process.setUncaughtExceptionCaptureCallback(null);
-	captureCallbackInstalled = false;
+function uninstallBunUnhandledRejectionListenerIfIdle(): void {
+	if (hasActiveGuard() || !bunUnhandledRejectionListenerInstalled) return;
+	process.off("unhandledRejection", handleBunUnhandledRejection);
+	bunUnhandledRejectionListenerInstalled = false;
 }
 
-function uninstallProcessEmitPatchIfIdle(): void {
-	if (activeProviderTurns.size > 0 || !originalProcessEmit) return;
-	uninstallCaptureCallbackIfIdle();
+function uninstallProcessHooksIfIdle(): void {
+	if (hasActiveGuard()) return;
+	uninstallBunUnhandledRejectionListenerIfIdle();
+	if (!originalProcessEmit || !cursorProcessEmit || process.emit !== cursorProcessEmit) return;
 	process.emit = originalProcessEmit as typeof process.emit;
 	originalProcessEmit = undefined;
+	cursorProcessEmit = undefined;
+}
+
+function installProcessHooks(): void {
+	installProcessEmitPatch();
+	installBunUnhandledRejectionListener();
 }
 
 export const __testUtils = {
 	activeProviderTurnCount: (): number => activeProviderTurns.size,
+	activeSessionCount: (): number => activeSessions.size,
+	resetLifecycleSessionGuard(): void {
+		activeLifecycleSessionGuard?.dispose();
+		activeLifecycleSessionGuard = undefined;
+	},
 };
 
 export { isCursorSdkAbortConnectError };
 
 export function installCursorSdkProcessErrorGuard(): CursorSdkProcessErrorGuard {
-	installProcessEmitPatch();
-	installCaptureCallbackIfAvailable();
 	const token: CursorSdkProcessErrorGuardToken = { suppressAbortErrors: false };
 	activeProviderTurns.add(token);
+	installProcessHooks();
 	let disposed = false;
 	return {
 		suppressAbortErrors(): void {
@@ -96,7 +141,33 @@ export function installCursorSdkProcessErrorGuard(): CursorSdkProcessErrorGuard
 			if (disposed) return;
 			disposed = true;
 			activeProviderTurns.delete(token);
-			uninstallProcessEmitPatchIfIdle();
+			uninstallProcessHooksIfIdle();
+		},
+	};
+}
+
+export function installCursorSdkSessionProcessErrorGuard(): CursorSdkSessionProcessErrorGuard {
+	const token: CursorSdkSessionProcessErrorGuardToken = {};
+	activeSessions.add(token);
+	installProcessHooks();
+	let disposed = false;
+	return {
+		dispose(): void {
+			if (disposed) return;
+			disposed = true;
+			activeSessions.delete(token);
+			uninstallProcessHooksIfIdle();
 		},
 	};
 }
+
+export function registerCursorSdkSessionProcessErrorGuard(pi: Pick<ExtensionAPI, "on">): void {
+	pi.on("session_start", () => {
+		activeLifecycleSessionGuard?.dispose();
+		activeLifecycleSessionGuard = installCursorSdkSessionProcessErrorGuard();
+	});
+	pi.on("session_shutdown", () => {
+		activeLifecycleSessionGuard?.dispose();
+		activeLifecycleSessionGuard = undefined;
+	});
+}

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

@@ -0,0 +1,328 @@
+import type { ExtensionAPI, ExtensionCommandContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+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,
+	type CursorSessionAgentResumeEntryData,
+	type CursorSessionAgentResumeScope,
+} from "./cursor-session-agent-resume.js";
+
+export const CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE = "cursor-sdk-agent-cleanup";
+
+type CleanupAction = "dry-run" | "delete";
+type CleanupPhase = "intent" | "result";
+
+export interface CursorSessionAgentCleanupFailure {
+	agentId: string;
+	error: string;
+}
+
+export interface CursorSessionAgentCleanupEntryData {
+	action: CleanupAction;
+	phase?: CleanupPhase;
+	runtime: "local";
+	timestamp: string;
+	candidateAgentIds: string[];
+	protectedAgentIds?: string[];
+	deletedAgentIds?: string[];
+	failedAgentIds?: CursorSessionAgentCleanupFailure[];
+}
+
+export interface CursorSessionAgentCleanupPlan {
+	candidateAgentIds: string[];
+	protectedAgentIds: string[];
+}
+
+export type CursorSessionAgentCleanupScope = CursorSessionAgentResumeScope;
+
+type LocalResumeCleanupApi = Pick<ExtensionAPI, "appendEntry">;
+type LocalResumeCleanupCommandContext = Pick<ExtensionCommandContext, "cwd"> & {
+	sessionManager: Pick<ExtensionCommandContext["sessionManager"], "getEntries" | "getBranch" | "getSessionFile" | "getSessionId">;
+	ui: Pick<ExtensionCommandContext["ui"], "notify">;
+};
+type LocalResumeCleanupSdkOperations = {
+	delete(agentId: string, options?: { cwd?: string }): Promise<void>;
+};
+
+// 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<string>();
+let appendDurabilityForTests: ((data: CursorSessionAgentCleanupEntryData) => boolean) | undefined;
+let sdkOperationsForTests: LocalResumeCleanupSdkOperations | undefined;
+
+function uniqueSorted(values: Iterable<string>): string[] {
+	return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+
+function readResumeEntries(entries: readonly SessionEntry[]): CursorSessionAgentResumeEntryData[] {
+	const records: CursorSessionAgentResumeEntryData[] = [];
+	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: CursorSessionAgentResumeEntryData, scope: CursorSessionAgentCleanupScope): boolean {
+	return data.scopeKey === scope.scopeKey &&
+		data.sessionFile === scope.sessionFile &&
+		data.sessionId === scope.sessionId &&
+		data.cwd === scope.cwd &&
+		data.repoRoot === scope.repoRoot;
+}
+
+function getCurrentCleanupScope(ctx: LocalResumeCleanupCommandContext): CursorSessionAgentCleanupScope {
+	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: unknown): CursorSessionAgentCleanupEntryData | undefined {
+	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): id is string => typeof id === "string") : [];
+	const protectedAgentIds = Array.isArray(record.protectedAgentIds) ? record.protectedAgentIds.filter((id): id is string => typeof id === "string") : undefined;
+	const deletedAgentIds = Array.isArray(record.deletedAgentIds) ? record.deletedAgentIds.filter((id): id is string => typeof id === "string") : undefined;
+	const failedAgentIds = Array.isArray(record.failedAgentIds)
+		? record.failedAgentIds.flatMap((item): CursorSessionAgentCleanupFailure[] => {
+			const failure = asRecord(item);
+			return isCursorLocalAgentId(failure?.agentId) && typeof failure.error === "string" ? [{ agentId: failure.agentId, error: failure.error }] : [];
+		})
+		: 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: readonly SessionEntry[]): Set<string> {
+	const deleted = new Set<string>();
+	const pending = new Set<string>();
+	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 { agentId } of data.failedAgentIds ?? []) pending.delete(agentId);
+		}
+	}
+	return new Set([...deleted, ...pending, ...nondurableCleanupResultAgentIds]);
+}
+
+function readLatestBranchAgentId(branch: readonly SessionEntry[], scope: CursorSessionAgentCleanupScope): string | undefined {
+	return readResumeEntries(branch).filter((entry) => resumeEntryMatchesCleanupScope(entry, scope)).at(-1)?.agentId;
+}
+
+export function readCursorSessionAgentCleanupPlan(
+	entries: readonly SessionEntry[],
+	branch: readonly SessionEntry[],
+	scope: CursorSessionAgentCleanupScope,
+): CursorSessionAgentCleanupPlan {
+	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 Set<string>();
+	for (const resume of readResumeEntries(entries)) {
+		if (!resumeEntryMatchesCleanupScope(resume, scope)) continue;
+		for (const agentId of resume.cleanupCandidateAgentIds ?? []) {
+			if (!isCursorLocalAgentId(agentId) || protectedAgentIds.has(agentId) || unavailable.has(agentId)) continue;
+			candidates.add(agentId);
+		}
+	}
+	return {
+		candidateAgentIds: uniqueSorted(candidates),
+		protectedAgentIds: uniqueSorted(protectedAgentIds),
+	};
+}
+
+function formatCleanupPlan(plan: CursorSessionAgentCleanupPlan): string {
+	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(): Promise<LocalResumeCleanupSdkOperations> {
+	if (sdkOperationsForTests) return sdkOperationsForTests;
+	const { Agent } = await loadCursorSdk();
+	return {
+		delete: (agentId, options) => Agent.delete(agentId, options),
+	};
+}
+
+function cleanupEntryVerificationKey(data: CursorSessionAgentCleanupEntryData): string {
+	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: CursorSessionAgentCleanupEntryData, right: CursorSessionAgentCleanupEntryData): boolean {
+	return cleanupEntryVerificationKey(left) === cleanupEntryVerificationKey(right);
+}
+
+function appendCleanupEntry(pi: LocalResumeCleanupApi, data: CursorSessionAgentCleanupEntryData): void {
+	pi.appendEntry<CursorSessionAgentCleanupEntryData>(CURSOR_SESSION_AGENT_CLEANUP_ENTRY_TYPE, data);
+}
+
+function appendDurableCleanupEntry(
+	pi: LocalResumeCleanupApi,
+	ctx: LocalResumeCleanupCommandContext,
+	data: CursorSessionAgentCleanupEntryData,
+): boolean {
+	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: LocalResumeCleanupApi, args: string, ctx: LocalResumeCleanupCommandContext): Promise<void> {
+	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 plan = readCursorSessionAgentCleanupPlan(entries, branch, getCurrentCleanupScope(ctx));
+	const baseEntry = {
+		runtime: "local" as const,
+		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: string[] = [];
+	const failedAgentIds: CursorSessionAgentCleanupFailure[] = [];
+	try {
+		const operations = await getSdkOperations();
+		for (const agentId of plan.candidateAgentIds) {
+			try {
+				await operations.delete(agentId, { cwd: ctx.cwd });
+				deletedAgentIds.push(agentId);
+			} catch (error) {
+				failedAgentIds.push({ agentId, error: scrubSensitiveText(getString(asRecord(error), "message") ?? String(error)) });
+			}
+		}
+	} catch (error) {
+		const message = scrubSensitiveText(getString(asRecord(error), "message") ?? String(error));
+		failedAgentIds.push(...plan.candidateAgentIds.map((agentId) => ({ agentId, error: message })));
+	}
+	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: ((data: CursorSessionAgentCleanupEntryData) => boolean) | undefined) => {
+		appendDurabilityForTests = appendDurability;
+	},
+	setSdkOperations: (operations: LocalResumeCleanupSdkOperations | undefined) => {
+		sdkOperationsForTests = operations;
+	},
+	parseCleanupEntryData,
+};