@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -21,13 +21,14 @@ import { resolveWorkflowQuestionToolSurface } from "../gsd/question-transport.js
 import { buildProjectGsdMcpServers, ensureProjectWorkflowMcpConfig } from "../gsd/mcp-project-config.js";
 import { loadProjectGSDPreferences } from "../gsd/preferences.js";
 import { markToolStart, markToolEnd } from "../gsd/auto.js";
-import { markInteractiveElicitationStart, markInteractiveElicitationEnd, } from "../gsd/auto-tool-tracking.js";
+import { markInteractiveElicitationStart, markInteractiveElicitationEnd, isInteractiveElicitationInFlight, } from "../gsd/auto-tool-tracking.js";
 import { discoverBrowserMcpServerName, discoverMcpServers, discoverMcpServerNames, discoverUserMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools, } from "../gsd/mcp-filter.js";
 import { RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES, RUN_UAT_FORBIDDEN_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES, resolveToolPresentationPlan } from "../gsd/tool-presentation-plan.js";
 import { getUnitToolSurfaceContract } from "../gsd/unit-tool-contracts.js";
 import { awaitWorkflowMcpToolRegistration, getToolSurfaceReadinessError, POST_PREFLIGHT_READINESS_RETRY_DELAYS_MS, POST_PREFLIGHT_SDK_SETTLE_MS, TOOL_SURFACE_NOT_READY, } from "../gsd/tool-surface-readiness.js";
 import { beginWorkflowMcpSdkSession, endWorkflowMcpSdkSession, } from "../gsd/workflow-mcp-readiness-cache.js";
 import { getGuidedUnitContext } from "../gsd/guided-unit-context.js";
+import { getActiveAutoUnitType, isAutoActive } from "../gsd/auto-runtime-state.js";
 import { hasBrowserContractPrefix } from "../shared/browser-contract.js";
 import { showInterviewRound } from "../shared/tui.js";
 export { buildFinalAssistantContent, extractToolResultsFromSdkUserMessage, handleClaudeCodePartialStreamEvent, mergePendingToolCalls, shouldSuppressDuplicateToolUnavailableBlock, } from "./turn-assembler.js";
@@ -50,6 +51,27 @@ export function resolveClaudeCodeCwd(options) {
 const OTHER_OPTION_LABEL = "None of the above";
 /** Regex pattern that identifies field names and descriptions that should be treated as sensitive/secure inputs. */
 const SENSITIVE_FIELD_PATTERN = /(password|passphrase|secret|token|api[_\s-]*key|private[_\s-]*key|credential)/i;
+/** Mirrors @opengsd/mcp-server's ask_user_questions host elicitation timeout. */
+const WORKFLOW_ELICIT_TIMEOUT_MS = 10 * 60 * 1000;
+/** Close the local form just before the server drops the MCP elicitation request. */
+const WORKFLOW_ELICIT_TIMEOUT_SKEW_MS = 1_000;
+export const CLAUDE_CODE_INTERVIEW_FORM_TIMEOUT_MS = Math.max(1, WORKFLOW_ELICIT_TIMEOUT_MS - WORKFLOW_ELICIT_TIMEOUT_SKEW_MS);
+const ELICITATION_EXPIRED_NOTICE = "Question expired before you answered - the form was closed and no answers were sent.";
+const activeAskUserQuestionElicitationTimeoutAborters = new Set();
+function isAskUserQuestionsToolName(toolName) {
+    const name = String(toolName ?? "");
+    return name === "ask_user_questions" || name.endsWith("__ask_user_questions");
+}
+function isAskUserQuestionsTimedOutResult(toolCall, result) {
+    return isAskUserQuestionsToolName(toolCall.name) && result.details?.timed_out === true;
+}
+function abortActiveAskUserQuestionElicitationsForTimeout() {
+    if (!isInteractiveElicitationInFlight())
+        return;
+    for (const abort of [...activeAskUserQuestionElicitationTimeoutAborters]) {
+        abort();
+    }
+}
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -175,30 +197,44 @@ function extractMessageText(msg) {
     }
     return "";
 }
