@opengsd/gsd-pi 1.4.0 → 1.5.0

package/README.md

@@ -19,7 +19,7 @@ It combines a terminal agent, project workflow tools, worktree-aware Git automat
 - **Autonomous project workflow** — Break work into milestones, slices, and tasks, then let auto mode plan, implement, verify, and advance.
 - **Worktree-aware Git automation** — Keep implementation work isolated while preserving a reviewable main checkout.
 - **Local project memory** — Store project requirements, decisions, runtime notes, generated plans, summaries, and validation evidence under `.gsd/`.
-- **Multi-provider model routing** — Use the provider your team already has, with configurable defaults and per-phase model preferences.
+- **Multi-provider model routing** — Use the provider your team already has, including API keys, OAuth providers, and external CLI providers such as Claude Code and Cursor Agent.
 - **Extension surface** — Add project-specific commands, tools, skills, and UI integrations through bundled or community extensions.
 - **Terminal and web surfaces** — Use the TUI by default, or launch `gsd --web` when a visual control plane fits the work better than a terminal.
 
@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.4.0**
+Latest release: **v1.5.0**
 
-- **models:** Add Claude Sonnet 5.
-- **Added:** Add Hermes plugin installer.
-- **compat:** Report .planning/ drift in /gsd sync and doctor.
-- **compat:** Project to .planning/ inside renderAllFromDb.
-- **compat:** Add external-planning-edit drift handler.
-- **compat:** Add DB → .planning/ projection writer.
-- **compat:** Extract .planning/ layout detector.
-- **compat:** Extend marker schema 1→2 with planning field.
+- **hermes:** Add /gsd new-milestone command for chat-driven milestone creation (#1162).
+- **gsd:** Make CODEBASE.md workspace-aware in parent mode.
+- **gsd:** Doctor probe + validation for parent-workspace repos.
+- **gsd:** Surface per-repo git health in /gsd status + document limits.
+- **gsd:** Wire repository assignment into slice/task planning.
+- **gsd:** Add parent-workspace discovery UX + document nested-only layout.
+- **provider:** Add Cursor Agent provider.
+- **gsd:** Make workspace.mode parent behavioral (mode contract).
 
 <!-- release-highlights:end -->
 
@@ -158,7 +158,7 @@ Need help choosing settings? Use the [GSD Pi web configurator](https://pi.opengs
 gsd
 ```
 
-Run the setup flow, choose your preferred model provider, and open a project directory. GSD stores project planning and runtime state in `.gsd/`, with gitignored sibling runtime directories such as `.gsd-backups/` for migration snapshots. Stale `.gsd-backups/migrate-*` snapshots are pruned after 30 days once the flat-phase `.gsd/phases/` migration is complete.
+Run the setup flow, choose your preferred model provider, and open a project directory. Cursor Agent users can choose the `cursor-agent` provider after installing and authenticating the local `cursor-agent` CLI; its default model is `composer-2.5`, and `CURSOR_API_KEY` is supported as an auth signal. GSD stores project planning and runtime state in `.gsd/`, with gitignored sibling runtime directories such as `.gsd-backups/` for migration snapshots. Stale `.gsd-backups/migrate-*` snapshots are pruned after 30 days once the flat-phase `.gsd/phases/` migration is complete.
 
 For a full first-run walkthrough, see [Getting Started With gsd-pi](./docs/user-docs/getting-started.md).
 

package/dist/onboarding.js

@@ -16,6 +16,7 @@ import { renderGsdPiLogo, GSD_PI_BRAND, GSD_WEBSITE } from './logo.js';
 import { agentDir } from './app-paths.js';
 import { isClaudeCliReady } from './claude-cli-check.js';
 import { isAntigravityCliReady, isGeminiCliReady } from './resources/extensions/google-cli/readiness.js';
+import { isCursorAgentReady } from './resources/extensions/cursor-cli/readiness.js';
 import { markOnboardingComplete, markStepCompleted, markStepSkipped, isOnboardingComplete, } from './resources/extensions/gsd/onboarding-state.js';
 import { getLlmProviderIds } from './resources/extensions/gsd/setup-catalog.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -359,6 +360,9 @@ export async function runLlmStep(p, pc, authStorage) {
     if (isClaudeCliReady()) {
         authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'uses your existing Claude subscription' });
     }
+    if (isCursorAgentReady()) {
+        authOptions.push({ value: 'cursor-agent-cli', label: 'Use Cursor Agent', hint: 'uses your existing Cursor subscription' });
+    }
     if (isAntigravityCliReady()) {
         authOptions.push({ value: 'antigravity-cli', label: 'Use Antigravity CLI', hint: 'recommended — replaces Gemini CLI for individuals' });
     }
@@ -388,6 +392,13 @@ export async function runLlmStep(p, pc, authStorage) {
         persistDefaultProvider('claude-code');
         return true;
     }
+    if (method === 'cursor-agent-cli') {
+        p.log.success('Cursor Agent detected — routing through local CLI');
+        p.log.info('Your Cursor subscription will be used for inference. No API key needed.');
+        authStorage.set('cursor-agent', { type: 'api_key', key: 'cli' });
+        persistDefaultProvider('cursor-agent');
+        return true;
+    }
     if (method === 'gemini-cli') {
         p.log.warn('Google Gemini CLI is deprecated for individual users — install Antigravity: https://antigravity.google');
         p.log.success('Google Gemini CLI detected — routing through local CLI');

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-6cd0d33f2832351c
+f30abebf080db301

package/dist/resources/GSD-WORKFLOW.md

@@ -5,7 +5,7 @@
 > **When to read this:** At the start of any session working on GSD-managed work, or when loaded by `/gsd`.
 >
 > **After reading this, always read `.gsd/STATE.md` to find out what's next.**
-> If the milestone has a `CONTEXT.md`, read that too. If the active slice has an `S##-CONTEXT.md`, read that as well — these files contain project-specific decisions, reference paths, and implementation guidance that this generic methodology doc does not.
+> If the milestone has a `NN-CONTEXT.md`, read that too. If the active slice has an `NN-MM-CONTEXT.md`, read that as well — these files contain project-specific decisions, reference paths, and implementation guidance that this generic methodology doc does not.
 
 ---
 
@@ -14,10 +14,10 @@
 Read these files in order and act on what they say:
 
 1. **`.gsd/STATE.md`** — Where are we? What's the next action?
-2. **`.gsd/phases/<active>/ROADMAP.md`** — What's the plan? Which slices are done? (`STATE.md` tells you which milestone is active)
-3. **`.gsd/phases/<active>/CONTEXT.md`** — Milestone-level project decisions, reference paths, constraints. Read this before doing implementation work.
-4. If a slice is active and has one, read **`S##-CONTEXT.md`** — Slice-specific decisions and constraints.
-5. If a slice is active, read its **`S##-PLAN.md`** — Which tasks exist? Which are done?
+2. **`.gsd/phases/<NN-slug>/<NN>-ROADMAP.md`** — What's the plan? Which slices are done? (`STATE.md` tells you which milestone is active)
+3. **`.gsd/phases/<NN-slug>/<NN>-CONTEXT.md`** — Milestone-level project decisions, reference paths, constraints. Read this before doing implementation work.
+4. If a slice is active and has one, read **`<NN>-<MM>-CONTEXT.md`** — Slice-specific decisions and constraints.
+5. If a slice is active, read its **`<NN>-<MM>-PLAN.md`** — Which tasks exist? Which are done?
 6. If `.gsd/CODEBASE.md` exists, skim it for fast structural orientation before broad code exploration.
 7. If a task was interrupted, check for **`continue.md`** in the active slice directory — Resume from there.
 
@@ -47,22 +47,17 @@ All artifacts live in `.gsd/` at the project root:
   DECISIONS.md                              # Append-only decisions register
   CODEBASE.md                               # Generated codebase map cache (auto-refreshed by GSD)
   phases/
-    M001/
-      M001-ROADMAP.md                       # Milestone plan (checkboxes = state)
-      M001-CONTEXT.md                       # Optional: user decisions from discuss phase
-      M001-RESEARCH.md                      # Optional: codebase/tech research
-      M001-SUMMARY.md                       # Milestone rollup (updated as slices complete)
-      slices/
-        S01/
-          S01-PLAN.md                       # Task decomposition for this slice
-          S01-CONTEXT.md                    # Optional: slice-level user decisions
-          S01-RESEARCH.md                   # Optional: slice-level research
-          S01-SUMMARY.md                    # Slice summary (written on completion)
-          S01-UAT.md                        # Non-blocking human test script (written on completion)
-          continue.md                       # Ephemeral: resume point if interrupted
-          tasks/
-            T01-PLAN.md                     # Individual task plan
-            T01-SUMMARY.md                  # Task summary with frontmatter
+    01-foundation/
+      01-ROADMAP.md                         # Milestone plan (checkboxes = state)
+      01-CONTEXT.md                         # Optional: user decisions from discuss phase
+      01-RESEARCH.md                        # Optional: codebase/tech research
+      01-SUMMARY.md                         # Milestone rollup (updated as slices complete)
+      01-01-PLAN.md                         # Task decomposition for the first slice
+      01-01-CONTEXT.md                      # Optional: slice-level user decisions
+      01-01-RESEARCH.md                     # Optional: slice-level research
+      01-01-SUMMARY.md                      # Slice summary (written on completion)
+      01-01-UAT.md                          # Non-blocking human test script (written on completion)
+      01-01-CONTINUE.md                     # Ephemeral: resume point if interrupted
 ```
 
 ---
@@ -424,7 +419,7 @@ key_decisions:
 patterns_established:
   - "Pattern name and where it lives"
 drill_down_paths:
-  - .gsd/phases/M001/slices/S01/tasks/T01-PLAN.md
+  - .gsd/phases/01-foundation/01-01-PLAN.md
 duration: 15min
 verification_result: pass
 completed_at: 2026-03-07T16:00:00Z
@@ -635,10 +630,10 @@ These are soft caps — exceed them when genuinely needed, but don't let summari
 
 This methodology doc is generic. Project-specific guidance belongs in the milestone and slice context files:
 
-- **`.gsd/phases/<active>/CONTEXT.md`** — milestone-level architecture decisions, reference file paths, and implementation constraints
-- **`.gsd/phases/<active>/slices/S##/S##-CONTEXT.md`** — slice-level decisions, edge cases, and narrow implementation guidance when present
+- **`.gsd/phases/<NN-slug>/<NN>-CONTEXT.md`** — milestone-level architecture decisions, reference file paths, and implementation constraints
+- **`.gsd/phases/<NN-slug>/<NN>-<MM>-CONTEXT.md`** — slice-level decisions, edge cases, and narrow implementation guidance when present
 
-**Always read the active milestone's `CONTEXT.md` before starting implementation work.** If the active slice also has `S##-CONTEXT.md`, read that too. These files tell you what decisions are locked, what files to reference, and how to verify your work in this specific project.
+**Always read the active milestone's `<NN>-CONTEXT.md` before starting implementation work.** If the active slice also has `<NN>-<MM>-CONTEXT.md`, read that too. These files tell you what decisions are locked, what files to reference, and how to verify your work in this specific project.
 
 ---
 

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

@@ -21,7 +21,7 @@ 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";
@@ -51,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
 // ---------------------------------------------------------------------------
@@ -1238,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
@@ -1265,6 +1309,9 @@ export function createClaudeCodeElicitationHandler(ui) {
                 };
             }
             finally {
+                clearTimeout(expiryTimer);
+                signal.removeEventListener("abort", forwardSdkAbort);
+                activeAskUserQuestionElicitationTimeoutAborters.delete(abortExpiredForm);
                 markToolEnd(elicId);
                 markInteractiveElicitationEnd();
             }
@@ -1785,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`. */
@@ -1890,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) {
@@ -2009,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;
                                         }
@@ -2019,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,
+                                            });
                                         }
                                     }
                                 }
@@ -2031,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;
+}