pi-cursor-sdk 0.1.21 → 0.1.22

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.1.22 - 2026-05-28
+
+### Fixed
+
+- Fix pi auto-compaction `AgentBusyError` (`already has active run`) by marking pooled session agents busy as soon as a Cursor SDK `run.wait()` starts (live and direct turns), releasing scoped live-run drain state, and resetting the pooled agent on `session_before_compact` before summarization streams (`prepareCursorSessionForCompaction` in `src/cursor-session-compaction-prep.ts`).
+
 ## 0.1.21 - 2026-05-28
 
 **Upgrade:** Requires **pi 0.76.0+** and installs exact **`@cursor/sdk@1.0.14`**. Older pi or Cursor SDK combinations are not supported on this release line.

package/docs/cursor-model-ux-spec.md

@@ -39,7 +39,7 @@ Current implementation notes:
 - Max Mode context windows are distinct from default/non-Max context windows. `@cursor/sdk` 1.0.14 documentation says the SDK may enable Max Mode automatically when a selected model requires it, but the public local-agent `ModelSelection` path still does not expose a manual Max Mode selector. Do not advertise Max Mode context windows unless the SDK catalog exposes an exact parameter/variant or the SDK public API adds a Max Mode selector that the extension actually sends.
 - `@cursor/sdk` 1.0.14 adds latest-style `ModelListItem.aliases`. The extension registers only unambiguous aliases as pi model IDs (with the same context suffixes when applicable) and sends the alias back in `ModelSelection.id`, while sharing Cursor-only state such as fast defaults with the underlying catalog `id`. Aliases shared by multiple base models, such as generic family aliases, are skipped because the pi row metadata would otherwise imply one base model while Cursor may resolve the alias to another.
 - Session-scoped Cursor SDK agent pooling reuses one live `@cursor/sdk` agent across compatible follow-up turns within the same pi session scope. `planCursorSessionSend()` in `src/cursor-session-send-policy.ts` decides whether the next turn sends a full bootstrap prompt or an incremental follow-up, whether the SDK agent must be recreated, and why. `computeCursorContextFingerprint()` and `shouldBootstrapCursorContext()` remain the context-only bootstrap signal. The pool recreates the agent when context diverges, when branch or compaction summaries appear after `/tree` navigation or compaction, after 20 completed incremental sends, when the API key identity changes, after send errors, on `session_shutdown`, and when `session_before_tree` / `session_tree` invalidate the active branch. Incremental sends omit the full Cursor SDK tool boundary block because the session agent retains prior bootstrap context, but every send ends with a short tool tail guard placed after the latest user request (including an explicit shell `cd` hint).
-- Pi steering/follow-up delivery can arrive while a split live Cursor SDK run is still active. The provider resolves pending live runs by scanning trailing `toolResult` messages while skipping trailing `user` messages, tracks the active live run per session scope, and resumes the in-flight run instead of calling `Agent.send()` again. When the context ends with steering user text after tool results, the provider releases the prior live run and chains an incremental `Agent.send()` for the latest user message in the same provider turn; if the prior run emits more text or tool requests after steering arrives, that stale activity is cancelled instead of surfacing another old-run tool turn and losing the new user input. A pre-send guard waits for or resumes any still-active scoped live run before starting a fresh send so `@cursor/sdk` `AgentBusyError` (`already has active run`) does not surface to pi users. `acquireSessionCursorAgent()` also awaits fire-and-forget background `run.wait()` cleanup for the current pooled agent instance before returning a lease, so send planning, transcript offsets, and later `Agent.send()` do not race the prior turn's SDK run completion (for example pi auto-compaction summarization). Tracked completions and send commits are scoped to the pooled agent `instanceId` so disposal/replacement drops stale tracking and ignores late commits from disposed agents.
+- Pi steering/follow-up delivery can arrive while a split live Cursor SDK run is still active. The provider resolves pending live runs by scanning trailing `toolResult` messages while skipping trailing `user` messages, tracks the active live run per session scope, and resumes the in-flight run instead of calling `Agent.send()` again. When the context ends with steering user text after tool results, the provider releases the prior live run and chains an incremental `Agent.send()` for the latest user message in the same provider turn; if the prior run emits more text or tool requests after steering arrives, that stale activity is cancelled instead of surfacing another old-run tool turn and losing the new user input. A pre-send guard waits for or resumes any still-active scoped live run before starting a fresh send so `@cursor/sdk` `AgentBusyError` (`already has active run`) does not surface to pi users. Pooled session agents mark busy as soon as live/direct `run.wait()` tracking starts (`trackRunCompletion` on the session lease), and `acquireSessionCursorAgent()` awaits that busy state before returning a lease so send planning, transcript offsets, and later `Agent.send()` do not race the prior turn's SDK run completion (for example pi auto-compaction summarization). `session_before_compact` calls `prepareCursorSessionForCompaction()` to release scoped live-run drain state and reset the pooled agent before summarization streams. Tracked completions and send commits are scoped to the pooled agent `instanceId` so disposal/replacement drops stale tracking and ignores late commits from disposed agents.
 
 ## Goal
 