+// Patterns are anchored to the `UNIT: <Phase>` dispatch header ONLY. The old
+// patterns also matched bare slugs (`run-uat`, `plan-slice`, `gsd_plan_slice`,
+// …) anywhere in the text, so any incidental occurrence — a branch name like
+// `milestone/M039`, an untracked file `m039-s05-…spec.ts`, a forensic report,
+// or the user literally typing "slice"/"UAT" while describing a problem — would
+// misclassify the turn as a dispatched unit. Only the dispatch header is an
+// authoritative phase signal, so match nothing else.
 const GSD_PHASE_PATTERNS = [
-    ["run-uat", /\b(?:UNIT:\s*Run UAT|run-uat)\b/i],
-    ["complete-milestone", /\b(?:UNIT:\s*Complete Milestone|complete-milestone)\b/i],
-    ["validate-milestone", /\b(?:UNIT:\s*Validate Milestone|validate-milestone)\b/i],
-    ["reassess-roadmap", /\b(?:UNIT:\s*Reassess Roadmap|reassess-roadmap)\b/i],
-    ["complete-slice", /\b(?:UNIT:\s*Complete Slice|complete-slice)\b/i],
-    ["replan-slice", /\b(?:UNIT:\s*Replan Slice|replan-slice)\b/i],
-    ["refine-slice", /\b(?:UNIT:\s*Refine Slice|refine-slice)\b/i],
-    ["plan-slice", /\b(?:UNIT:\s*Plan Slice|plan-slice|gsd_plan_slice)\b/i],
-    ["plan-milestone", /\b(?:UNIT:\s*Plan Milestone|plan-milestone|gsd_plan_milestone)\b/i],
-    ["execute-task", /\b(?:UNIT:\s*Execute Task|execute-task|execute-task-simple|reactive-execute)\b/i],
-    ["gate-evaluate", /\b(?:UNIT:\s*Gate Evaluate|gate-evaluate|gsd_save_gate_result)\b/i],
-    ["research-milestone", /\b(?:UNIT:\s*Research Milestone|research-milestone)\b/i],
-    ["research-slice", /\b(?:UNIT:\s*Research Slice|research-slice)\b/i],
-    ["research-decision", /\b(?:research decision|research-decision)\b/i],
-    ["discuss-milestone", /\b(?:Discuss milestone|discuss-milestone)\b/i],
-    ["discuss-slice", /\b(?:Discuss slice|discuss-slice)\b/i],
-    ["discuss-project", /\b(?:discuss-project|Discuss project)\b/i],
-    ["discuss-requirements", /\b(?:discuss-requirements|Discuss requirements)\b/i],
+    ["run-uat", /\bUNIT:\s*Run UAT\b/i],
+    ["complete-milestone", /\bUNIT:\s*Complete Milestone\b/i],
+    ["validate-milestone", /\bUNIT:\s*Validate Milestone\b/i],
+    ["reassess-roadmap", /\bUNIT:\s*Reassess Roadmap\b/i],
+    ["complete-slice", /\bUNIT:\s*Complete Slice\b/i],
+    ["replan-slice", /\bUNIT:\s*Replan Slice\b/i],
+    ["refine-slice", /\bUNIT:\s*Refine Slice\b/i],
+    ["plan-slice", /\bUNIT:\s*Plan Slice\b/i],
+    ["plan-milestone", /\bUNIT:\s*Plan Milestone\b/i],
+    ["execute-task", /\bUNIT:\s*Execute Task\b/i],
+    ["gate-evaluate", /\bUNIT:\s*Gate Evaluate\b/i],
+    ["research-milestone", /\bUNIT:\s*Research Milestone\b/i],
+    ["research-slice", /\bUNIT:\s*Research Slice\b/i],
+    ["research-decision", /\bUNIT:\s*Research Decision\b/i],
+    ["discuss-milestone", /\bUNIT:\s*Discuss Milestone\b/i],
+    ["discuss-slice", /\bUNIT:\s*Discuss Slice\b/i],
+    ["discuss-project", /\bUNIT:\s*Discuss Project\b/i],
+    ["discuss-requirements", /\bUNIT:\s*Discuss Requirements\b/i],
 ];
