gsd-pi 2.68.1 → 2.69.0-dev.232905b

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -5,7 +5,7 @@
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
 import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
-import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides } from "./model-router.js";
+import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
@@ -177,12 +177,38 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
             const ok = await pi.setModel(model, { persist: false });
             if (ok) {
                 appliedModel = model;
+                // ADR-005: Adjust active tool set for the selected model's provider capabilities.
+                // Hard-filter incompatible tools, then let extensions override via adjust_tool_set hook.
+                const activeToolNames = pi.getActiveTools();
+                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api);
+                let finalToolNames = compatibleTools;
+                // Fire adjust_tool_set hook — extensions can override the filtered tool set
+                if (routingConfig.hooks !== false) {
+                    const hookResult = await pi.emitAdjustToolSet({
+                        selectedModelApi: model.api,
+                        selectedModelProvider: model.provider,
+                        selectedModelId: model.id,
+                        activeToolNames,
+                        filteredTools: removedTools,
+                    });
+                    if (hookResult?.toolNames) {
+                        finalToolNames = hookResult.toolNames;
+                    }
+                }
+                // Apply the filtered tool set if any tools were removed
+                if (removedTools.length > 0 || finalToolNames.length !== activeToolNames.length) {
+                    pi.setActiveTools(finalToolNames);
+                }
                 if (verbose) {
                     const fallbackNote = modelId === effectiveModelConfig.primary
                         ? ""
                         : ` (fallback from ${effectiveModelConfig.primary})`;
                     const phase = unitPhaseLabel(unitType);
                     ctx.ui.notify(`Model [${phase}]${routingTierLabel}: ${model.provider}/${model.id}${fallbackNote}`, "info");
+                    // ADR-005: Report tools filtered due to provider incompatibility
+                    if (removedTools.length > 0) {
+                        ctx.ui.notify(`Tool compatibility: ${removedTools.length} tools filtered for ${model.api} — ${removedTools.join(", ")}`, "info");
+                    }
                 }
                 break;
             }

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -415,4 +415,11 @@ export function registerHooks(pi) {
         // Default: no override — let capability scoring handle selection
         return undefined;
     });
+    // Tool set adaptation hook (ADR-005 Phase 4)
+    // Extensions can override tool set after model selection by returning { toolNames: [...] }
+    // Return undefined to let the built-in provider compatibility filtering proceed.
+    pi.on("adjust_tool_set", async (_event) => {
+        // Default: no override — let provider capability filtering handle tool set
+        return undefined;
+    });
 }

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -16,6 +16,7 @@ import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";
 import { toPosixPath } from "../../shared/mod.js";
 import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../../cmux/index.js";
+import { autoEnableCmuxPreferences } from "../commands-cmux.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 /**
  * Bundled skill triggers — resolved dynamically at runtime instead of
@@ -64,10 +65,13 @@ export async function buildBeforeAgentStartResult(event, ctx) {
         shortcutDashboard: formatShortcut("Ctrl+Alt+G"),
         shortcutShell: formatShortcut("Ctrl+Alt+B"),
     });
-    const loadedPreferences = loadEffectiveGSDPreferences();
+    let loadedPreferences = loadEffectiveGSDPreferences();
     if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
         markCmuxPromptShown();
