pi-cursor-sdk 0.1.51 → 0.1.52

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.1.52 - 2026-06-28
+
+### Fixed
+
+- Serialize Cursor provider turns per pi session scope so parallel same-session Cursor model evaluations cannot supersede each other's SDK session agent or drain the wrong live run. Queued aborts now return an aborted stream without creating a Cursor SDK agent or leaking the turn queue.
+
+### Validation
+
+- `npm run check:platform-smoke`, `npm run typecheck`, `npm test` (796 tests), and `npm publish --dry-run` pass locally.
+- `npm run smoke:platform:all` passes on macOS, Ubuntu, and Windows native with Cursor auth. Artifact index: `.artifacts/platform-smoke/latest.json`.
+- Subagent review/fix loop and thermo-nuclear release review completed with final `NO FINDINGS`.
+
 ## 0.1.51 - 2026-06-25
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cursor-sdk",
-  "version": "0.1.51",
+  "version": "0.1.52",
   "description": "pi provider extension backed by @cursor/sdk local agents",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "license": "MIT",

package/src/cursor-provider-turn-runner.ts

@@ -46,7 +46,6 @@ export class CursorProviderTurnRunner {
 		});
 
 		try {
-			stream.push({ type: "start", partial });
 			this.throwIfAborted();
 			const cwd = getCursorSessionCwd();
 			this.sdkEventDebug = CursorSdkEventDebugSink.maybeCreate({
@@ -62,6 +61,7 @@ export class CursorProviderTurnRunner {
 			) {
 				return;
 			}
+			this.throwIfAborted();
 
 			this.resolvedApiKey = requireCursorApiKey(options);
 			prepared = await prepareCursorProviderTurn({

package/src/cursor-provider.ts

@@ -22,6 +22,8 @@ import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-gu
 import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { CursorProviderTurnRunner } from "./cursor-provider-turn-runner.js";
+import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { runExclusiveCursorSessionTurn, __testUtils as cursorSessionTurnQueueTestUtils } from "./cursor-session-turn-queue.js";
 
 function makeInitialMessage(model: Model<Api>): AssistantMessage {
 	return {
@@ -54,7 +56,6 @@ export function streamCursor(
 
 	(async () => {
 		const partial = makeInitialMessage(model);
-		const sdkProcessErrorGuard = installCursorSdkProcessErrorGuard();
 
 		const runner = new CursorProviderTurnRunner({
 			model,
@@ -66,7 +67,12 @@ export function streamCursor(
 		});
 
 		try {
-			await runner.run(sdkProcessErrorGuard);
+			stream.push({ type: "start", partial });
+			await runExclusiveCursorSessionTurn(
+				getCursorSessionScopeKey(),
+				() => runner.run(installCursorSdkProcessErrorGuard()),
+				options?.signal,
+			);
 		} catch (error) {
 			await runner.handleOuterCatch(error);
 		}
@@ -93,4 +99,5 @@ export const __testUtils = {
 	resetCursorNativeReplayIdleDisposeMs,
 	releaseAllPendingCursorLiveRunsForTests,
 	resetSessionCursorAgents: () => disposeAllSessionCursorAgents(),
+	resetSessionTurnQueue: cursorSessionTurnQueueTestUtils.reset,
 };

package/src/cursor-session-turn-queue.ts

@@ -0,0 +1,52 @@
+import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
+
+const turnQueuesByScope = new Map<string, Promise<void>>();
+
+async function waitForPreviousTurn(previous: Promise<void>, signal?: AbortSignal): Promise<void> {
+	if (!signal) {
+		await previous.catch(() => undefined);
+		return;
+	}
+	if (signal.aborted) throw new CursorLiveRunAbortError();
+	await new Promise<void>((resolve, reject) => {
+		const onAbort = (): void => {
+			reject(new CursorLiveRunAbortError());
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		previous.catch(() => undefined).then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		});
+	});
+}
+
+export async function runExclusiveCursorSessionTurn<T>(scopeKey: string, body: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+	const previous = turnQueuesByScope.get(scopeKey);
+	let releaseCurrent!: () => void;
+	const current = new Promise<void>((resolve) => {
+		releaseCurrent = resolve;
+	});
+	const tail = (previous ?? Promise.resolve()).catch(() => undefined).then(() => current);
+	turnQueuesByScope.set(scopeKey, tail);
+	void tail.finally(() => {
+		if (turnQueuesByScope.get(scopeKey) === tail) {
+			turnQueuesByScope.delete(scopeKey);
+		}
+	});
+
+	try {
+		if (previous) await waitForPreviousTurn(previous, signal);
+		return await body();
+	} finally {
+		releaseCurrent();
+	}
+}
+
+export const __testUtils = {
+	reset(): void {
+		turnQueuesByScope.clear();
+	},
+	count(): number {
+		return turnQueuesByScope.size;
+	},
+};