+/** The set of GSD phases this adapter recognises, derived from the patterns above. */
+const KNOWN_GSD_PHASES = new Set(GSD_PHASE_PATTERNS.map(([phase]) => phase));
 export function inferGsdPhaseFromContext(context) {
+    // Scan only the system prompt and the most recent user directive. Scanning
+    // the entire scrollback let a phase header that merely appeared in history
+    // (e.g. a SUMMARY the agent read, or a pasted prior dispatch) re-classify
+    // every subsequent turn.
+    const lastUser = [...context.messages].reverse().find((m) => m.role === "user");
     const text = [
         context.systemPrompt ?? "",
-        ...context.messages.map((message) => extractMessageText(message)),
+        lastUser ? extractMessageText(lastUser) : "",
     ].join("\n");
     for (const [phase, pattern] of GSD_PHASE_PATTERNS) {
         if (pattern.test(text))
@@ -222,6 +258,26 @@ export function resolveGsdPhaseForSdk(context, projectRoot) {
             return guided.unitType;
         }
     }
+    // Auto-mode records the dispatched unit type before each turn — that is the
+    // authoritative phase, so prefer it over any inference. (Guided interactive
+    // dispatch is handled above via getGuidedUnitContext.) Ignore `hook/*`
+    // pseudo-units and anything not a recognised GSD phase.
+    const autoUnit = getActiveAutoUnitType();
+    if (autoUnit && KNOWN_GSD_PHASES.has(autoUnit)) {
+        return autoUnit;
+    }
+    // No authoritative guided/auto signal → ad-hoc turn. Do NOT regex-infer a
+    // phase from prose: that would fire the workflow MCP preflight and, for
+    // run-uat, strip Bash/Write/Edit/gsd_exec for the rest of the session the
+    // moment the conversation (or the GSD system prompt itself) happened to
+    // mention a phase token. An ad-hoc turn keeps the full tool surface.
+    //
+    // The header-anchored inference remains only as a last resort while auto is
+    // running but the current unit wasn't recorded for some reason; even then it
+    // matches the `UNIT:` dispatch header only, never bare slugs in scrollback.
+    if (!isAutoActive()) {
+        return undefined;
+    }
     return inferGsdPhaseFromContext(context);
 }
 /**
@@ -250,8 +306,10 @@ export function buildPromptFromContext(context, toolContext = {}) {
         ? "- GSD workflow tools (gsd_exec, gsd_slice_complete, gsd_task_complete, gsd_plan_slice, gsd_save_gate_result, etc.) " +
             `are MCP tools — call them as mcp__${toolContext.workflowMcpServerName}__<tool_name> ` +
             `(e.g. mcp__${toolContext.workflowMcpServerName}__gsd_exec, mcp__${toolContext.workflowMcpServerName}__gsd_save_gate_result)\n` +
-            `- Structured user input: call mcp__${toolContext.workflowMcpServerName}__ask_user_questions. ` +
-            "Do not call bare ask_user_questions. Do not call native AskUserQuestion.\n"
+            (toolContext.questionToolAvailable !== false
+                ? `- Structured user input: call mcp__${toolContext.workflowMcpServerName}__ask_user_questions. ` +
+                    "Do not call bare ask_user_questions. Do not call native AskUserQuestion.\n"
+                : "")
         : "- GSD workflow MCP tools are unavailable in this Claude Code run.\n";
     const toolSearchLine = toolContext.workflowMcpServerName
         ? "- ToolSearch is available only for Claude Code deferred workflow MCP hydration. " +
@@ -1201,17 +1259,40 @@ export function createClaudeCodeElicitationHandler(ui) {
             // it does not tear down the very elicitation that IS the human boundary
             // (#cc-elicitation-self-cancel). It clears in the finally on every exit.
             const elicId = "cc-elicit-" + (request.id ?? `${Date.now()}-${nextElicitationSeq()}`);
+            const formAbortController = new AbortController();
+            let expiryNoticeShown = false;
+            const abortExpiredForm = () => {
+                if (formAbortController.signal.aborted)
+                    return;
+                formAbortController.abort();
+                if (!expiryNoticeShown) {
+                    expiryNoticeShown = true;
+                    ui.notify(ELICITATION_EXPIRED_NOTICE, "warning");
+                }
+            };
+            const forwardSdkAbort = () => {
+                if (!formAbortController.signal.aborted)
+                    formAbortController.abort();
+            };
+            if (signal.aborted) {
+                forwardSdkAbort();
+            }
+            else {
+                signal.addEventListener("abort", forwardSdkAbort, { once: true });
+            }
+            const expiryTimer = setTimeout(abortExpiredForm, CLAUDE_CODE_INTERVIEW_FORM_TIMEOUT_MS);
             markInteractiveElicitationStart();
             markToolStart(elicId, "ask_user_questions");
+            activeAskUserQuestionElicitationTimeoutAborters.add(abortExpiredForm);
             try {
-                const interviewResult = await showInterviewRound(questions, { signal, overlay: true }, { ui }).catch(() => undefined);
+                const interviewResult = await showInterviewRound(questions, { signal: formAbortController.signal, overlay: true }, { ui }).catch(() => undefined);
                 if (interviewResult === undefined) {
                     // `await` so the dialog human-wait stays inside try/finally and the
                     // in-flight guard is held until the dialog resolves. Without it,
                     // `finally` runs the moment the promise is created and the fallback
                     // wait runs with zero in-flight tools — reintroducing the
                     // self-cancel on this path (Bugbot #1c00624d).
-                    return await promptElicitationWithDialogs(request, questions, ui, signal);
+                    return await promptElicitationWithDialogs(request, questions, ui, formAbortController.signal);
                 }
                 if (Object.keys(interviewResult.answers).length === 0) {
                     // A system/host teardown (compaction, session_switch, true
@@ -1228,6 +1309,9 @@ export function createClaudeCodeElicitationHandler(ui) {
                 };
             }
             finally {
+                clearTimeout(expiryTimer);
+                signal.removeEventListener("abort", forwardSdkAbort);
+                activeAskUserQuestionElicitationTimeoutAborters.delete(abortExpiredForm);
                 markToolEnd(elicId);
                 markInteractiveElicitationEnd();
             }
@@ -1378,12 +1462,24 @@ function workflowMcpServerNameFromAllowedTools(allowedTools) {
     }
     return undefined;
 }
+function workflowQuestionToolAvailableFromAllowedTools(allowedTools, workflowMcpServerName, gsdPhase) {
+    if (!workflowMcpServerName || !gsdPhase)
+        return undefined;
+    return Array.isArray(allowedTools)
+        && allowedTools.includes(`mcp__${workflowMcpServerName}__ask_user_questions`);
+}
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isStringRecord(value) {
     return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
+export function resolveWorkflowMcpPreflightServerConfig(mcpServers, workflowServerName) {
+    if (!workflowServerName || !isRecord(mcpServers))
+        return undefined;
+    const workflowServerConfig = mcpServers[workflowServerName];
+    return isRecord(workflowServerConfig) ? workflowServerConfig : undefined;
+}
 function cloneSdkMcpServerConfig(config) {
     if (!isRecord(config))
         return undefined;
@@ -1707,6 +1803,17 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
+let capturedClaudeCodeUIContext;
+/**
+ * Capture the active extension UI context from `before_provider_request`. Core
+ * invokes `streamSimple` with a plain `SimpleStreamOptions` (no
+ * `extensionUIContext`), so without this the elicitation handler is never wired
+ * and `ask_user_questions` immediately returns cancelled. See index.ts, which
+ * registers the hook that calls this.
+ */
+export function setClaudeCodeUIContext(ui) {
+    capturedClaudeCodeUIContext = ui;
+}
 /**
  * GSD streamSimple function that delegates to the Claude Agent SDK.
  *
@@ -1725,6 +1832,8 @@ function createSdkAttemptMessageState() {
         builder: null,
         intermediateToolBlocks: [],
         toolResultsById: new Map(),
+        toolCompletionTargetsById: new Map(),
+        emittedExternalToolResultIds: new Set(),
     };
 }
 /** Async pump that drives the Claude Agent SDK's async-iterable message stream and pushes events into `stream`. */
