pi-cursor-sdk 0.1.59 → 0.1.61

package/src/cursor-runtime-state.ts

@@ -7,6 +7,7 @@ import {
 	CURSOR_AUTO_REVIEW_ENV,
 	CURSOR_CLOUD_ACK_ENV,
 	CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV,
+	CURSOR_CLOUD_AUTO_CREATE_PR_ENV,
 	CURSOR_CLOUD_BRANCH_ENV,
 	CURSOR_CLOUD_CONTEXT_ENV,
 	CURSOR_CLOUD_DIRECT_PUSH_ENV,
@@ -15,19 +16,18 @@ import {
 	CURSOR_CLOUD_ENV_NAME_ENV,
 	CURSOR_CLOUD_ENV_TYPE_ENV,
 	CURSOR_CLOUD_REPO_ENV,
+	CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV,
 	CURSOR_LOCAL_FORCE_ENV,
 	CURSOR_LOCAL_RESUME_ENV,
 	CURSOR_RUNTIME_ENV,
 	CURSOR_SANDBOX_ENV,
+	getCursorSdkProjectConfigPath,
+	getCursorSdkUserConfigPath,
 	loadCursorSdkConfig,
-	loadCursorSdkProjectConfig,
-	loadCursorSdkUserConfig,
-	mergeCursorSdkConfig,
-	parseCursorSdkConfig,
+	mergeCursorSdkConfigForUpdate,
 	parseExplicitCursorCloudEnvNames,
 	resolveCursorSdkConfig,
-	saveCursorSdkProjectConfig,
-	saveCursorSdkUserConfig,
+	updateCursorSdkConfig,
 	type CursorExplicitSdkConfig,
 	type CursorResolvedSdkConfig,
 	type CursorResolvedSetting,
@@ -35,6 +35,8 @@ import {
 	type CursorSdkConfig,
 } from "./cursor-config.js";
 import { asRecord } from "./cursor-record-utils.js";
+import { getResolvedSessionCursorHttp1Enabled } from "./cursor-http1.js";
+import { getCursorSessionCwd, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
 
 export const CURSOR_RUNTIME_ENTRY_TYPE = "cursor-runtime-state";
 
@@ -57,28 +59,18 @@ export type CursorRuntimeStateExtensionApi = Pick<
 	"appendEntry" | "getFlag" | "registerFlag" | "registerCommand" | "on"
 >;
 
-type CursorRuntimeContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "isProjectTrusted">>;
+type CursorRuntimeContext = Pick<ExtensionContext, "cwd">;
 
 type CursorStatusRefresh = (ctx: ExtensionContext) => void;
 
-let cliAutoReview = false;
-let cliSandbox = false;
-let cliLocalForce = false;
+interface CursorCliConfigSnapshot {
+	config: CursorExplicitSdkConfig;
+	cloudEnvNames?: string;
+}
+
+let cliCursorSnapshot: CursorCliConfigSnapshot = { config: {} };
 let cliLocalForceConsumed = false;
-let cliLocalResume = false;
-let cliNoLocalResume = false;
 let envLocalForceConsumed = false;
-let cliCursorRuntime: string | undefined;
-let cliCursorCloudRepo: string | undefined;
-let cliCursorCloudBranch: string | undefined;
-let cliCursorCloudContext: string | undefined;
-let cliCursorCloudDirectPush = false;
-let cliCursorCloudAllowLocalState = false;
-let cliCursorCloudEnv: string | undefined;
-let cliCursorCloudEnvFromFiles = false;
-let cliCursorCloudEnvType: string | undefined;
-let cliCursorCloudEnvName: string | undefined;
-let cliCursorCloudAck = false;
 let sessionCursorRuntime: CursorRuntime | undefined;
 let sessionCursorCloudAcknowledged = false;
 
@@ -94,43 +86,23 @@ function stringFlagValue(value: boolean | string | undefined): string | undefine
 }
 
 export function getCursorCliConfig(): CursorExplicitSdkConfig {
-	const parsed = parseCursorSdkConfig({
-		cloud: {
-			repo: cliCursorCloudRepo,
-			branch: cliCursorCloudBranch,
-			...(cliCursorCloudDirectPush ? { directPush: true } : {}),
-			...(cliCursorCloudAllowLocalState ? { allowLocalState: true } : {}),
-			envNames: parseExplicitCursorCloudEnvNames(cliCursorCloudEnv, "--cursor-cloud-env"),
-			...(cliCursorCloudEnvFromFiles ? { envFromFiles: true } : {}),
-			environment: {
-				type: cliCursorCloudEnvType,
-				name: cliCursorCloudEnvName,
-			},
-			...(cliCursorCloudAck ? { acknowledged: true } : {}),
-		},
-		local: {
-			...(cliAutoReview ? { autoReview: true } : {}),
-			...(cliSandbox ? { sandboxOptions: { enabled: true } } : {}),
-			...(cliLocalForce ? { force: true } : {}),
-			...(cliNoLocalResume ? { resume: false } : cliLocalResume ? { resume: true } : {}),
-		},
-	}) ?? {};
-	return {
-		...parsed,
-		...(cliCursorRuntime ? { runtime: cliCursorRuntime } : {}),
-		...(cliCursorCloudContext
-			? { cloud: { ...parsed.cloud, contextHandoff: cliCursorCloudContext } }
-			: {}),
-	};
+	const config = structuredClone(cliCursorSnapshot.config);
+	const envNames = parseExplicitCursorCloudEnvNames(cliCursorSnapshot.cloudEnvNames, "--cursor-cloud-env");
+	if (envNames) config.cloud = { ...config.cloud, envNames };
+	return config;
 }
 
 export function getCursorSessionConfig(): CursorSdkConfig {
-	return sessionCursorRuntime
-		? {
-				runtime: sessionCursorRuntime,
-				...(sessionCursorCloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-			}
-		: {};
+	const useHttp1ForAgent = getResolvedSessionCursorHttp1Enabled();
+	return {
+		...(sessionCursorRuntime
+			? {
+					runtime: sessionCursorRuntime,
+					...(sessionCursorCloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
+				}
+			: {}),
+		...(useHttp1ForAgent === undefined ? {} : { local: { useHttp1ForAgent } }),
+	};
 }
 
 export function resolveEffectiveCursorConfig(options: {
@@ -147,16 +119,28 @@ export function resolveEffectiveCursorConfig(options: {
 }
 
 export function resolveEffectiveCursorConfigForContext(ctx: CursorRuntimeContext): CursorResolvedSdkConfig {
-	return resolveEffectiveCursorConfig({ cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted?.() === true });
+	return resolveEffectiveCursorConfig({
+		cwd: ctx.cwd,
+		projectTrusted: getCursorSessionCwd() === ctx.cwd && getCursorSessionProjectTrusted(),
+	});
 }
 
 export type CursorRuntimeResolution =
-	| { kind: "valid"; runtime: CursorResolvedSetting<CursorRuntime> }
+	| {
+			kind: "valid";
+			runtime: CursorResolvedSetting<CursorRuntime>;
+			useHttp1ForAgent: CursorResolvedSetting<boolean>;
+		}
 	| { kind: "invalid"; message: string };
 
 export function resolveCursorStatusRuntime(ctx: CursorRuntimeContext): CursorRuntimeResolution {
 	try {
-		return { kind: "valid", runtime: resolveEffectiveCursorConfigForContext(ctx).runtime };
+		const config = resolveEffectiveCursorConfigForContext(ctx);
+		return {
+			kind: "valid",
+			runtime: config.runtime,
+			useHttp1ForAgent: config.local.useHttp1ForAgent,
+		};
 	} catch (error) {
 		return { kind: "invalid", message: error instanceof Error ? error.message : String(error) };
 	}
@@ -173,8 +157,10 @@ export function formatCursorStatus(
 	runtime: CursorRuntime | "invalid",
 	fast: boolean | undefined,
 	mode: "agent" | "plan" | "invalid",
+	useHttp1ForAgent = false,
 ): string {
 	const parts = [`cursor:${runtime}`, fast === true ? "fast:on" : fast === false ? "fast:off" : "fast:n/a"];
+	if (runtime === "local" && useHttp1ForAgent) parts.push("http1");
 	if (mode === "invalid") parts.push("mode invalid");
 	else if (mode === "plan") parts.push("plan");
 	return parts.join(" · ");
@@ -183,7 +169,10 @@ export function formatCursorStatus(
 export function consumeCursorLocalForceOverride(resolved: { value: boolean; source: string }): boolean {
 	if (!resolved.value) return false;
 	if (resolved.source === "cli" && !cliLocalForceConsumed) {
-		cliLocalForce = false;
+		if (cliCursorSnapshot.config.local) {
+			const { force: _, ...local } = cliCursorSnapshot.config.local;
+			cliCursorSnapshot.config.local = local;
+		}
 		cliLocalForceConsumed = true;
 		return true;
 	}
@@ -207,22 +196,45 @@ export function restoreSessionCursorRuntimeState(branch: readonly SessionEntry[]
 }
 
 export function restoreCursorCliState(pi: Pick<ExtensionAPI, "getFlag">): void {
-	cliAutoReview = pi.getFlag("cursor-auto-review") === true;
-	cliSandbox = pi.getFlag("cursor-sandbox") === true;
-	cliLocalForce = !cliLocalForceConsumed && pi.getFlag("cursor-local-force") === true;
-	cliLocalResume = pi.getFlag("cursor-local-resume") === true;
-	cliNoLocalResume = pi.getFlag("cursor-no-local-resume") === true;
-	cliCursorRuntime = stringFlagValue(pi.getFlag("cursor-runtime"));
-	cliCursorCloudRepo = stringFlagValue(pi.getFlag("cursor-cloud-repo"));
-	cliCursorCloudBranch = stringFlagValue(pi.getFlag("cursor-cloud-branch"));
-	cliCursorCloudContext = stringFlagValue(pi.getFlag("cursor-cloud-context"));
-	cliCursorCloudDirectPush = pi.getFlag("cursor-cloud-direct-push") === true;
-	cliCursorCloudAllowLocalState = pi.getFlag("cursor-cloud-allow-local-state") === true;
-	cliCursorCloudEnv = stringFlagValue(pi.getFlag("cursor-cloud-env"));
-	cliCursorCloudEnvFromFiles = pi.getFlag("cursor-cloud-env-from-files") === true;
-	cliCursorCloudEnvType = stringFlagValue(pi.getFlag("cursor-cloud-env-type"));
-	cliCursorCloudEnvName = stringFlagValue(pi.getFlag("cursor-cloud-env-name"));
-	cliCursorCloudAck = pi.getFlag("cursor-cloud-ack") === true;
+	const runtime = stringFlagValue(pi.getFlag("cursor-runtime"));
+	const repo = stringFlagValue(pi.getFlag("cursor-cloud-repo"));
+	const branch = stringFlagValue(pi.getFlag("cursor-cloud-branch"));
+	const contextHandoff = stringFlagValue(pi.getFlag("cursor-cloud-context"));
+	const environmentType = stringFlagValue(pi.getFlag("cursor-cloud-env-type"));
+	const environmentName = stringFlagValue(pi.getFlag("cursor-cloud-env-name"));
+	const cloudEnvNames = stringFlagValue(pi.getFlag("cursor-cloud-env"));
+	const cloud: NonNullable<CursorExplicitSdkConfig["cloud"]> = {
+		...(repo ? { repo } : {}),
+		...(branch ? { branch } : {}),
+		...(contextHandoff ? { contextHandoff } : {}),
+		...(pi.getFlag("cursor-cloud-direct-push") === true ? { directPush: true } : {}),
+		...(pi.getFlag("cursor-cloud-auto-create-pr") === true ? { autoCreatePR: true } : {}),
+		...(pi.getFlag("cursor-cloud-skip-reviewer-request") === true ? { skipReviewerRequest: true } : {}),
+		...(pi.getFlag("cursor-cloud-allow-local-state") === true ? { allowLocalState: true } : {}),
+		...(pi.getFlag("cursor-cloud-env-from-files") === true ? { envFromFiles: true } : {}),
+		...(environmentType || environmentName
+			? { environment: { ...(environmentType ? { type: environmentType } : {}), ...(environmentName ? { name: environmentName } : {}) } }
+			: {}),
+		...(pi.getFlag("cursor-cloud-ack") === true ? { acknowledged: true } : {}),
+	};
+	const local: NonNullable<CursorExplicitSdkConfig["local"]> = {
+		...(pi.getFlag("cursor-auto-review") === true ? { autoReview: true } : {}),
+		...(pi.getFlag("cursor-sandbox") === true ? { sandboxOptions: { enabled: true } } : {}),
+		...(!cliLocalForceConsumed && pi.getFlag("cursor-local-force") === true ? { force: true } : {}),
+		...(pi.getFlag("cursor-no-local-resume") === true
+			? { resume: false }
+			: pi.getFlag("cursor-local-resume") === true
+				? { resume: true }
+				: {}),
+	};
+	cliCursorSnapshot = {
+		config: {
+			...(runtime ? { runtime } : {}),
+			...(Object.keys(cloud).length ? { cloud } : {}),
+			...(Object.keys(local).length ? { local } : {}),
+		},
+		...(cloudEnvNames ? { cloudEnvNames } : {}),
+	};
 }
 
 function persistCursorRuntimePreference(
@@ -265,6 +277,16 @@ function registerCursorRuntimeFlags(pi: Pick<ExtensionAPI, "registerFlag">): voi
 		type: "boolean",
 		default: false,
 	});
+	pi.registerFlag("cursor-cloud-auto-create-pr", {
+		description: `Ask Cursor cloud to create a pull request for this run (or set ${CURSOR_CLOUD_AUTO_CREATE_PR_ENV}=1)`,
+		type: "boolean",
+		default: false,
+	});
+	pi.registerFlag("cursor-cloud-skip-reviewer-request", {
+		description: `Ask Cursor cloud not to request you as a reviewer for this run (or set ${CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV}=1)`,
+		type: "boolean",
+		default: false,
+	});
 	pi.registerFlag("cursor-cloud-allow-local-state", {
 		description: `Allow Cursor cloud to proceed with local-only state for this run (or set ${CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV}=1)`,
 		type: "boolean",
@@ -370,6 +392,13 @@ function registerCursorRuntimeCommand(
 				ctx.ui.notify(`${currentResolution.message} Fix the explicit override before changing the session runtime.`, "error");
 				return;
 			}
+			if (saveProject && (getCursorSessionCwd() !== ctx.cwd || !getCursorSessionProjectTrusted())) {
+				ctx.ui.notify(
+					"Cannot save Cursor project config without explicit project-trust provenance. Ensure .pi/settings.json or another Pi project resource exists, trust the project, then restart pi; or restart with --approve. Project-local package installs must use --approve on every run that reads or writes .pi/cursor-sdk.json.",
+					"error",
+				);
+				return;
+			}
 			const cloudAcknowledged = raw === "cloud" && await confirmCloudAcknowledgement(
 				ctx,
 				resolveEffectiveCursorConfigForContext(ctx).cloud.acknowledged.value,
@@ -378,14 +407,19 @@ function registerCursorRuntimeCommand(
 			if (saveUser || saveProject) {
 				try {
 					if (saveUser) {
-						const current = loadCursorSdkUserConfig();
-						saveCursorSdkUserConfig(mergeCursorSdkConfig(current, {
-							runtime: raw,
-							...(cloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-						}));
+						updateCursorSdkConfig(
+							getCursorSdkUserConfigPath(),
+							(current) => mergeCursorSdkConfigForUpdate(current, {
+								runtime: raw,
+								...(cloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
+							}),
+							{ newFileMode: 0o600 },
+						);
 					} else {
-						const current = loadCursorSdkProjectConfig(ctx.cwd, true) ?? {};
-						saveCursorSdkProjectConfig(ctx.cwd, mergeCursorSdkConfig(current, { runtime: raw }));
+						updateCursorSdkConfig(
+							getCursorSdkProjectConfigPath(ctx.cwd),
+							(current) => mergeCursorSdkConfigForUpdate(current, { runtime: raw }),
+						);
 					}
 				} catch (error) {
 					const effectiveResolution = resolveCursorStatusRuntime(ctx);
@@ -455,24 +489,9 @@ export function registerCursorCloudRuntimeControls(
 }
 
 export function resetCursorRuntimeStateForTests(): void {
-	cliAutoReview = false;
-	cliSandbox = false;
-	cliLocalForce = false;
+	cliCursorSnapshot = { config: {} };
 	cliLocalForceConsumed = false;
-	cliLocalResume = false;
-	cliNoLocalResume = false;
 	envLocalForceConsumed = false;
-	cliCursorRuntime = undefined;
-	cliCursorCloudRepo = undefined;
-	cliCursorCloudBranch = undefined;
-	cliCursorCloudContext = undefined;
-	cliCursorCloudDirectPush = false;
-	cliCursorCloudAllowLocalState = false;
-	cliCursorCloudEnv = undefined;
-	cliCursorCloudEnvFromFiles = false;
-	cliCursorCloudEnvType = undefined;
-	cliCursorCloudEnvName = undefined;
-	cliCursorCloudAck = false;
 	sessionCursorRuntime = undefined;
 	sessionCursorCloudAcknowledged = false;
 }

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

@@ -3,12 +3,14 @@ import { classifyCursorConnectError, isCursorSdkAbortConnectError } from "./curs
 
 interface CursorSdkProcessErrorGuardToken {
 	suppressAbortErrors: boolean;
+	onLocalTransportClosedPipe?: () => void;
 }
 
 interface CursorSdkSessionProcessErrorGuardToken {}
 
 export interface CursorSdkProcessErrorGuard {
 	suppressAbortErrors(): void;
+	containLocalTransportClosedPipe(onClosedPipe: () => void): void;
 	dispose(): void;
 }
 
@@ -52,10 +54,66 @@ function isCursorSdkWriteIterableClosedError(error: unknown): boolean {
 	);
 }
 
+// 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: unknown): boolean {
+	if (typeof error !== "object" || error === null) return false;
+	const { name, stack } = error as { name?: unknown; stack?: unknown };
+	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. 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: unknown): boolean {
+	if (!(error instanceof Error) || error.name !== "Error") return false;
+	const { code, syscall } = error as NodeJS.ErrnoException;
+	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(): boolean {
+	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: string | symbol, args: readonly unknown[]): boolean {
 	if (event !== "uncaughtException" && event !== "unhandledRejection") return false;
 	const error = args[0];
+	if (isObservedLocalTransportClosedPipeWriteError(error)) {
+		return containLocalTransportClosedPipeError();
+	}
 	if (isCursorSdkWriteIterableClosedError(error)) return activeSessions.size > 0;
+	if (isCursorSdkAbortError(error)) return hasActiveAbortSuppression();
 	const classification = classifyCursorConnectError(error);
 	if (!classification) return false;
 	if (classification.kind === "abort") return hasActiveAbortSuppression();
@@ -137,6 +195,10 @@ export function installCursorSdkProcessErrorGuard(): CursorSdkProcessErrorGuard
 			if (disposed) return;
 			token.suppressAbortErrors = true;
 		},
+		containLocalTransportClosedPipe(onClosedPipe: () => void): void {
+			if (disposed) return;
+			token.onLocalTransportClosedPipe = onClosedPipe;
+		},
 		dispose(): void {
 			if (disposed) return;
 			disposed = true;

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

@@ -1,3 +1,4 @@
+import type { LocalAgentStore } from "@cursor/sdk";
 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";
@@ -10,9 +11,15 @@ import {
 	parseCursorSessionAgentResumeEntryData,
 	readResumableCursorSessionAgentIds,
 	resolveCursorSessionRepoRoot,
+	type CursorSessionAgentCleanupCandidate,
 	type CursorSessionAgentResumeEntryData,
 	type CursorSessionAgentResumeScope,
 } 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";
 
@@ -22,6 +29,7 @@ type CleanupPhase = "intent" | "result";
 export interface CursorSessionAgentCleanupFailure {
 	agentId: string;
 	error: string;
+	retryable?: boolean;
 }
 
 export interface CursorSessionAgentCleanupEntryData {
@@ -48,9 +56,11 @@ type LocalResumeCleanupCommandContext = Pick<ExtensionCommandContext, "cwd"> & {
 	ui: Pick<ExtensionCommandContext["ui"], "notify">;
 };
 type LocalResumeCleanupSdkOperations = {
-	delete(agentId: string, options?: { cwd?: string }): Promise<void>;
+	delete(agentId: string, options?: { cwd?: string; store?: LocalAgentStore }): Promise<void>;
 };
 
+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.
@@ -106,7 +116,9 @@ function parseCleanupEntryData(value: unknown): CursorSessionAgentCleanupEntryDa
 	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 }] : [];
+			return isCursorLocalAgentId(failure?.agentId) && typeof failure.error === "string"
+				? [{ agentId: failure.agentId, error: failure.error, ...(failure.retryable === false ? { retryable: false } : {}) }]
+				: [];
 		})
 		: undefined;
 	return {
@@ -124,6 +136,7 @@ function parseCleanupEntryData(value: unknown): CursorSessionAgentCleanupEntryDa
 function readUnavailableAgentIds(entries: readonly SessionEntry[]): Set<string> {
 	const deleted = new Set<string>();
 	const pending = new Set<string>();
+	const permanentlyFailed = 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);
@@ -139,39 +152,57 @@ function readUnavailableAgentIds(entries: readonly SessionEntry[]): Set<string>
 			pending.delete(agentId);
 		}
 		if (data.phase === "result") {
-			for (const { agentId } of data.failedAgentIds ?? []) pending.delete(agentId);
+			for (const failure of data.failedAgentIds ?? []) {
+				pending.delete(failure.agentId);
+				if (failure.retryable === false) permanentlyFailed.add(failure.agentId);
+			}
 		}
 	}
-	return new Set([...deleted, ...pending, ...nondurableCleanupResultAgentIds]);
+	return new Set([...deleted, ...pending, ...permanentlyFailed, ...nondurableCleanupResultAgentIds]);
 }
 
 function readLatestBranchAgentId(branch: readonly SessionEntry[], scope: CursorSessionAgentCleanupScope): string | undefined {
 	return readResumeEntries(branch).filter((entry) => resumeEntryMatchesCleanupScope(entry, scope)).at(-1)?.agentId;
 }
 
-export function readCursorSessionAgentCleanupPlan(
+function readCursorSessionAgentCleanupPlanDetails(
 	entries: readonly SessionEntry[],
 	branch: readonly SessionEntry[],
 	scope: CursorSessionAgentCleanupScope,
-): CursorSessionAgentCleanupPlan {
+): CursorSessionAgentCleanupPlan & { candidates: CursorSessionAgentCleanupCandidate[] } {
 	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>();
+	const candidates = new Map<string, CursorSessionAgentCleanupCandidate>();
 	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);
+		const recordedCandidates: CursorSessionAgentCleanupCandidate[] = [
+			...(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 {
-		candidateAgentIds: uniqueSorted(candidates),
+		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: readonly SessionEntry[],
+	branch: readonly SessionEntry[],
+	scope: CursorSessionAgentCleanupScope,
+): CursorSessionAgentCleanupPlan {
+	const { candidates: _, ...plan } = readCursorSessionAgentCleanupPlanDetails(entries, branch, scope);
+	return plan;
+}
+
 function formatCleanupPlan(plan: CursorSessionAgentCleanupPlan): string {
 	if (plan.candidateAgentIds.length === 0) return "No recorded superseded local Cursor SDK agents are cleanup-eligible.";
 	return [
@@ -245,7 +276,8 @@ export async function runCursorSessionAgentCleanupCommand(pi: LocalResumeCleanup
 
 	const entries = ctx.sessionManager.getEntries();
 	const branch = ctx.sessionManager.getBranch();
-	const plan = readCursorSessionAgentCleanupPlan(entries, branch, getCurrentCleanupScope(ctx));
+	const scope = getCurrentCleanupScope(ctx);
+	const plan = readCursorSessionAgentCleanupPlanDetails(entries, branch, scope);
 	const baseEntry = {
 		runtime: "local" as const,
 		timestamp: new Date().toISOString(),
@@ -274,19 +306,38 @@ export async function runCursorSessionAgentCleanupCommand(pi: LocalResumeCleanup
 
 	const deletedAgentIds: string[] = [];
 	const failedAgentIds: CursorSessionAgentCleanupFailure[] = [];
+	const openedStores = new Map<string, Awaited<ReturnType<typeof openCursorSessionStore>>>();
 	try {
 		const operations = await getSdkOperations();
-		for (const agentId of plan.candidateAgentIds) {
+		const identities = await getCursorSessionStoreIdentities(ctx.cwd, scope.scopeKey, scope.sessionFile !== undefined);
+		for (const candidate of plan.candidates) {
+			const { agentId } = candidate;
 			try {
-				await operations.delete(agentId, { cwd: ctx.cwd });
+				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)) });
+				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",

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

@@ -5,6 +5,7 @@ import type {
 	SessionShutdownEvent,
 	SessionTreeEvent,
 } from "@earendil-works/pi-coding-agent";
+import { clearCursorSdkHttp1 } from "./cursor-http1.js";
 import { onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
 
 export interface CursorSessionAgentLifecycleExtensionApi {
@@ -22,11 +23,15 @@ export function registerCursorSessionAgentLifecycle(pi: CursorSessionAgentLifecy
 	});
 	pi.on("session_shutdown", async (event) => {
 		const { disposeSessionCursorAgent, resetSessionCursorAgent } = await import("./cursor-session-agent.js");
-		if (event.reason === "reload") {
-			await resetSessionCursorAgent();
-			return;
+		try {
+			if (event.reason === "reload") {
+				await resetSessionCursorAgent();
+				return;
+			}
+			await disposeSessionCursorAgent();
+		} finally {
+			clearCursorSdkHttp1();
 		}
-		await disposeSessionCursorAgent();
 	});
 	pi.on("session_compact", async () => {
 		const { invalidateSessionAgent } = await import("./cursor-session-agent.js");