package/package.json

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

package/src/cursor-provider-run-finalizer.ts

@@ -113,6 +113,9 @@ export class CursorRunFinalizer {
 					sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey),
 				);
 			});
+		// Mark the pooled agent busy as soon as the SDK run exists so auto-compaction summarization
+		// (and other concurrent acquires) wait for run.wait() instead of hitting AgentBusyError.
+		prepared.sessionAgentLease.trackRunCompletion(waitCompletion);
 		return { waitCompletion, prepared };
 	}
 
@@ -139,7 +142,6 @@ export class CursorRunFinalizer {
 		}
 		this.params.runnerParams.sdkEventDebugRef.current = undefined;
 		if (liveCompletion) {
-			this.safeCleanup(() => liveCompletion.prepared.sessionAgentLease.trackRunCompletion(liveCompletion.waitCompletion));
 			void liveCompletion.waitCompletion
 				.finally(async () => {
 					await this.finalizeSdkEventDebugBestEffort();

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

@@ -105,7 +105,7 @@ export class CursorProviderTurnRunner {
 				return;
 			}
 
-			const outcome = await awaitFinalizeCursorRunOutcome({
+			const outcomePromise = awaitFinalizeCursorRunOutcome({
 				run: send.run,
 				prepared,
 				cursorAgentMessageOffset: send.cursorAgentMessageOffset,
@@ -117,6 +117,8 @@ export class CursorProviderTurnRunner {
 				sdkEventDebug: this.sdkEventDebug,
 				contextWindowAgentId: prepared.contextWindowAgentId,
 			});
+			prepared.sessionAgentLease.trackRunCompletion(outcomePromise);
+			const outcome = await outcomePromise;
 			await runFinalizer.applyTerminalEvent({ kind: "direct", prepared, outcome });
 		} catch (error) {
 			await runFinalizer.applyTerminalEvent({ kind: "error", prepared, error });

package/src/cursor-session-compaction-prep.ts

@@ -0,0 +1,19 @@
+import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
+import { resetSessionCursorAgent } from "./cursor-session-agent.js";
+import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+
+/**
+ * Prepare the pooled Cursor session agent for pi compaction summarization.
+ * Releases any scoped live-run drain state still tied to the pooled agent, then
+ * disposes the pool entry so summarization acquires a clean SDK agent.
+ */
+export async function prepareCursorSessionForCompaction(
+	scopeKey: string = getCursorSessionScopeKey(),
+): Promise<void> {
+	while (true) {
+		const run = cursorLiveRuns.getActiveForScope(scopeKey);
+		if (!run || run.disposed) break;
+		await cursorLiveRuns.release(run);
+	}
+	await resetSessionCursorAgent(scopeKey);
+}

package/src/index.ts

@@ -7,10 +7,11 @@ import { registerCursorQuestionTool } from "./cursor-question-tool.js";
 import { registerCursorSessionCwd } from "./cursor-session-cwd.js";
 import { registerCursorAgentsContextDedup } from "./cursor-agents-context.js";
 import { registerCursorSessionAgent } from "./cursor-session-agent.js";
+import { prepareCursorSessionForCompaction } from "./cursor-session-compaction-prep.js";
 import { streamCursor } from "./cursor-provider.js";
 
 type CursorExtensionApi =
-	& Pick<ExtensionAPI, "registerProvider" | "registerCommand">
+	& Pick<ExtensionAPI, "registerProvider" | "registerCommand" | "on">
 	& Parameters<typeof registerCursorSessionCwd>[0]
 	& Parameters<typeof registerCursorSessionAgent>[0]
 	& Parameters<typeof registerCursorRuntimeControls>[0]
@@ -38,6 +39,9 @@ export default async function (pi: CursorExtensionApi) {
 	// Session cwd must register before other session_start listeners that depend on it.
 	registerCursorSessionCwd(pi);
 	registerCursorSessionAgent(pi);
+	pi.on("session_before_compact", async () => {
+		await prepareCursorSessionForCompaction();
+	});
 	registerCursorRuntimeControls(pi);
 	registerCursorNativeToolDisplay(pi);
 	registerCursorQuestionTool(pi);