-        ctx.ui.notify("cmux detected. Run /gsd cmux on to enable sidebar metadata, notifications, and visual subagent splits for this project.", "info");
+        if (autoEnableCmuxPreferences()) {
+            loadedPreferences = loadEffectiveGSDPreferences();
+            ctx.ui.notify("cmux detected — auto-enabled. Run /gsd cmux off to disable.", "info");
+        }
     }
     let preferenceBlock = "";
     if (loadedPreferences) {

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -40,13 +40,9 @@ let activeQueuePhase = false;
 let pendingGateId = null;
 /**
  * Recognized gate question ID patterns.
- * These appear in both discuss-prepared.md (4-layer) and discuss.md (depth/requirements/roadmap).
+ * These appear in discuss.md (depth/requirements/roadmap).
  */
 const GATE_QUESTION_PATTERNS = [
-    "layer1_scope_gate",
-    "layer2_architecture_gate",
-    "layer3_error_gate",
-    "layer4_quality_gate",
     "depth_verification",
 ];
 /**

package/dist/resources/extensions/gsd/codebase-generator.js

@@ -14,13 +14,20 @@ import { execSync } from "node:child_process";
 import { gsdRoot } from "./paths.js";
 // ─── Defaults ────────────────────────────────────────────────────────────────
 const DEFAULT_EXCLUDES = [
+    // ── AI / tooling meta ──
+    ".agents/",
     ".gsd/",
     ".planning/",
     ".plans/",
     ".claude/",
     ".cursor/",
+    ".bg-shell/",
+    // ── Editor / IDE ──
     ".vscode/",
+    ".idea/",
+    // ── VCS ──
     ".git/",
+    // ── Dependencies & build artifacts ──
     "node_modules/",
     "dist/",
     "build/",
@@ -28,7 +35,12 @@ const DEFAULT_EXCLUDES = [
     "coverage/",
     "__pycache__/",
     ".venv/",
+    "venv/",
     "vendor/",
+    "target/",
+    // ── Misc ──
+    ".cache/",
+    "tmp/",
 ];
 const DEFAULT_MAX_FILES = 500;
 const DEFAULT_COLLAPSE_THRESHOLD = 20;

package/dist/resources/extensions/gsd/commands-cmux.js

@@ -1,8 +1,37 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { clearCmuxSidebar, CmuxClient, detectCmuxEnvironment, resolveCmuxConfig } from "../cmux/index.js";
 import { saveFile } from "./files.js";
 import { getProjectGSDPreferencesPath, loadEffectiveGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+/**
+ * Auto-enable cmux in project preferences when detected but never configured.
+ * Called at boot (before agent start) — no ExtensionCommandContext needed.
+ * Returns true if preferences were written, false if skipped.
+ */
+export function autoEnableCmuxPreferences() {
+    const path = getProjectGSDPreferencesPath();
+    if (!existsSync(path))
+        return false;
+    const existing = loadProjectGSDPreferences();
+    const prefs = existing?.preferences ? { ...existing.preferences } : { version: 1 };
+    prefs.cmux = {
+        enabled: true,
+        notifications: true,
+        sidebar: true,
+        splits: false,
+        browser: false,
+        ...(prefs.cmux ?? {}),
+    };
+    prefs.cmux.enabled = true;
+    prefs.version = prefs.version || 1;
+    const frontmatter = serializePreferencesToFrontmatter(prefs);
+    let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+    const preserved = extractBodyAfterFrontmatter(readFileSync(path, "utf-8"));
+    if (preserved)
+        body = preserved;
+    writeFileSync(path, `---\n${frontmatter}---${body}`, "utf-8");
+    return true;
+}
 function extractBodyAfterFrontmatter(content) {
     const start = content.startsWith("---\n") ? 4 : content.startsWith("---\r\n") ? 5 : -1;
     if (start === -1)

package/dist/resources/extensions/gsd/guided-flow.js

@@ -36,19 +36,7 @@ import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, } from "./workflow-mcp.js";
-import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, formatEcosystemBrief, } from "./preparation.js";
-// ─── Preparation result storage ─────────────────────────────────────────────
-// Stores the most recent preparation result for injection into discuss prompts.
-// S02 will consume this when building the prepared discussion prompt.
-let lastPreparationResult = null;
-/** Get the most recent preparation result (for S02 prompt building). */
-export function getLastPreparationResult() {
-    return lastPreparationResult;
-}
-/** Clear the preparation result (called after discussion completes). */
-export function clearPreparationResult() {
-    lastPreparationResult = null;
-}
+import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -335,7 +323,7 @@ function resolveAvailableModel(modelId, availableModels, currentProvider) {
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId, preamble, _basePath) {
+function buildDiscussPrompt(nextId, preamble, _basePath, preparationContext) {
     const milestoneRel = `.gsd/milestones/${nextId}`;
     const inlinedTemplates = [
         inlineTemplate("project", "Project"),
@@ -347,6 +335,7 @@ function buildDiscussPrompt(nextId, preamble, _basePath) {
     return loadPrompt("discuss", {
         milestoneId: nextId,
         preamble,
+        preparationContext: preparationContext ?? "",
         contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
         roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
         inlinedTemplates,
@@ -377,50 +366,12 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
         multiMilestoneCommitInstruction: buildDocsCommitInstruction("docs: project plan — N milestones"),
     });
 }
-/**
- * Build the prepared discuss prompt with brief injection.
- * Uses the discuss-prepared template which encodes the 4-layer discussion protocol.
- *
- * @param nextId - The milestone ID being discussed
- * @param preamble - Preamble text for the discuss prompt
- * @param _basePath - Root directory of the project (unused, kept for signature consistency)
- * @param prepResult - Preparation result containing briefs to inject
- * @returns The prepared discuss prompt string
- */
-function buildPreparedPrompt(nextId, preamble, _basePath, prepResult) {
-    const milestoneRel = `.gsd/milestones/${nextId}`;
-    // Use context-enhanced instead of context for prepared discussions
-    const inlinedTemplates = [
-        inlineTemplate("project", "Project"),
-        inlineTemplate("requirements", "Requirements"),
-        inlineTemplate("context-enhanced", "Context Enhanced"),
-        inlineTemplate("roadmap", "Roadmap"),
-        inlineTemplate("decisions", "Decisions"),
-    ].join("\n\n---\n\n");
-    // Format the briefs from the preparation result
-    const codebaseBrief = prepResult.codebaseBrief || formatCodebaseBrief(prepResult.codebase);
-    const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
-    const ecosystemBrief = prepResult.ecosystemBrief || formatEcosystemBrief(prepResult.ecosystem);
-    return loadPrompt("discuss-prepared", {
-        milestoneId: nextId,
-        preamble,
-        codebaseBrief,
-        priorContextBrief,
-        ecosystemBrief,
-        contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
-        roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
-        inlinedTemplates,
-        commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): context, requirements, and roadmap`),
-        multiMilestoneCommitInstruction: buildDocsCommitInstruction("docs: project plan — N milestones"),
-    });
-}
 /**
  * Run preparation phase if enabled, then build the discuss prompt.
- * This is the main entry point for new milestone discussions with preparation.
- * Stores the preparation result for S02 to inject into the discuss prompt.
- *
- * When preparation succeeds, uses the discuss-prepared template with brief injection.
- * Falls back to the standard discuss template when preparation is disabled or fails.
+ * Preparation analyzes the codebase and prior context, injecting the results
+ * as supplementary context into the standard discuss template. The discuss
+ * template drives the conversation (asks "What's the vision?" first), while
+ * the preparation briefs give the agent grounding in the existing codebase.
  *
  * @param ctx - Extension command context with UI for progress notifications
  * @param nextId - The milestone ID being discussed
@@ -429,12 +380,12 @@ function buildPreparedPrompt(nextId, preamble, _basePath, prepResult) {
  * @returns The discuss prompt string
  */
 async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
-    // Clear stale preparation result immediately to prevent cross-session/project
-    // state leaks. This ensures data from a prior milestone/project never leaks
-    // into subsequent discussions (adversarial review fix #3602).
-    lastPreparationResult = null;
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
-    // Run preparation if enabled (default: true)
+    // Run preparation if enabled (default: true) — results are injected as
+    // supplementary context into the standard discuss prompt, NOT as a
+    // replacement template. The discuss prompt always leads with "What's the
+    // vision?" so the user defines the scope, not the codebase analysis.
+    let preparationContext = "";
     if (prefs.discuss_preparation !== false) {
         try {
             const prepResult = await runPreparation(basePath, ctx.ui, {
@@ -442,20 +393,24 @@ async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
                 discuss_web_research: prefs.discuss_web_research,
                 discuss_depth: prefs.discuss_depth,
             });
-            lastPreparationResult = prepResult;
-            // Use prepared prompt if preparation was enabled and produced results
             if (prepResult.enabled) {
-                return buildPreparedPrompt(nextId, preamble, basePath, prepResult);
+                const codebaseBrief = prepResult.codebaseBrief || formatCodebaseBrief(prepResult.codebase);
+                const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
+                const parts = [];
+                if (codebaseBrief)
+                    parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
+                if (priorContextBrief)
+                    parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
+                if (parts.length > 0) {
+                    preparationContext = `\n\n## Preparation Context\n\nThe system analyzed the codebase before this discussion. Use these findings as background context — they describe what already exists, NOT what the user wants to build. Always ask the user what they want to build first.\n\n${parts.join("\n\n")}`;
+                }
             }
         }
-        catch {
-            // If preparation throws, ensure stale data doesn't persist
-            lastPreparationResult = null;
+        catch (err) {
+            logWarning("guided", `preparation failed, proceeding without context: ${err.message}`);
         }
     }
-    // Fall back to standard discuss prompt for backward compatibility
-    // lastPreparationResult is already null (cleared at entry or on error)
-    return buildDiscussPrompt(nextId, preamble, basePath);
+    return buildDiscussPrompt(nextId, preamble, basePath, preparationContext);
 }
 /**
  * Bootstrap a .gsd/ project from scratch for headless use.

package/dist/resources/extensions/gsd/model-router.js

@@ -2,10 +2,12 @@
 // Maps complexity tiers to models, enforcing downgrade-only semantics.
 // The user's configured model is always the ceiling.
 import { tierOrdinal } from "./complexity-classifier.js";
+import { getProviderCapabilities } from "@gsd/pi-ai";
+import { getToolCompatibility } from "@gsd/pi-coding-agent";
 // ─── Known Model Tiers ───────────────────────────────────────────────────────
 // Maps known model IDs to their capability tier. Used when tier_models is not
 // explicitly configured to pick the best available model for each tier.
-const MODEL_CAPABILITY_TIER = {
+export const MODEL_CAPABILITY_TIER = {
     // Light-tier models (cheapest)
     "claude-haiku-4-5": "light",
     "claude-3-5-haiku-latest": "light",
@@ -80,15 +82,45 @@ const MODEL_COST_PER_1K_INPUT = {
 // Per-model capability profiles (0–100 scale). Used for capability-aware
 // model selection within an eligible tier set.
 export const MODEL_CAPABILITY_PROFILES = {
+    // ── Anthropic ──────────────────────────────────────────────────────────────
     "claude-opus-4-6": { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
     "claude-sonnet-4-6": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
+    "claude-sonnet-4-5-20250514": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
+    "claude-3-5-sonnet-latest": { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 70, instruction: 82 },
     "claude-haiku-4-5": { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+    "claude-3-5-haiku-latest": { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+    "claude-3-haiku-20240307": { coding: 50, debugging: 40, research: 35, reasoning: 40, speed: 95, longContext: 40, instruction: 65 },
+    "claude-3-opus-latest": { coding: 90, debugging: 85, research: 82, reasoning: 90, speed: 35, longContext: 75, instruction: 88 },
+    // ── OpenAI GPT ─────────────────────────────────────────────────────────────
     "gpt-4o": { coding: 80, debugging: 75, research: 70, reasoning: 75, speed: 65, longContext: 70, instruction: 80 },
     "gpt-4o-mini": { coding: 55, debugging: 45, research: 40, reasoning: 45, speed: 90, longContext: 45, instruction: 70 },
+    "gpt-4-turbo": { coding: 78, debugging: 72, research: 68, reasoning: 72, speed: 50, longContext: 65, instruction: 78 },
+    "gpt-4.1": { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 72, instruction: 82 },
+    "gpt-4.1-mini": { coding: 58, debugging: 48, research: 42, reasoning: 48, speed: 88, longContext: 48, instruction: 72 },
+    "gpt-4.1-nano": { coding: 40, debugging: 30, research: 25, reasoning: 30, speed: 95, longContext: 30, instruction: 60 },
+    "gpt-5": { coding: 92, debugging: 88, research: 85, reasoning: 92, speed: 40, longContext: 85, instruction: 90 },
+    "gpt-5-mini": { coding: 62, debugging: 52, research: 48, reasoning: 52, speed: 88, longContext: 52, instruction: 74 },
+    "gpt-5-nano": { coding: 42, debugging: 32, research: 28, reasoning: 32, speed: 95, longContext: 32, instruction: 62 },
+    "gpt-5-pro": { coding: 94, debugging: 90, research: 88, reasoning: 94, speed: 35, longContext: 88, instruction: 92 },
+    "gpt-5.1": { coding: 93, debugging: 89, research: 86, reasoning: 93, speed: 42, longContext: 86, instruction: 91 },
+    "gpt-5.1-codex-max": { coding: 90, debugging: 85, research: 70, reasoning: 85, speed: 55, longContext: 75, instruction: 85 },
+    "gpt-5.1-codex-mini": { coding: 65, debugging: 55, research: 40, reasoning: 50, speed: 88, longContext: 48, instruction: 72 },
+    "gpt-5.2": { coding: 93, debugging: 90, research: 87, reasoning: 93, speed: 42, longContext: 87, instruction: 91 },
+    "gpt-5.2-codex": { coding: 93, debugging: 90, research: 72, reasoning: 88, speed: 50, longContext: 78, instruction: 88 },
+    "gpt-5.3-codex": { coding: 94, debugging: 91, research: 74, reasoning: 89, speed: 50, longContext: 80, instruction: 89 },
+    "gpt-5.3-codex-spark": { coding: 68, debugging: 58, research: 42, reasoning: 52, speed: 90, longContext: 50, instruction: 74 },
+    "gpt-5.4": { coding: 95, debugging: 92, research: 88, reasoning: 94, speed: 42, longContext: 88, instruction: 92 },
+    // ── OpenAI o-series (reasoning-first) ──────────────────────────────────────
+    "o1": { coding: 78, debugging: 82, research: 78, reasoning: 90, speed: 20, longContext: 65, instruction: 82 },
+    "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
+    "o4-mini": { coding: 75, debugging: 80, research: 72, reasoning: 88, speed: 60, longContext: 65, instruction: 80 },
+    "o4-mini-deep-research": { coding: 75, debugging: 80, research: 85, reasoning: 88, speed: 30, longContext: 80, instruction: 80 },
+    // ── Google ─────────────────────────────────────────────────────────────────
     "gemini-2.5-pro": { coding: 75, debugging: 70, research: 85, reasoning: 75, speed: 55, longContext: 90, instruction: 75 },
     "gemini-2.0-flash": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+    "gemini-flash-2.0": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+    // ── DeepSeek ───────────────────────────────────────────────────────────────
     "deepseek-chat": { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
-    "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
 };
 // ─── Base Task Requirements Data Table ───────────────────────────────────────
 // Per-unit-type base requirement vectors. Weights indicate how important each
@@ -398,3 +430,54 @@ function getModelCost(modelId) {
     // Unknown cost — assume expensive to avoid routing to unknown cheap models
     return 999;
 }
+// ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
+/**
+ * Check if a tool is compatible with a provider's capabilities.
+ * Returns true if the tool can be used with the provider.
+ */
+export function isToolCompatibleWithProvider(toolName, providerCaps) {
+    const compat = getToolCompatibility(toolName);
+    if (!compat)
+        return true; // no metadata = always compatible
+    // Hard filter: provider doesn't support image tool results
+    if (compat.producesImages && !providerCaps.imageToolResults)
+        return false;
+    // Hard filter: tool uses schema features provider doesn't support
+    if (compat.schemaFeatures?.some(f => providerCaps.unsupportedSchemaFeatures.includes(f))) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Filter a list of tool names to only those compatible with a provider.
+ * Used by the routing pipeline to adjust tool sets when switching providers.
+ */
+export function filterToolsForProvider(toolNames, providerApi) {
+    const providerCaps = getProviderCapabilities(providerApi);
+    // Provider doesn't support tool calling at all
+    if (!providerCaps.toolCalling) {
+        return { compatible: [], filtered: toolNames };
+    }
+    const compatible = [];
+    const filtered = [];
+    for (const name of toolNames) {
+        if (isToolCompatibleWithProvider(name, providerCaps)) {
+            compatible.push(name);
+        }
+        else {
+            filtered.push(name);
+        }
+    }
+    return { compatible, filtered };
+}
+/**
+ * Adjust the active tool set for a selected model's provider capabilities.
+ * Returns tool names that should be active — removes incompatible tools.
+ *
+ * This is a hard filter only — it removes tools that would fail at the
+ * provider level. It does NOT remove tools based on soft heuristics.
+ */
+export function adjustToolSet(activeToolNames, selectedModelApi) {
+    const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+    return { toolNames: compatible, removedTools: filtered };
+}

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -28,6 +28,8 @@ After reflection is confirmed, decide the approach based on the actual scope —
 
 **Anti-reduction rule:** If the user describes a big vision, plan the big vision. Do not ask "what's the minimum viable version?" or try to reduce scope unless the user explicitly asks for an MVP or minimal version. When something is complex or risky, phase it into a later milestone — do not cut it. The user's ambition is the target, and your job is to sequence it intelligently, not shrink it.
 
+{{preparationContext}}
+
 ## Mandatory Investigation Before First Question Round
 
 Before asking your first question, do a mandatory investigation pass. This is not optional.

package/dist/resources/extensions/gsd/templates/context.md

@@ -38,6 +38,28 @@ To call this milestone complete, we must prove:
 - {{one real end-to-end scenario}}
 - {{what cannot be simulated if this milestone is to be considered truly done}}
 
+## Architectural Decisions
+
+### {{decisionTitle}}
+
+**Decision:** {{decisionStatement}}
+
+**Rationale:** {{rationale}}
+
+**Alternatives Considered:**
+- {{alternative}} — {{whyNotChosen}}
+
+---
+
+> Add additional decisions as separate `### Decision Title` blocks following the same structure above.
+> See `.gsd/DECISIONS.md` for the full append-only register of all project decisions.
+
+## Error Handling Strategy
+
+{{errorHandlingStrategy}}
+
+> Describe the approach for handling failures, edge cases, and error propagation. Include retry policies, fallback behaviors, and user-facing error messages where relevant.
+
 ## Risks and Unknowns
 
 - {{riskOrUnknown}} — {{whyItMatters}}
@@ -47,8 +69,6 @@ To call this milestone complete, we must prove:
 - `{{fileOrModule}}` — {{howItRelates}}
 - `{{fileOrModule}}` — {{howItRelates}}
 
-> See `.gsd/DECISIONS.md` for all architectural and pattern decisions — it is an append-only register; read it during planning, append to it during execution.
-
 ## Relevant Requirements
 
 - {{requirementId}} — {{howThisMilestoneAdvancesIt}}
@@ -71,6 +91,18 @@ To call this milestone complete, we must prove:
 
 - {{systemOrService}} — {{howThisMilestoneInteractsWithIt}}
 
+## Testing Requirements
+
+{{testingRequirements}}
+
+> Specify test types (unit, integration, e2e), coverage expectations, and specific test scenarios that must pass.
+
+## Acceptance Criteria
+
+{{acceptanceCriteria}}
+
+> Per-slice acceptance criteria gathered during discussion. Each slice should have clear, testable criteria.
+
 ## Open Questions
 
 - {{question}} — {{currentThinking}}

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -1,24 +1,37 @@
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
+    "ask_user_questions",
+    "gsd_decision_save",
     "gsd_complete_milestone",
     "gsd_complete_task",
     "gsd_complete_slice",
+    "gsd_generate_milestone_id",
+    "gsd_journal_query",
     "gsd_milestone_complete",
+    "gsd_milestone_generate_id",
     "gsd_milestone_status",
     "gsd_milestone_validate",
+    "gsd_plan_task",
     "gsd_plan_milestone",
     "gsd_plan_slice",
     "gsd_replan_slice",
     "gsd_reassess_roadmap",
+    "gsd_requirement_save",
+    "gsd_requirement_update",
     "gsd_roadmap_reassess",
+    "gsd_save_decision",
     "gsd_save_gate_result",
+    "gsd_save_requirement",
+    "gsd_skip_slice",
     "gsd_slice_replan",
     "gsd_slice_complete",
     "gsd_summary_save",
+    "gsd_task_plan",
     "gsd_task_complete",
+    "gsd_update_requirement",
     "gsd_validate_milestone",
 ]);
 function parseLookupOutput(output) {
@@ -73,6 +86,8 @@ function getBundledWorkflowMcpCliPath(env) {
             return candidate;
     }
     const candidates = [
+        resolve(fileURLToPath(new URL("../../../../packages/mcp-server/src/cli.ts", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/src/cli.ts", import.meta.url))),
         resolve(fileURLToPath(new URL("../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
         resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
     ];
@@ -84,9 +99,9 @@ function getBundledWorkflowMcpCliPath(env) {
 }
 function getBundledWorkflowExecutorModulePath() {
     const candidates = [
-        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
         resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.js", import.meta.url))),
         resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.ts", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
     ];
     for (const candidate of candidates) {
         if (existsSync(candidate))
@@ -96,9 +111,20 @@ function getBundledWorkflowExecutorModulePath() {
 }
 function getBundledWorkflowWriteGateModulePath() {
     const candidates = [
-        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
         resolve(fileURLToPath(new URL("./bootstrap/write-gate.js", import.meta.url))),
         resolve(fileURLToPath(new URL("./bootstrap/write-gate.ts", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function getResolveTsHookPath() {
+    const candidates = [
+        resolve(fileURLToPath(new URL("./tests/resolve-ts.mjs", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../src/resources/extensions/gsd/tests/resolve-ts.mjs", import.meta.url))),
     ];
     for (const candidate of candidates) {
         if (existsSync(candidate))
@@ -106,14 +132,35 @@ function getBundledWorkflowWriteGateModulePath() {
     }
     return null;
 }
-function buildWorkflowLaunchEnv(projectRoot, gsdCliPath, explicitEnv) {
+function mergeNodeOptions(existing, additions) {
+    const tokens = (existing ?? "").split(/\s+/).map((value) => value.trim()).filter(Boolean);
+    for (const addition of additions) {
+        if (!tokens.includes(addition)) {
+            tokens.push(addition);
+        }
+    }
+    return tokens.length > 0 ? tokens.join(" ") : undefined;
+}
+function buildWorkflowLaunchEnv(projectRoot, gsdCliPath, explicitEnv, workflowCliPath) {
     const executorModulePath = getBundledWorkflowExecutorModulePath();
     const writeGateModulePath = getBundledWorkflowWriteGateModulePath();
+    const resolveTsHookPath = getResolveTsHookPath();
+    const wantsSourceTs = Boolean(resolveTsHookPath) &&
+        ((workflowCliPath?.endsWith(".ts") ?? false) ||
+            (executorModulePath?.endsWith(".ts") ?? false) ||
+            (writeGateModulePath?.endsWith(".ts") ?? false));
+    const nodeOptions = wantsSourceTs
+        ? mergeNodeOptions(explicitEnv?.NODE_OPTIONS, [
+            "--experimental-strip-types",
+            `--import=${pathToFileURL(resolveTsHookPath).href}`,
+        ])
+        : explicitEnv?.NODE_OPTIONS;
     return {
         ...(explicitEnv ?? {}),
         ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
         ...(executorModulePath ? { GSD_WORKFLOW_EXECUTORS_MODULE: executorModulePath } : {}),
         ...(writeGateModulePath ? { GSD_WORKFLOW_WRITE_GATE_MODULE: writeGateModulePath } : {}),
+        ...(nodeOptions ? { NODE_OPTIONS: nodeOptions } : {}),
         GSD_PERSIST_WRITE_GATE_STATE: "1",
         GSD_WORKFLOW_PROJECT_ROOT: projectRoot,
     };
@@ -148,7 +195,7 @@ export function detectWorkflowMcpLaunchConfig(projectRoot = process.cwd(), env =
             command: process.execPath,
             args: [distCli],
             cwd: resolvedWorkflowProjectRoot,
-            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath, undefined, distCli),
         };
     }
     const bundledCli = getBundledWorkflowMcpCliPath(env);
@@ -158,7 +205,7 @@ export function detectWorkflowMcpLaunchConfig(projectRoot = process.cwd(), env =
             command: process.execPath,
             args: [bundledCli],
             cwd: resolvedWorkflowProjectRoot,
-            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+            env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath, undefined, bundledCli),
         };
     }
     const binPath = lookupCommand("gsd-mcp-server");

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-u9mQsApZYm8sVYSAaft8g
+CHeIRZw-E97oO51g7zDvv