@@ -1736,7 +1845,7 @@ async function pumpSdkMessages(model, context, options, stream) {
     try {
         const permissionMode = await resolveClaudePermissionMode();
         const claudeOptions = options;
-        const uiContext = claudeOptions?.extensionUIContext;
+        const uiContext = claudeOptions?.extensionUIContext ?? capturedClaudeCodeUIContext;
         const onExternalToolCall = claudeOptions?.onExternalToolCall;
         const onExternalToolResult = claudeOptions?.onExternalToolResult;
         const sdkQueryForTest = claudeOptions?._sdkQueryForTest;
@@ -1769,6 +1878,7 @@ async function pumpSdkMessages(model, context, options, stream) {
         const prompt = buildPromptFromContext(context, {
             workflowMcpServerName,
             browserMcpServerName: browserMcpServerNameFromAllowedTools(sdkOpts.allowedTools),
+            questionToolAvailable: workflowQuestionToolAvailableFromAllowedTools(sdkOpts.allowedTools, workflowMcpServerName, gsdPhase),
         });
         const queryPrompt = buildSdkQueryPrompt(context, prompt);
         // Emit start with an empty partial
@@ -1808,6 +1918,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                         unitType: gsdPhase,
                         workflowServerName: workflowMcpServerName,
                         projectRoot,
+                        workflowServerConfig: resolveWorkflowMcpPreflightServerConfig(sdkOpts.mcpServers, workflowMcpServerName),
                         signal: options?.signal,
                     });
                     if (preflightError) {
@@ -1828,7 +1939,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                 }
             }
             sdkAttemptLoop: for (let readinessAttempt = 0;; readinessAttempt++) {
-                let { builder, intermediateToolBlocks, toolResultsById } = createSdkAttemptMessageState();
+                let { builder, intermediateToolBlocks, toolResultsById, toolCompletionTargetsById, emittedExternalToolResultIds, } = createSdkAttemptMessageState();
                 const controller = new AbortController();
                 const forwardAbort = () => controller.abort();
                 if (options?.signal) {
@@ -1947,7 +2058,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                             case "user": {
                                 // Capture content from the completed turn before resetting
                                 if (builder) {
-                                    for (const block of builder.message.content) {
+                                    for (const [contentIndex, block] of builder.message.content.entries()) {
                                         if (block.type === "text" && block.text) {
                                             lastTextContent = block.text;
                                         }
@@ -1957,6 +2068,10 @@ async function pumpSdkMessages(model, context, options, stream) {
                                         else if (block.type === "toolCall" || block.type === "serverToolUse") {
                                             // Collect tool blocks for externalToolExecution rendering
                                             intermediateToolBlocks.push(block);
+                                            toolCompletionTargetsById.set(block.id, {
+                                                partial: builder.message,
+                                                contentIndex,
+                                            });
                                         }
                                     }
                                 }
@@ -1969,61 +2084,73 @@ async function pumpSdkMessages(model, context, options, stream) {
                                 // Push a synthetic toolcall_end for each tool call from this turn
                                 // so the TUI can render tool results in real-time during the SDK
                                 // session instead of waiting until the entire session completes.
-                                if (builder) {
-                                    for (const block of builder.message.content) {
-                                        const extResult = block.externalResult;
-                                        if (!extResult)
-                                            continue;
-                                        const contentIndex = builder.message.content.indexOf(block);
-                                        if (contentIndex < 0)
-                                            continue;
-                                        const suppressDuplicateUnavailable = shouldSuppressDuplicateToolUnavailableBlock(block, builder.message.content);
-                                        // Push synthetic completion events with result attached so the
-                                        // chat-controller can update pending ToolExecutionComponents.
-                                        if (block.type === "toolCall") {
-                                            if (suppressDuplicateUnavailable) {
-                                                delete block.externalResult;
-                                                stream.push({
-                                                    type: "toolcall_end",
-                                                    contentIndex,
-                                                    toolCall: block,
-                                                    partial: builder.message,
-                                                });
-                                                block.externalResult = extResult;
-                                                continue;
-                                            }
-                                            try {
-                                                await onExternalToolResult?.({
-                                                    toolCall: block,
-                                                    result: extResult,
-                                                });
-                                            }
-                                            catch (error) {
-                                                console.warn("[claude-code] onExternalToolResult callback failed:", error);
-                                            }
+                                for (const block of intermediateToolBlocks) {
+                                    if (block.type !== "toolCall" && block.type !== "serverToolUse")
+                                        continue;
+                                    if (emittedExternalToolResultIds.has(block.id))
+                                        continue;
+                                    const target = toolCompletionTargetsById.get(block.id);
+                                    if (!target)
+                                        continue;
+                                    const extResult = block.externalResult;
+                                    if (!extResult)
+                                        continue;
+                                    const suppressDuplicateUnavailable = shouldSuppressDuplicateToolUnavailableBlock(block, target.partial.content);
+                                    // Push synthetic completion events with result attached so the
+                                    // chat-controller can update pending ToolExecutionComponents.
+                                    if (block.type === "toolCall") {
+                                        if (isAskUserQuestionsTimedOutResult(block, extResult)) {
+                                            abortActiveAskUserQuestionElicitationsForTimeout();
+                                        }
+                                        if (suppressDuplicateUnavailable) {
+                                            delete block.externalResult;
                                             stream.push({
                                                 type: "toolcall_end",
-                                                contentIndex,
+                                                contentIndex: target.contentIndex,
                                                 toolCall: block,
-                                                partial: builder.message,
+                                                partial: target.partial,
                                             });
+                                            block.externalResult = extResult;
+                                            emittedExternalToolResultIds.add(block.id);
+                                            continue;
                                         }
-                                        else if (block.type === "serverToolUse") {
-                                            try {
-                                                await onExternalToolResult?.({
-                                                    toolCall: serverToolUseToToolCallLike(block),
-                                                    result: extResult,
-                                                });
-                                            }
-                                            catch (error) {
-                                                console.warn("[claude-code] onExternalToolResult callback failed:", error);
-                                            }
-                                            stream.push({
-                                                type: "server_tool_use",
-                                                contentIndex,
-                                                partial: builder.message,
+                                        try {
+                                            await onExternalToolResult?.({
+                                                toolCall: block,
+                                                result: extResult,
+                                            });
+                                        }
+                                        catch (error) {
+                                            console.warn("[claude-code] onExternalToolResult callback failed:", error);
+                                        }
+                                        stream.push({
+                                            type: "toolcall_end",
+                                            contentIndex: target.contentIndex,
+                                            toolCall: block,
+                                            partial: target.partial,
+                                        });
+                                        emittedExternalToolResultIds.add(block.id);
+                                    }
+                                    else if (block.type === "serverToolUse") {
+                                        const toolCall = serverToolUseToToolCallLike(block);
+                                        if (isAskUserQuestionsTimedOutResult(toolCall, extResult)) {
+                                            abortActiveAskUserQuestionElicitationsForTimeout();
+                                        }
+                                        try {
+                                            await onExternalToolResult?.({
+                                                toolCall,
+                                                result: extResult,
                                             });
                                         }
+                                        catch (error) {
+                                            console.warn("[claude-code] onExternalToolResult callback failed:", error);
+                                        }
+                                        stream.push({
+                                            type: "server_tool_use",
+                                            contentIndex: target.contentIndex,
+                                            partial: target.partial,
+                                        });
+                                        emittedExternalToolResultIds.add(block.id);
                                     }
                                 }
                                 builder = null;

package/dist/resources/extensions/cursor-cli/index.js

@@ -0,0 +1,16 @@
+import { CURSOR_AGENT_MODELS } from "./models.js";
+import { isCursorAgentReady } from "./readiness.js";
+import { streamViaCursorAgent } from "./stream-adapter.js";
+export default function cursorCli(pi) {
+    if (process.env.GSD_CURSOR_DISABLE === "1")
+        return;
+    pi.registerProvider("cursor-agent", {
+        name: "Cursor Agent",
+        authMode: "externalCli",
+        api: "cursor-stream-json",
+        baseUrl: "local://cursor-agent",
+        isReady: isCursorAgentReady,
+        streamSimple: streamViaCursorAgent,
+        models: CURSOR_AGENT_MODELS,
+    });
+}

package/dist/resources/extensions/cursor-cli/models.js

@@ -0,0 +1,63 @@
+const ZERO_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+const CURSOR_INPUT = ["text"];
+export const CURSOR_AGENT_MODELS = [
+    {
+        id: "composer-2.5",
+        name: "Composer 2.5 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 64_000,
+    },
+    {
+        id: "claude-sonnet-4-6",
+        name: "Claude Sonnet 4.6 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 64_000,
+    },
+    {
+        id: "claude-opus-4-7",
+        name: "Claude Opus 4.7 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+    },
+    {
+        id: "gpt-5.5",
+        name: "GPT-5.5 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+    },
+    {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "grok-4",
+        name: "Grok 4 (via Cursor)",
+        reasoning: true,
+        input: CURSOR_INPUT,
+        cost: ZERO_COST,
+        contextWindow: 256_000,
+        maxTokens: 64_000,
+    },
+];

package/dist/resources/extensions/cursor-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/cursor-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/dist/resources/extensions/cursor-cli/readiness.js

@@ -0,0 +1,128 @@
+import { execFileSync } from "node:child_process";
+const VERSION_TIMEOUT_MS = 5_000;
+const STATUS_TIMEOUT_MS = 10_000;
+const CHECK_INTERVAL_MS = 30_000;
+let cachedBinaryPresent = null;
+let cachedAuthed = null;
+let lastCheckMs = 0;
+export function getCursorAgentCommand(platform = process.platform) {
+    return platform === "win32" ? "cursor-agent.cmd" : "cursor-agent";
+}
+export function getCursorAgentCommandCandidates(platform = process.platform) {
+    const command = getCursorAgentCommand(platform);
+    return platform === "win32" ? [command, "cursor-agent.exe", "cursor-agent"] : [command];
+}
+export function buildCursorAgentSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
+    }
+    return { command, args };
+}
+function debugLog(...parts) {
+    if (process.env.GSD_CURSOR_DEBUG) {
+        process.stderr.write(`[cursor-readiness] ${parts.map((part) => String(part)).join(" ")}\n`);
+    }
+}
+function spawnCursorAgent(command, args, timeout) {
+    const invocation = buildCursorAgentSpawnInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, { timeout, stdio: "pipe" });
+}
+function findWorkingCommand() {
+    for (const command of getCursorAgentCommandCandidates()) {
+        try {
+            spawnCursorAgent(command, ["--version"], VERSION_TIMEOUT_MS);
+            debugLog("version probe ok via", command);
+            return command;
+        }
+        catch (error) {
+            debugLog("version probe failed for", command, error.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function parseCursorAgentStatus(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            for (const key of ["authenticated", "loggedIn", "logged_in", "isAuthenticated"]) {
+                if (typeof parsed[key] === "boolean")
+                    return parsed[key];
+            }
+        }
+        catch {
+            // Fall through to text heuristics.
+        }
+    }
+    const lower = trimmed.toLowerCase();
+    if (/not authenticated|not logged in|no credentials|logged out|unauthenticated/.test(lower))
+        return false;
+    if (/authenticated|logged in|signed in|cursor account|subscription/.test(lower))
+        return true;
+    return null;
+}
+export function isCursorAgentApiKeyValue(value) {
+    const trimmed = value?.trim();
+    return Boolean(trimmed && trimmed !== "cli");
+}
+function hasCursorApiKey() {
+    return isCursorAgentApiKeyValue(process.env.CURSOR_API_KEY);
+}
+function probeAuth(command) {
+    if (hasCursorApiKey())
+        return true;
+    for (const args of [["agent", "status", "--json"], ["status", "--json"], ["agent", "status"], ["status"]]) {
+        try {
+            const out = spawnCursorAgent(command, args, STATUS_TIMEOUT_MS).toString();
+            debugLog("status output", args.join(" "), out.slice(0, 200));
+            const parsed = parseCursorAgentStatus(out);
+            if (parsed !== null)
+                return parsed;
+        }
+        catch (error) {
+            debugLog("status failed", args.join(" "), error.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function isCursorAgentReadyUncached() {
+    const command = findWorkingCommand();
+    if (!command)
+        return false;
+    return probeAuth(command) === true;
+}
+function refreshCache() {
+    const now = Date.now();
+    if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS)
+        return;
+    lastCheckMs = now;
+    const command = findWorkingCommand();
+    if (!command) {
+        cachedBinaryPresent = false;
+        cachedAuthed = false;
+        return;
+    }
+    cachedBinaryPresent = true;
+    const authed = probeAuth(command);
+    if (authed === null) {
+        if (cachedAuthed === null)
+            cachedAuthed = false;
+        return;
+    }
+    cachedAuthed = authed;
+}
+export function isCursorAgentBinaryPresent() {
+    refreshCache();
+    return cachedBinaryPresent ?? false;
+}
+export function isCursorAgentReady() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+export function clearCursorAgentReadinessCache() {
+    cachedBinaryPresent = null;
+    cachedAuthed = null;
+    lastCheckMs = 0;
+}