pi-cursor-sdk 0.5.0 → 0.5.2

package/dist/cursor-pi-tool-bridge-run.js

@@ -20,6 +20,7 @@ export class CursorPiToolBridgeRunImpl {
     knownMcpToolNames;
     knownCursorMcpCallIds = new Set();
     queuedRequests = [];
+    pendingToolCallListeners = new Set();
     pendingByPiToolCallId = new Map();
     pendingByBridgeCallId = new Map();
     pendingByCursorMcpCallId = new Map();
@@ -129,6 +130,23 @@ export class CursorPiToolBridgeRunImpl {
     hasPendingPiToolCallId(piToolCallId) {
         return this.pendingByPiToolCallId.has(piToolCallId);
     }
+    hasPendingToolCalls() {
+        return this.pendingCount() > 0;
+    }
+    onPendingToolCallsChanged(listener) {
+        this.pendingToolCallListeners.add(listener);
+        return () => { this.pendingToolCallListeners.delete(listener); };
+    }
+    notifyPendingToolCallsChanged() {
+        for (const listener of this.pendingToolCallListeners) {
+            try {
+                listener();
+            }
+            catch {
+                // Observers must not prevent call registration or protocol settlement.
+            }
+        }
+    }
     cancelPendingPiToolCallId(piToolCallId, reason) {
         const pending = this.pendingByPiToolCallId.get(piToolCallId);
         if (!pending)
@@ -173,6 +191,7 @@ export class CursorPiToolBridgeRunImpl {
             return;
         this.disposed = true;
         this.cancel("Cursor pi tool bridge run disposed");
+        this.pendingToolCallListeners.clear();
         await waitForProtocolFlush();
         await Promise.allSettled([
             this.mcpTransport?.close(),
@@ -241,6 +260,7 @@ export class CursorPiToolBridgeRunImpl {
             this.pendingByBridgeCallId.set(request.bridgeCallId, pending);
             this.pendingByCursorMcpCallId.set(cursorMcpCallId, pending);
             this.knownCursorMcpCallIds.add(cursorMcpCallId);
+            this.notifyPendingToolCallsChanged();
             pending.timeout = setTimeout(() => {
                 const reason = `Cursor pi bridge CallTool timed out after ${this.callTimeoutMs} ms`;
                 this.rejectAndAbortPending(pending, new Error(reason));
@@ -352,5 +372,6 @@ export class CursorPiToolBridgeRunImpl {
         const queuedIndex = this.queuedRequests.findIndex((request) => request.bridgeCallId === pending.request.bridgeCallId);
         if (queuedIndex >= 0)
             this.queuedRequests.splice(queuedIndex, 1);
+        this.notifyPendingToolCallsChanged();
     }
 }

package/dist/cursor-pi-tool-bridge-server.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { asRecord } from "./cursor-record-utils.js";
+import { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import { buildCursorPiToolBridgeSnapshot, buildCursorPiToolBridgeSurfaceSignature, createEmptySnapshot, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-snapshot.js";
 export const LOOPBACK_HOST = "127.0.0.1";
 const HTTP_SERVER_CLOSE_GRACE_MS = 250;
@@ -33,7 +34,6 @@ export class CursorPiToolBridgeRegistry {
                 exposeOverlappingBuiltins: resolveCursorPiToolBridgeBuiltinsEnabled(this.env),
             })
             : createEmptySnapshot();
-        const { CursorPiToolBridgeRunImpl } = await import("./cursor-pi-tool-bridge-run.js");
         const run = new CursorPiToolBridgeRunImpl(this, this.env, snapshot, bridgeEnabled && snapshot.tools.length > 0, options);
         this.runs.add(run);
         await run.start();

package/dist/cursor-provider-binding.js

@@ -1,4 +1,6 @@
-import { CURSOR_API_KEY_CONFIG_VALUE } from "./cursor-api-key.js";
+import { cursorApiKeyAuth, normalizeCursorApiKey, resolveCursorCredentialApiKey } from "./cursor-api-key.js";
+import { discoverModels } from "./model-discovery.js";
+import { clearModelListCache } from "./model-list-cache.js";
 import { captureCursorCloudLifecycleRecorder } from "./cursor-cloud-lifecycle.js";
 import { captureCursorUsageRecorder } from "./cursor-usage-ledger.js";
 import { getCursorNativeToolDisplayState } from "./cursor-native-tool-display-state.js";
@@ -6,15 +8,17 @@ import { getRegisteredCursorPiToolBridge } from "./cursor-pi-tool-bridge.js";
 import { createCursorLazyStream } from "./cursor-provider-lazy.js";
 import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
 import { captureCursorRequestProjection, resolveCursorRequestProvenance } from "./cursor-request-provenance.js";
-export const CURSOR_PROVIDER_OWNERSHIP_ERROR = "Cursor provider ownership is unavailable: this request does not belong to the active Cursor registration. Bind this session's extensions and refresh Cursor models/reload it; use independent ModelRuntime instances for sibling sessions.";
+export const CURSOR_PROVIDER_OWNERSHIP_ERROR = "Cursor provider ownership is unavailable: this request does not belong to the active Cursor registration. Reload this session's extensions to restore its Cursor registration; use independent ModelRuntime instances for sibling sessions.";
 const requestOwners = new WeakMap();
 /** One closure per ExtensionAPI, including direct compaction/tree/bug-report streams. */
 export function registerCursorProviderBinding(pi) {
     const binding = { active: false, closed: false };
+    let registry;
     const operations = new WeakMap();
     pi.on("session_before_compact", (event) => { operations.set(event.signal, "compaction"); });
     pi.on("session_before_tree", (event) => { operations.set(event.signal, "tree"); });
     pi.on("before_provider_headers", (event, ctx) => {
+        const notices = new Set();
         // Pi's SDK supplies this session-owned callback for ordinary and auxiliary
         // streams. ModelRuntime forwards the same real headers object to the provider.
         requestOwners.set(event.headers, {
@@ -22,6 +26,18 @@ export function registerCursorProviderBinding(pi) {
             scope: getCursorSessionScopeSnapshot(pi),
             projection: captureCursorRequestProjection(ctx.sessionManager),
             usageRecorder: captureCursorUsageRecorder(pi, ctx),
+            reportSdkNotice: (kind, message) => {
+                if (!binding.active || binding.closed)
+                    return false;
+                if (notices.has(kind))
+                    return;
+                pi.appendEntry("pi-cursor-sdk:capability-notice", { kind, message });
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, "warning");
+                else
+                    console.warn(message);
+                notices.add(kind);
+            },
         });
     });
     const stream = createCursorLazyStream((model, context, options) => {
@@ -42,17 +58,61 @@ export function registerCursorProviderBinding(pi) {
             bridge: getRegisteredCursorPiToolBridge(pi),
             nativeDisplay: getCursorNativeToolDisplayState(pi),
             recordCloudLifecycle: captureCursorCloudLifecycleRecorder(pi),
+            reportSdkNotice: owner.reportSdkNotice,
         };
     });
-    pi.on("session_start", () => { if (!binding.closed)
-        binding.active = true; });
-    pi.on("session_shutdown", () => { binding.active = false; binding.closed = true; });
-    return (models) => {
+    pi.on("session_start", async (_event, ctx) => {
         if (binding.closed)
             return;
-        pi.registerProvider("cursor", {
-            name: "Cursor", baseUrl: "https://cursor.com", apiKey: CURSOR_API_KEY_CONFIG_VALUE,
-            api: "cursor-sdk", models, streamSimple: stream,
-        });
+        binding.active = true;
+        registry = ctx.modelRegistry;
+        // The genuine extension context supplies composed config auth; startup
+        // selection already has the known baseline, without reading a default store.
+        await registry.refresh({ providers: ["cursor"], allowNetwork: false });
+    });
+    pi.on("session_shutdown", () => { binding.active = false; binding.closed = true; registry = undefined; });
+    return (models, onCatalog) => {
+        if (binding.closed)
+            return;
+        const toNative = (definitions) => definitions.map(({ compat: _compat, ...definition }) => ({
+            ...definition, provider: "cursor", api: "cursor-sdk", baseUrl: "https://cursor.com",
+        }));
+        let current = toNative(models);
+        const provider = {
+            id: "cursor", name: "Cursor", baseUrl: "https://cursor.com",
+            auth: { apiKey: cursorApiKeyAuth() },
+            getModels: () => current,
+            stream: stream,
+            streamSimple: stream,
+            async refreshModels(context) {
+                if (binding.closed)
+                    return;
+                const resolved = await registry?.getProviderAuth("cursor");
+                context.signal.throwIfAborted();
+                const credential = context.credential;
+                const apiKey = registry
+                    ? normalizeCursorApiKey(resolved?.auth.apiKey)
+                    : credential && credential.type !== "api_key" ? undefined
+                        : await resolveCursorCredentialApiKey(credential, async () => process.env.CURSOR_API_KEY);
+                let issue;
+                await discoverModels({
+                    apiKey, allowNetwork: context.allowNetwork, forceRefresh: context.force, signal: context.signal,
+                    onFallback: (next) => { issue = next; },
+                    publish: (definitions, update) => context.publish({
+                        update: () => {
+                            if (binding.closed)
+                                return;
+                            update();
+                            current = toNative(definitions);
+                            // Do not infer logout before native composed auth is reachable.
+                            if (registry && !apiKey)
+                                clearModelListCache();
+                            onCatalog(issue);
+                        },
+                    }),
+                });
+            },
+        };
+        pi.registerProvider(provider);
     };
 }

package/dist/cursor-provider-errors.js

@@ -120,7 +120,11 @@ function collectConnectErrorStacks(error, record) {
 }
 function isConnectError(error, record) {
     const name = error instanceof Error ? error.name : getErrorStringField(record, "name");
-    return name === "ConnectError";
+    if (name === "ConnectError")
+        return true;
+    // @cursor/sdk convertConnectError re-wraps backend ConnectErrors (name -> NetworkError,
+    // code -> "unavailable") and leaves the original ConnectError on `.cause` without outer details.
+    return getErrorStringField(asRecord(record?.cause), "name") === "ConnectError";
 }
 function isUnauthenticatedConnectCode(code) {
     return code === 16 || (typeof code === "string" && /^(?:16|unauthenticated)$/i.test(code));
@@ -133,11 +137,10 @@ function isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence) {
         /(?:operation was aborted|canceled)/i.test(evidence) &&
         /(?:AbortError|operation was aborted)/i.test(`${evidence}\n${stackEvidence}`) &&
         stackEvidence.includes("@cursor/sdk") &&
-        stackEvidence.includes("@connectrpc/connect-node") &&
         /\b(?:onStall|reportStall|StallDetected)\b/i.test(stackEvidence));
 }
 /**
- * @cursor/sdk@1.0.32 throws internal RetriableError (name/kind "RetriableError") with message
+ * @cursor/sdk@1.0.36 throws internal RetriableError (name/kind "RetriableError") with message
  * "Connection stalled" or "Connection stalled repeatedly" after fetchWithRetry exhausts stalls.
  * The ConnectError is only the cause; the top-level error is not a ConnectError.
  */
@@ -154,25 +157,23 @@ export function isCursorSdkConnectionStalledError(error) {
     const stack = getErrorStack(error, record);
     return /(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(stack) || stack.includes("@cursor/sdk");
 }
-function isCursorExtensionConnectStack(stack) {
-    // pi runs Cursor SDK in Node, where the SDK dynamically imports connect-node.
-    // connect-web is the SDK's Bun/Deno path and is intentionally not classified for supported pi runs.
-    return stack.includes("@connectrpc/connect-node") && /(?:^|[\\/])pi-cursor-sdk(?:[\\/]|$)/.test(stack);
-}
 function getCursorConnectSource(error, record) {
-    const stack = getErrorStack(error, record);
+    const stack = collectConnectErrorStacks(error, record);
+    // Node/Bun use the SDK's vendored transport; Deno uses connect-web.
     if (stack.includes("@cursor/sdk"))
         return "cursor-sdk-stack";
-    if (isCursorExtensionConnectStack(stack))
-        return "cursor-extension-connect-stack";
-    const details = Array.isArray(record?.details) ? record.details : [];
-    const hasCursorBackendDetails = details.some((detail) => {
-        const type = getErrorStringField(asRecord(detail), "type");
-        return typeof type === "string" && type.startsWith("aiserver.");
-    });
-    if (hasCursorBackendDetails)
-        return "cursor-backend-details";
-    return stack.includes("@connectrpc/connect-node") ? "connect-node-stack" : "generic-connect";
+    let current = record;
+    for (let depth = 0; depth < 3 && current; depth += 1) {
+        const details = Array.isArray(current.details) ? current.details : [];
+        const hasCursorBackendDetails = details.some((detail) => {
+            const type = getErrorStringField(asRecord(detail), "type");
+            return typeof type === "string" && type.startsWith("aiserver.");
+        });
+        if (hasCursorBackendDetails)
+            return "cursor-backend-details";
+        current = asRecord(current.cause);
+    }
+    return "generic-connect";
 }
 export function classifyCursorConnectError(error) {
     const record = asRecord(error);
@@ -186,16 +187,22 @@ export function classifyCursorConnectError(error) {
     const stack = getErrorStack(error, record);
     const evidence = collectConnectErrorEvidence(error, record);
     const stackEvidence = collectConnectErrorStacks(error, record);
-    if ((code === 1 || code === "canceled") &&
-        Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
-        (causeName === "AbortError" || /AbortError/.test(stack)) &&
-        stack.includes("@cursor/sdk") &&
-        stack.includes("@connectrpc/connect-node")) {
-        return { kind: "abort", source: "cursor-sdk-stack" };
-    }
     if (isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence)) {
         return { kind: "network", source: getCursorConnectSource(error, record) };
     }
+    const directAbort = (code === 1 || code === "canceled") &&
+        (causeName === "AbortError" || /AbortError/.test(stack));
+    // The vendored 1.0.36 transport wraps a canceled ConnectError as Unknown.
+    // Require the observed canceled -> AbortError cause chain, not generic text.
+    const wrappedAbort = (code === 2 || code === "unknown") &&
+        causeName === "ConnectError" &&
+        (cause?.code === 1 || cause?.code === "canceled") &&
+        asRecord(cause?.cause)?.name === "AbortError";
+    if ((directAbort || wrappedAbort) &&
+        Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
+        stack.includes("@cursor/sdk")) {
+        return { kind: "abort", source: "cursor-sdk-stack" };
+    }
     if (isUnauthenticatedConnectCode(code) || isLikelyAuthError(evidence)) {
         return { kind: "unauthenticated", source: getCursorConnectSource(error, record) };
     }

package/dist/cursor-provider-live-run-drain.js

@@ -10,8 +10,14 @@ import { formatCursorSdkAbortMessage, resolveCursorSdkAbortCause } from "./curso
 import { formatInactiveCursorReplayTrace } from "./cursor-native-replay-trace.js";
 import { partitionNativeToolsByActiveContext } from "./cursor-native-replay-routing.js";
 export const DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS = 5 * 60 * 1000;
+function parseCursorNativeReplayIdleDisposeMs(raw) {
+    if (!raw || /[^0-9]/.test(raw))
+        return DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+    const value = Number(raw);
+    return value >= 1 && value <= 2147483647 ? value : DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+}
 const CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN = /^(cursor-replay-\d+-\d+)-tool-\d+$/;
-let cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+let cursorNativeReplayIdleDisposeMsOverride;
 let cursorNativeReplayCounter = 0;
 export async function abandonSessionCursorAgent(scopeKey) {
     if (!scopeKey)
@@ -19,7 +25,7 @@ export async function abandonSessionCursorAgent(scopeKey) {
     await resetSessionCursorAgent(scopeKey);
 }
 export const cursorLiveRuns = createCursorLiveRunCoordinator({
-    getIdleDisposeMs: () => cursorNativeReplayIdleDisposeMs,
+    getIdleDisposeMs: () => cursorNativeReplayIdleDisposeMsOverride ?? parseCursorNativeReplayIdleDisposeMs(process.env.PI_CURSOR_LIVE_RUN_IDLE_DISPOSE_MS),
     deleteNativeToolDisplay: deleteCursorNativeToolDisplay,
     abandonSessionAgent: (scopeKey) => abandonSessionCursorAgent(scopeKey),
 });
@@ -407,10 +413,10 @@ export async function drainExistingCursorLiveRunBeforeSend(stream, partial, mode
     }
 }
 export function setCursorNativeReplayIdleDisposeMs(value) {
-    cursorNativeReplayIdleDisposeMs = value;
+    cursorNativeReplayIdleDisposeMsOverride = value;
 }
 export function resetCursorNativeReplayIdleDisposeMs() {
-    cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+    cursorNativeReplayIdleDisposeMsOverride = undefined;
 }
 export async function releaseAllPendingCursorLiveRunsForTests() {
     while (cursorLiveRuns.count() > 0) {

package/dist/cursor-provider-run-finalizer.js

@@ -84,12 +84,12 @@ export class CursorRunFinalizer {
         this.terminalApplied = true;
     }
     async cleanup(prepared, sendResult, liveCompletion) {
-        this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
         const abortRegistration = sendResult?.abortRegistration;
         this.params.runnerParams.sdkEventDebugRef.current = undefined;
         if (liveCompletion) {
             void liveCompletion.waitCompletion
                 .finally(async () => {
+                this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
                 if (abortRegistration) {
                     this.safeCleanup(() => abortRegistration.signal.removeEventListener("abort", abortRegistration.listener));
                 }
@@ -99,6 +99,7 @@ export class CursorRunFinalizer {
                 .catch(() => { });
             return;
         }
+        this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
         if (abortRegistration) {
             this.safeCleanup(() => abortRegistration.signal.removeEventListener("abort", abortRegistration.listener));
         }

package/dist/cursor-provider-turn-prepare.js

@@ -4,12 +4,13 @@ import { installCursorMcpToolTimeoutOverride } from "./cursor-mcp-timeout-overri
 import { ensureCursorRipgrepPath } from "./cursor-ripgrep-path.js";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-sdk-output-filter.js";
 import { acquireSessionCursorAgent, buildCursorSessionSendPrompt, planCursorSessionSend, resetSessionCursorAgent, } from "./cursor-session-agent.js";
-import { buildCursorPrompt, estimateCursorPromptTokens } from "./context.js";
+import { buildCursorPrompt, estimateCursorPromptTokens, getCursorPendingInput } from "./context.js";
 import { getCursorPromptOptions } from "./cursor-usage-accounting.js";
 import { getActiveContextToolNames } from "./cursor-context-tools.js";
 import { abandonSessionCursorAgent, createCursorNativeReplayId, cursorLiveRuns, getActiveCursorLiveRunForCurrentScope, } from "./cursor-provider-live-run-drain.js";
 import { getCursorProviderAgentModeOrThrow, getEffectiveFastForModelId, } from "./cursor-state.js";
 import { resolveEffectiveCursorConfig } from "./cursor-runtime-state.js";
+import { buildCursorCustomSubagentDefinitions } from "./cursor-custom-subagent-definitions.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
 import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
 import { formatCursorCloudPreflightError, buildCursorCloudAgentOptions, preflightCursorCloudRuntime, } from "./cursor-cloud-options.js";
@@ -24,13 +25,17 @@ import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js"
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import { prepareCursorSummaryProviderTurn } from "./cursor-provider-turn-summary.js";
-function buildCursorCloudPromptContext(context, handoff) {
+function buildCursorCloudPromptContext(context, handoff, nativeSourceRoles) {
     if (handoff === "bootstrap")
         return context;
     // Fresh cloud runs omit history, not the current Pi instructions. Replay before
     // selecting the user message, otherwise transcript-only inputs lose the prompt.
     const current = resolveCursorPiContext(context);
     const messages = getCursorConversationMessages(context);
+    if (nativeSourceRoles) {
+        const { start } = getCursorPendingInput(messages, nativeSourceRoles);
+        return { ...current, messages: messages.slice(start) };
+    }
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const message = messages[index];
         if (message.role === "user")
@@ -61,7 +66,7 @@ function buildLocalCursorProviderTurnLifecycle(lease, scopeKey) {
     };
 }
 async function prepareCursorCloudProviderTurn(prepareParams) {
-    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
+    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled, agents, customSubagentNames } = prepareParams;
     const { model, context, options } = params;
     let restoreCursorSdkOutputFilter;
     let cloudAgentForCleanup;
@@ -84,13 +89,16 @@ async function prepareCursorCloudProviderTurn(prepareParams) {
         }
         const { Agent } = await loadCursorSdk();
         restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
+        const promptContext = buildCursorCloudPromptContext(context, resolvedConfig.cloud.contextHandoff.value, params.request.nativeSourceRoles);
+        const nativeSourceRoles = params.request.nativeSourceRoles;
         const promptOptions = {
             ...getCursorPromptOptions(model),
+            nativeSourceRoles: nativeSourceRoles?.slice(nativeSourceRoles.length - getCursorConversationMessages(promptContext).length),
             agentMode,
             includePiBridgeGuidance: false,
             includePiAskQuestionGuidance: false,
         };
-        const prompt = buildCursorPrompt(buildCursorCloudPromptContext(context, resolvedConfig.cloud.contextHandoff.value), promptOptions);
+        const prompt = buildCursorPrompt(promptContext, promptOptions);
         const promptInputTokens = estimateCursorPromptTokens(prompt, promptOptions);
         const agent = await suppressCursorSdkOutput(() => Agent.create(buildCursorCloudAgentOptions({
             apiKey: resolvedApiKey,
@@ -98,6 +106,7 @@ async function prepareCursorCloudProviderTurn(prepareParams) {
             agentMode,
             resolvedConfig,
             name: params.scope.sessionName,
+            agents,
         })));
         cloudAgentForCleanup = agent;
         if (!params.recordCloudLifecycle({ agentId: agent.agentId }, resolvedApiKey)) {
@@ -133,6 +142,7 @@ async function prepareCursorCloudProviderTurn(prepareParams) {
             promptOptions,
             agentMode,
             localForce: false,
+            ...(customSubagentNames ? { customSubagentNames } : {}),
         });
         completed = true;
         cloudAgentForCleanup = undefined;
@@ -172,7 +182,7 @@ async function prepareCursorCloudProviderTurn(prepareParams) {
     }
 }
 async function prepareCursorLocalProviderTurn(prepareParams) {
-    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
+    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled, agents, customSubagentNames } = prepareParams;
     const { model, context, options } = params;
     let restoreCursorSdkOutputFilter;
     let sessionAgentScopeKey;
@@ -201,7 +211,9 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             modelSelection: selection,
             settingSources,
             localSafety,
+            agents,
             localResume: resolvedConfig.local.resume.value,
+            storeRoot: resolvedConfig.local.storeRoot.value,
             useHttp1ForAgent,
             debugRecorder: sdkEventDebug,
             onBridgeToolRequest: (request) => {
@@ -222,9 +234,10 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
         const buildPromptOptions = (plan) => {
             const promptOptions = {
                 ...getCursorPromptOptions(model),
+                nativeSourceRoles: params.request.nativeSourceRoles,
                 agentMode,
                 includePiBridgeGuidance,
-                includePiAskQuestionGuidance: bridgeToolNames.has("pi__cursor_ask_question"),
+                includePiAskQuestionGuidance: false,
             };
             if (plan.mode !== "bootstrap" || !resolveCursorToolManifestEnabled()) {
                 return promptOptions;
@@ -238,7 +251,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
                 }),
             };
         };
-        let sendPlan = planCursorSessionSend(sessionAgentLease.sendState, context);
+        let sendPlan = planCursorSessionSend(sessionAgentLease.sendState, context, params.request.nativeSourceRoles);
         if (sessionAgentLease.created && sessionAgentLease.resumed && sendPlan.mode === "incremental") {
             sendPlan = { mode: "bootstrap", resetAgent: false, reason: "process_resume" };
         }
@@ -250,7 +263,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             sessionAgentScopeKey = sessionAgentLease.scopeKey;
             bridgeToolNames = new Set(sessionAgentLease.bridgeRun?.snapshot.tools.map((tool) => tool.mcpToolName) ?? []);
             includePiBridgeGuidance = bridgeToolNames.size > 0;
-            sendPlan = planCursorSessionSend(sessionAgentLease.sendState, context);
+            sendPlan = planCursorSessionSend(sessionAgentLease.sendState, context, params.request.nativeSourceRoles);
             promptOptions = buildPromptOptions(sendPlan);
             prompt = buildCursorSessionSendPrompt(context, promptOptions, sendPlan);
         }
@@ -286,6 +299,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             activeToolNames: activeToolNames ? [...activeToolNames] : [],
             sessionAgentScopeKey,
             bridgeRunId: bridgeRun?.id,
+            ...(customSubagentNames ? { customSubagentNames } : {}),
         });
         const nativeReplayId = createCursorNativeReplayId();
         const textDeltas = [];
@@ -379,7 +393,9 @@ export async function prepareCursorProviderTurn(prepareParams) {
         return prepareCursorSummaryProviderTurn(prepareParams, selection);
     }
     const agentMode = getCursorProviderAgentModeOrThrow(params.scope.scopeKey);
-    const context = { ...prepareParams, agentMode, selection, fastEnabled };
+    const agents = buildCursorCustomSubagentDefinitions(resolvedConfig.subagents.value);
+    const customSubagentNames = agents ? Object.keys(agents) : undefined;
+    const context = { ...prepareParams, agentMode, selection, fastEnabled, agents, customSubagentNames };
     return resolvedConfig.runtime.value === "cloud"
         ? prepareCursorCloudProviderTurn(context)
         : prepareCursorLocalProviderTurn(context);

package/dist/cursor-provider-turn-summary.js

@@ -33,7 +33,7 @@ export async function prepareCursorSummaryProviderTurn(prepareParams, selection)
         configureCursorSdkHttp1(sdk, resolvedConfig.local.useHttp1ForAgent);
         restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
         sessionStore = (await openCursorSessionStoreForScope({
-            cwd, scopeKey: params.scope.scopeKey, persistent: false, hasResumeHandle: false,
+            cwd, scopeKey: params.scope.scopeKey, persistent: false,
         })).sessionStore;
         throwIfAborted();
         agent = await suppressCursorSdkOutput(() => sdk.Agent.create({

package/dist/cursor-provider-turn-tool-ledger.js

@@ -1,3 +1,4 @@
+import { normalizeCursorToolName } from "./cursor-tool-presentation-registry.js";
 import { getToolArgs, getToolName } from "./cursor-transcript-utils.js";
 export class CursorToolCompletionLedger {
     startedToolCalls = new Map();
@@ -33,13 +34,14 @@ export class CursorToolCompletionLedger {
             return stepId;
         }
         const fingerprint = getStartedToolCallFingerprint(toolCall);
-        for (const [callId, startedToolCall] of this.startedToolCalls) {
-            if (getStartedToolCallFingerprint(startedToolCall) !== fingerprint)
-                continue;
+        const matches = [...this.startedToolCalls].filter(([, started]) => getStartedToolCallFingerprint(started) === fingerprint);
+        // Identical concurrent shells cannot be joined safely without a matching ID.
+        if (normalizeCursorToolName(getToolName(toolCall)) === "shell" && matches.length !== 1)
+            return undefined;
+        const callId = matches[0]?.[0];
+        if (callId !== undefined)
             this.clearStartedToolCall(callId);
-            return callId;
-        }
-        return undefined;
+        return callId;
     }
     recordCompletedIdentity(identity) {
         this.completedToolIdentities.add(identity);
@@ -95,5 +97,9 @@ export function getToolFingerprint(value) {
     }
 }
 export function getStartedToolCallFingerprint(toolCall) {
-    return getToolFingerprint({ toolName: getToolName(toolCall), args: getToolArgs(toolCall) });
+    const name = getToolName(toolCall);
+    // Accept legacy shell aliases; this does not establish that the SDK emits alias-changing pairs.
+    // Keep exact argument matching; assistant text alone is not completion proof.
+    const toolName = normalizeCursorToolName(name) === "shell" ? "shell" : name;
+    return getToolFingerprint({ toolName, args: getToolArgs(toolCall) });
 }

package/dist/cursor-provider.js

@@ -7,6 +7,7 @@ import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { CursorProviderTurnRunner } from "./cursor-provider-turn-runner.js";
 import { runExclusiveCursorSessionTurn, __testUtils as cursorSessionTurnQueueTestUtils } from "./cursor-session-turn-queue.js";
+import { withCursorSdkOutputNoticeHandler } from "./cursor-sdk-output-filter.js";
 function makeInitialMessage(model) {
     return {
         role: "assistant",
@@ -49,7 +50,7 @@ export function streamCursor(model, context, options, ownership) {
         });
         try {
             stream.push({ type: "start", partial });
-            await runExclusiveCursorSessionTurn(scope.scopeKey, () => runner.run(installCursorSdkProcessErrorGuard()), options?.signal);
+            await runExclusiveCursorSessionTurn(scope.scopeKey, () => withCursorSdkOutputNoticeHandler(ownership.reportSdkNotice, () => runner.run(installCursorSdkProcessErrorGuard())), options?.signal);
         }
         catch (error) {
             await runner.handleOuterCatch(error);

package/dist/cursor-question-tool.js

@@ -8,7 +8,7 @@ import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js
 export const CURSOR_ASK_QUESTION_TOOL_NAME = "cursor_ask_question";
 export const CURSOR_ASK_QUESTION_ENV = "PI_CURSOR_ASK_QUESTION";
 export function resolveCursorAskQuestionEnabled(env = process.env) {
-    return parseEnvBoolean(env[CURSOR_ASK_QUESTION_ENV], true);
+    return parseEnvBoolean(env[CURSOR_ASK_QUESTION_ENV], false);
 }
 /** Package-namespaced event while `cursor_ask_question` awaits pi UI input. */
 export const CURSOR_ASK_QUESTION_BLOCKED_EVENT = "pi-cursor-sdk:ask-question:blocked";
@@ -146,13 +146,13 @@ export function registerCursorQuestionTool(pi) {
     pi.registerTool({
         name: CURSOR_ASK_QUESTION_TOOL_NAME,
         label: "Cursor question",
-        description: "Ask the user a clarifying question from Cursor. Use when user preferences materially affect the next step; provide options when possible.",
-        promptSnippet: "Ask the user a clarifying question through pi UI when material choices affect Cursor's next step",
+        description: "Ask the user a clarifying question through pi UI. Do not use this unless the user asked to be prompted; otherwise proceed with a stated assumption.",
+        promptSnippet: "Do not prompt the user through cursor_ask_question unless they asked to be asked",
         executionMode: "sequential",
         parameters: CursorAskQuestionParamsSchema,
         promptGuidelines: [
-            "Use cursor_ask_question only when running a Cursor model and user input would materially change the plan, scope, platform, or implementation path.",
-            "Prefer cursor_ask_question with 2-4 concrete options instead of guessing when Cursor plan mode needs user choices.",
+            "Do not call cursor_ask_question unless the user explicitly asked to be prompted or to choose among options.",
+            "If this tool is available, prefer a reasonable default and state the assumption instead of blocking on a questionnaire.",
         ],
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
             const questions = normalizeQuestions(params);

package/dist/cursor-request-provenance.js

@@ -32,11 +32,22 @@ export function captureCursorRequestProjection(manager) {
             measurements.push(Object.freeze({ api: message.api, provider: message.provider, model: message.model, tokens }));
         }
     }
-    return Object.freeze({ digest: projectionDigest(convertToLlm(projection.messages)), measurements: Object.freeze(measurements) });
+    const nativeSourceRoles = projection.messages.flatMap((message) => message.role === "system" ? [] : convertToLlm([message]).map(() => message.role));
+    return Object.freeze({
+        digest: projectionDigest(convertToLlm(projection.messages)),
+        measurements: Object.freeze(measurements),
+        nativeSourceRoles: Object.freeze(nativeSourceRoles),
+    });
 }
 export function resolveCursorRequestProvenance(snapshot, model, context, purpose) {
+    // ponytail: canonical native origin only. Unmatched transforms stay conservative;
+    // upgrade if Pi exposes final request-bound source provenance.
     if (purpose !== "normal" || snapshot.digest !== projectionDigest(context.messages))
         return Object.freeze({ purpose });
     const measurement = snapshot.measurements.findLast((item) => item.api === model.api && item.provider === model.provider && item.model === model.id && item.tokens <= model.contextWindow);
-    return Object.freeze({ purpose, ...(measurement ? { occupancyFloor: measurement.tokens } : {}) });
+    return Object.freeze({
+        purpose,
+        nativeSourceRoles: snapshot.nativeSourceRoles,
+        ...(measurement ? { occupancyFloor: measurement.tokens } : {}),
+    });
 }

package/dist/cursor-sdk-output-filter.js

@@ -1 +1 @@
-export { CURSOR_SDK_STARTUP_NOISE_PATTERNS, installCursorSdkOutputFilter, isCursorSdkOutputSuppressed, isCursorSdkStartupNoise, suppressCursorSdkOutput, } from "../shared/cursor-sdk-output-filter.mjs";
+export { CURSOR_SDK_STARTUP_NOISE_PATTERNS, withCursorSdkOutputNoticeHandler, installCursorSdkOutputFilter, isCursorSdkOutputSuppressed, isCursorSdkStartupNoise, suppressCursorSdkOutput, } from "../shared/cursor-sdk-output-filter.mjs";

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

@@ -19,7 +19,7 @@ function hasActiveAbortSuppression() {
     return false;
 }
 function isCursorProvenance(source) {
-    return source === "cursor-sdk-stack" || source === "cursor-extension-connect-stack" || source === "cursor-backend-details";
+    return source === "cursor-sdk-stack" || source === "cursor-backend-details";
 }
 function isCursorSdkWriteIterableClosedError(error) {
     return (error instanceof Error &&
@@ -63,8 +63,6 @@ function shouldSuppressProcessError(event, args) {
         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() {