@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -7,6 +7,7 @@
  *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
  *   /gsd mcp status      — Same as bare /gsd mcp
  *   /gsd mcp check <srv> — Detailed status for a specific server
+ *   /gsd mcp discover [srv] — Connect and list tools for a server
  *   /gsd mcp test <srv>  — Test handshake + tools/list for a server
  *   /gsd mcp enable <srv> / disable <srv> — Toggle local server exposure
  *   /gsd mcp import <srv> [as <name>] — Copy a discovered server into local config
@@ -34,6 +35,7 @@ export interface McpServerStatus {
   name: string;
   transport: ManagedMcpTransport;
   connected: boolean;
+  available?: boolean;
   toolCount: number;
   error: string | undefined;
   disabled?: boolean;
@@ -45,6 +47,8 @@ export interface McpServerDetail extends McpServerStatus {
   tools: string[];
 }
 
+const MCP_STATUS_PROBE_TIMEOUT_MS = 10_000;
+
 export function hasHostMcpTool(systemPrompt: string, serverName: string): boolean {
   const marker = `mcp__${serverName}__`;
   return systemPrompt.includes(marker);
@@ -89,13 +93,15 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
   const lines: string[] = [`MCP Server Status — ${servers.length} server(s)\n`];
 
   for (const s of servers) {
-    const icon = s.disabled ? "⊘" : s.error ? "✗" : s.connected ? "✓" : "○";
+    const icon = s.disabled ? "⊘" : s.error ? "✗" : s.connected || s.available ? "✓" : "○";
     const status = s.disabled
       ? "disabled"
       : s.error
       ? `error: ${s.error}`
       : s.connected
         ? `connected — ${s.toolCount} tools`
+        : s.available
+          ? `available — ${s.toolCount} tools`
         : "disconnected";
     const warningText = s.envWarnings?.length ? ` — ${s.envWarnings.length} warning(s)` : "";
     lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}${warningText}`);
@@ -103,8 +109,8 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
 
   lines.push("");
   lines.push("Use /gsd mcp check <server> for details on a specific server.");
+  lines.push("Use /gsd mcp discover <server> to connect and list tools.");
   lines.push("Use /gsd mcp test <server> to verify handshake and tool discovery.");
-  lines.push("Use mcp_discover to connect and list tools for a server.");
 
   return lines.join("\n");
 }
@@ -120,8 +126,8 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
   } else if (server.error) {
     lines.push(`  Status:    error`);
     lines.push(`  Error:     ${server.error}`);
-  } else if (server.connected) {
-    lines.push(`  Status:    connected`);
+  } else if (server.connected || server.available) {
+    lines.push(`  Status:    ${server.connected ? "connected" : "available"}`);
     lines.push(`  Tools:     ${server.toolCount}`);
     if (server.tools.length > 0) {
       lines.push("");
@@ -133,7 +139,7 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
   } else {
     lines.push(`  Status:    disconnected`);
     lines.push("");
-    lines.push(`  Run mcp_discover("${server.name}") to connect and list tools.`);
+    lines.push(`  Run /gsd mcp discover ${server.name} to connect and list tools.`);
   }
 
   if (server.envWarnings?.length) {
@@ -167,10 +173,93 @@ export function formatMcpConnectionTestResult(result: ManagedMcpConnectionTestRe
   ].join("\n");
 }
 
+export function formatMcpDiscoveryResult(result: ManagedMcpConnectionTestResult): string {
+  if (result.ok) {
+    return [
+      `MCP discovery completed for ${result.server}.`,
+      "",
+      `Transport: ${result.transport}`,
+      `Tools:     ${result.toolCount}`,
+      ...(result.tools.length > 0 ? ["", "Discovered tools:", ...result.tools.map((tool) => `  - ${tool}`)] : []),
+      "",
+      `Call with: mcp_call(server="${result.server}", tool="<tool_name>", args={...})`,
+    ].join("\n");
+  }
+
+  return [
+    `MCP discovery failed for ${result.server}.`,
+    "",
+    `Transport: ${result.transport}`,
+    `Error:     ${result.error ?? "Unknown error"}`,
+    ...(result.warnings.length > 0 ? ["", "Warnings:", ...result.warnings.map((warning) => `  - ${warning}`)] : []),
+  ].join("\n");
+}
+
+async function readLiveConnectionStatus(serverName: string): Promise<{
+  connected: boolean;
+  tools: string[];
+  error?: string;
+}> {
+  try {
+    const mcpClient = await import("../mcp-client/index.js");
+    const mod = mcpClient as Record<string, unknown>;
+    if (typeof mod.getConnectionStatus === "function") {
+      return (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(serverName);
+    }
+  } catch {
+    // mcp-client may not expose status helpers in some hosts.
+  }
+  return { connected: false, tools: [] };
+}
+
+function shouldProbeConfiguredServer(config: { disabled?: boolean; transport: ManagedMcpTransport; envWarnings?: string[] }): boolean {
+  return !config.disabled && config.transport === "stdio" && (config.envWarnings?.length ?? 0) === 0;
+}
+
+async function resolveMcpRuntimeStatus(
+  config: {
+    name: string;
+    transport: ManagedMcpTransport;
+    disabled?: boolean;
+    envWarnings?: string[];
+  },
+  systemPrompt: string,
+): Promise<{
+  connected: boolean;
+  available: boolean;
+  tools: string[];
+  error?: string;
+}> {
+  const live = await readLiveConnectionStatus(config.name);
+  let connected = live.connected;
+  let tools = live.tools;
+  let error = live.error;
+
+  if (!connected && !error && hasHostMcpTool(systemPrompt, config.name)) connected = true;
+
+  if (!connected && !error && shouldProbeConfiguredServer(config)) {
+    const probed = await testMcpServerConnection(config.name, { timeoutMs: MCP_STATUS_PROBE_TIMEOUT_MS });
+    if (probed.ok) {
+      return {
+        connected: false,
+        available: true,
+        tools: probed.tools,
+      };
+    }
+    error = probed.error;
+  }
+
+  return {
+    connected,
+    available: false,
+    tools,
+    error,
+  };
+}
 // ─── Command handler ────────────────────────────────────────────────────────
 
 /**
- * Handle `/gsd mcp [status|check <server>]`.
+ * Handle `/gsd mcp [status|check <server>|discover [server]|...]`.
  */
 export async function handleMcpStatus(
   args: string,
@@ -200,6 +289,28 @@ export async function handleMcpStatus(
     return;
   }
 
+  // /gsd mcp discover [server]
+  if (lowered === "discover" || lowered.startsWith("discover ")) {
+    const requestedServerName = trimmed.slice("discover".length).trim();
+    let serverName = requestedServerName;
+    if (!serverName) {
+      if (configs.length === 1) {
+        serverName = configs[0]!.name;
+      } else {
+        const available = configs.map((config) => config.name).join(", ") || "(none)";
+        ctx.ui.notify(
+          `Usage: /gsd mcp discover <server>\n\nAvailable: ${available}`,
+          "warning",
+        );
+        return;
+      }
+    }
+
+    const result = await testMcpServerConnection(serverName);
+    ctx.ui.notify(formatMcpDiscoveryResult(result), result.ok ? "info" : "warning");
+    return;
+  }
+
   // /gsd mcp test <server>
   if (lowered.startsWith("test ")) {
     const serverName = trimmed.slice("test ".length).trim();
@@ -304,33 +415,17 @@ export async function handleMcpStatus(
       return;
     }
 
-    // Try to get connection/tool info from the mcp-client module if available
-    let connected = false;
-    let toolNames: string[] = [];
-    let error: string | undefined;
-    try {
-      const mcpClient = await import("../mcp-client/index.js");
-      // Access the module's connection state if exported; fall back gracefully
-      const mod = mcpClient as Record<string, unknown>;
-      if (typeof mod.getConnectionStatus === "function") {
-        const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(serverName);
-        connected = status.connected;
-        toolNames = status.tools;
-        error = status.error;
-      }
-    } catch {
-      // mcp-client may not expose status helpers — that's fine
-    }
-    if (!connected && !error && hasHostMcpTool(systemPrompt, serverName)) connected = true;
+    const runtime = await resolveMcpRuntimeStatus(config, systemPrompt);
 
     ctx.ui.notify(
       formatMcpServerDetail({
         name: config.name,
         transport: config.transport,
-        connected,
-        toolCount: toolNames.length,
-        tools: toolNames,
-        error,
+        connected: runtime.connected,
+        available: runtime.available,
+        toolCount: runtime.tools.length,
+        tools: runtime.tools,
+        error: runtime.error,
         disabled: config.disabled,
         sourcePath: config.sourcePath,
         envWarnings: config.envWarnings,
@@ -342,39 +437,20 @@ export async function handleMcpStatus(
 
   // /gsd mcp or /gsd mcp status
   if (!lowered || lowered === "status") {
-    // Build status for each server
-    const statuses: McpServerStatus[] = [];
-
-    for (const config of configs) {
-      let connected = false;
-      let toolCount = 0;
-      let error: string | undefined;
-
-      try {
-        const mcpClient = await import("../mcp-client/index.js");
-        const mod = mcpClient as Record<string, unknown>;
-        if (typeof mod.getConnectionStatus === "function") {
-          const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(config.name);
-          connected = status.connected;
-          toolCount = status.tools.length;
-          error = status.error;
-        }
-      } catch {
-        // Fall back to unknown state
-      }
-      if (!connected && !error && hasHostMcpTool(systemPrompt, config.name)) connected = true;
-
-      statuses.push({
+    const statuses: McpServerStatus[] = await Promise.all(configs.map(async (config) => {
+      const runtime = await resolveMcpRuntimeStatus(config, systemPrompt);
+      return {
         name: config.name,
         transport: config.transport,
-        connected,
-        toolCount,
-        error,
+        connected: runtime.connected,
+        available: runtime.available,
+        toolCount: runtime.tools.length,
+        error: runtime.error,
         disabled: config.disabled,
         sourcePath: config.sourcePath,
         envWarnings: config.envWarnings,
-      });
-    }
+      };
+    }));
 
     const warningLines = [
       ...management.warnings,
@@ -389,9 +465,10 @@ export async function handleMcpStatus(
 
   // Unknown subcommand
   ctx.ui.notify(
-    "Usage: /gsd mcp [status|check <server>|test <server>|enable <server>|disable <server>|delete <server> --confirm|import <server> [as <name>]|init [dir]]\n\n" +
+    "Usage: /gsd mcp [status|check <server>|discover [server]|test <server>|enable <server>|disable <server>|delete <server> --confirm|import <server> [as <name>]|init [dir]]\n\n" +
     "  status           Show all MCP server statuses (default)\n" +
     "  check <server>   Detailed status for a specific server\n" +
+    "  discover [server] Connect and list tools for a server\n" +
     "  test <server>    Verify MCP handshake and tools/list\n" +
     "  enable <server>  Enable a local GSD-managed server\n" +
     "  disable <server> Disable a local GSD-managed server\n" +

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -23,6 +23,9 @@ import {
 import { loadFile, saveFile, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { runClaudeImportFlow } from "./claude-import.js";
 
+const DEFAULT_WIDGET_MODE = "small";
+const WIDGET_MODE_OPTIONS = [DEFAULT_WIDGET_MODE, "full", "min", "off"] as const;
+
 /** Extract body content after frontmatter closing delimiter, or null if none. */
 function extractBodyAfterFrontmatter(content: string): string | null {
   const closingIdx = content.indexOf("\n---", content.indexOf("---"));
@@ -1558,7 +1561,7 @@ async function configureAdvanced(ctx: ExtensionCommandContext, prefs: Record<str
     prefs.min_request_interval_ms = minRequestInterval;
   }
 
-  const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, ["full", "small", "min", "off"], "full");
+  const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, WIDGET_MODE_OPTIONS, DEFAULT_WIDGET_MODE);
   if (widget !== undefined) prefs.widget_mode = widget;
 
   const experimental = (prefs.experimental as Record<string, unknown> | undefined) ?? {};

package/src/resources/extensions/gsd/commands-verdict.ts

@@ -238,7 +238,7 @@ export async function handleVerdict(
 
   if (effectiveVerdict === "needs-remediation") {
     ctx.ui.notify(
-      "Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.",
+      "Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.",
       "info",
     );
   }

package/src/resources/extensions/gsd/config-overlay.ts

@@ -23,6 +23,8 @@ import {
   resolveAutoSupervisorConfig,
 } from "./preferences.js";
 
+const DEFAULT_WIDGET_MODE = "small";
+
 // ─── Data Collection ──────────────────────────────────────────────────────
 
 interface ConfigSection {
@@ -160,7 +162,7 @@ function collectConfigSections(): ConfigSection[] {
   if (prefs?.service_tier) toggleRows.push({ label: "service_tier", value: prefs.service_tier });
   if (prefs?.search_provider && prefs.search_provider !== "auto") toggleRows.push({ label: "search_provider", value: prefs.search_provider });
   if (prefs?.context_selection) toggleRows.push({ label: "context_selection", value: prefs.context_selection });
-  if (prefs?.widget_mode && prefs.widget_mode !== "full") toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
+  if (prefs?.widget_mode && prefs.widget_mode !== DEFAULT_WIDGET_MODE) toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
   if (prefs?.experimental?.rtk) toggleRows.push({ label: "experimental.rtk", value: "on" });
   if (toggleRows.length > 0) sections.push({ title: "Toggles", rows: toggleRows });
 

package/src/resources/extensions/gsd/error-classifier.ts

@@ -47,9 +47,10 @@ export function resetRetryState(state: RetryState): void {
 const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
 // Include provider-specific quota-window phrasing like:
 // - "You've hit your limit"
+// - "You've reached your limit"
 // - "usage limit" / "quota reached"
 // - "out of extra usage"
-const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429|(?:hit|reached) your (?:\w+ )?limit|(?:usage|session|weekly|daily|monthly|quota) limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
 // OpenRouter affordability-style quota errors should be treated as transient
 // so core retry logic can lower maxTokens and continue in-session.
 const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;

package/src/resources/extensions/gsd/exec-sandbox.ts

@@ -20,6 +20,8 @@ export interface ExecSandboxRequest {
   script: string;
   /** Optional purpose/label recorded in meta.json. */
   purpose?: string;
+  /** Optional structured metadata recorded in meta.json. */
+  metadata?: Record<string, unknown>;
   /** Per-invocation timeout in ms. Clamped to `clamp_timeout_ms`. */
   timeout_ms?: number;
 }
@@ -315,6 +317,7 @@ function writeMeta(
     id: result.id,
     runtime: result.runtime,
     purpose: request.purpose ?? null,
+    ...(request.metadata ? { metadata: request.metadata } : {}),
     script_chars: request.script.length,
     started_at: now.toISOString(),
     finished_at: new Date(now.getTime() + result.duration_ms).toISOString(),
@@ -328,6 +331,7 @@ function writeMeta(
     stderr_truncated: result.stderr_truncated,
     stdout_path: result.stdout_path,
     stderr_path: result.stderr_path,
+    ...(request.metadata ? { metadata: request.metadata } : {}),
   };
   writeFileSync(path, `${JSON.stringify(meta, null, 2)}\n`);
 }

package/src/resources/extensions/gsd/gsd-db.ts

@@ -55,6 +55,7 @@ import {
 import { rowToGate } from "./db-gate-rows.js";
 import { rowToArtifact, rowToMilestone, type ArtifactRow, type MilestoneRow } from "./db-milestone-artifact-rows.js";
 import { backupDatabaseBeforeMigration } from "./db-migration-backup.js";
+import { isClosedStatus } from "./status-guards.js";
 import {
   applyMigrationV2Artifacts,
   applyMigrationV3Memories,
@@ -1665,16 +1666,50 @@ export function setMilestoneQueueOrder(order: string[]): void {
   }
 }
 
+function getMilestoneStatusForUpdate(milestoneId: string): string | null {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  const row = currentDb.prepare("SELECT status FROM milestones WHERE id = :id").get({ ":id": milestoneId });
+  return typeof row?.["status"] === "string" ? row["status"] : null;
+}
+
+function writeMilestoneStatus(milestoneId: string, status: string, completedAt?: string | null): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `UPDATE milestones SET status = :status, completed_at = :completed_at WHERE id = :id`,
+  ).run({ ":status": status, ":completed_at": completedAt ?? null, ":id": milestoneId });
+}
+
 /**
  * Update a milestone's status in the database.
- * Used by park/unpark to keep the DB in sync with the filesystem marker.
- * See: https://github.com/open-gsd/gsd-pi/issues/2694
+ *
+ * Generic status updates may close milestones, park/unpark open milestones, or
+ * advance planned milestones. They may not reopen a closed milestone; callers
+ * must use reopenMilestoneStatus(), which is reserved for gsd_milestone_reopen.
  */
 export function updateMilestoneStatus(milestoneId: string, status: string, completedAt?: string | null): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-  currentDb.prepare(
-    `UPDATE milestones SET status = :status, completed_at = :completed_at WHERE id = :id`,
-  ).run({ ":status": status, ":completed_at": completedAt ?? null, ":id": milestoneId });
+  const currentStatus = getMilestoneStatusForUpdate(milestoneId);
+  if (currentStatus && isClosedStatus(currentStatus) && !isClosedStatus(status)) {
+    throw new Error(
+      `Cannot update closed milestone ${milestoneId} from ${currentStatus} to ${status}; use gsd_milestone_reopen for an explicit reopen.`,
+    );
+  }
+  writeMilestoneStatus(milestoneId, status, completedAt);
+}
+
+/**
+ * Explicit closed -> active transition for gsd_milestone_reopen only.
+ */
+export function reopenMilestoneStatus(milestoneId: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  const currentStatus = getMilestoneStatusForUpdate(milestoneId);
+  if (!currentStatus) {
+    throw new Error(`Cannot reopen missing milestone ${milestoneId}`);
+  }
+  if (!isClosedStatus(currentStatus)) {
+    throw new Error(`Cannot reopen milestone ${milestoneId} from status ${currentStatus}; milestone is not closed.`);
+  }
+  writeMilestoneStatus(milestoneId, "active", null);
 }
 
 export function getActiveMilestoneFromDb(): MilestoneRow | null {
@@ -2708,7 +2743,7 @@ export function deleteArtifactByPath(path: string): void {
 
 /**
  * Drop hierarchy rows in dependency order inside a transaction. Used by
- * `gsd recover` to rebuild engine state from markdown.
+ * `gsd recover --confirm` to rebuild engine state from markdown.
  */
 export function clearEngineHierarchy(): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");

package/src/resources/extensions/gsd/guided-flow.ts

@@ -2374,7 +2374,7 @@ export async function showSmartEntry(
       if (result.action === "recovery-required") {
         ctx.ui.notify(
           result.message ??
-            `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover"}\` to import markdown explicitly.`,
+            `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover --confirm"}\` to import markdown explicitly.`,
           "warning",
         );
       }

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -40,9 +40,11 @@ function collectServerEntries(servers: unknown): DiscoveredMcpServer[] {
 export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
   const mcpJsonPath = resolve(projectDir, ".mcp.json");
   const settingsPath = resolve(projectDir, ".claude", "settings.json");
+  const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
 
   const mcpJson = readJsonFile(mcpJsonPath) as McpJsonFile | undefined;
   const settings = readJsonFile(settingsPath, true) as ClaudeSettingsFile | undefined;
+  const localSettings = readJsonFile(localSettingsPath, true) as ClaudeSettingsFile | undefined;
 
   const seen = new Set<string>();
   const discovered: DiscoveredMcpServer[] = [];
@@ -50,6 +52,7 @@ export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
     ...collectServerEntries(mcpJson?.mcpServers),
     ...collectServerEntries(mcpJson?.servers),
     ...collectServerEntries(settings?.mcpServers),
+    ...collectServerEntries(localSettings?.mcpServers),
   ]) {
     if (seen.has(entry.name)) continue;
     seen.add(entry.name);

package/src/resources/extensions/gsd/mcp-project-config.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -36,6 +36,12 @@ interface McpConfigFile {
   [key: string]: unknown;
 }
 
+interface ClaudeCodeLocalSettingsFile {
+  enabledMcpjsonServers?: unknown;
+  disabledMcpjsonServers?: unknown;
+  [key: string]: unknown;
+}
+
 export function resolveBundledGsdCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
   const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
   if (explicit) return explicit;
@@ -223,6 +229,78 @@ function readExistingConfig(configPath: string): McpConfigFile {
   }
 }
 
+function readExistingClaudeCodeSettings(settingsPath: string): ClaudeCodeLocalSettingsFile {
+  if (!existsSync(settingsPath)) return {};
+
+  const raw = readFileSync(settingsPath, "utf-8");
+  try {
+    const parsed = JSON.parse(raw) as ClaudeCodeLocalSettingsFile;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ${settingsPath}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+export function ensureClaudeCodeMcpJsonServersEnabled(
+  projectRoot: string,
+  serverNames: string[],
+): boolean {
+  const resolvedProjectRoot = resolve(projectRoot);
+  assertSafeDirectory(resolvedProjectRoot);
+
+  const targetServerNames = [...new Set(serverNames.filter((name) => name.trim().length > 0))];
+  if (targetServerNames.length === 0) return false;
+
+  const settingsDir = resolve(resolvedProjectRoot, ".claude");
+  const settingsPath = resolve(settingsDir, "settings.local.json");
+  const existing = readExistingClaudeCodeSettings(settingsPath);
+
+  const enabled = Array.isArray(existing.enabledMcpjsonServers)
+    ? [...existing.enabledMcpjsonServers]
+    : [];
+  const enabledNames = new Set(enabled.filter((value): value is string => typeof value === "string"));
+  let changed = !Array.isArray(existing.enabledMcpjsonServers);
+
+  for (const serverName of targetServerNames) {
+    if (!enabledNames.has(serverName)) {
+      enabled.push(serverName);
+      enabledNames.add(serverName);
+      changed = true;
+    }
+  }
+
+  let nextDisabled = existing.disabledMcpjsonServers;
+  if (Array.isArray(existing.disabledMcpjsonServers)) {
+    const blockedNames = new Set(targetServerNames);
+    const filtered = existing.disabledMcpjsonServers.filter((value) => !blockedNames.has(String(value)));
+    if (filtered.length !== existing.disabledMcpjsonServers.length) {
+      nextDisabled = filtered;
+      changed = true;
+    }
+  }
+
+  if (!changed) return false;
+
+  const nextSettings: ClaudeCodeLocalSettingsFile = {
+    ...existing,
+    enabledMcpjsonServers: enabled,
+    ...(Array.isArray(existing.disabledMcpjsonServers) ? { disabledMcpjsonServers: nextDisabled } : {}),
+  };
+
+  mkdirSync(settingsDir, { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(nextSettings, null, 2)}\n`, "utf-8");
+  return true;
+}
+
+export function ensureClaudeCodeMcpJsonServerEnabled(
+  projectRoot: string,
+  serverName: string,
+): boolean {
+  return ensureClaudeCodeMcpJsonServersEnabled(projectRoot, [serverName]);
+}
+
 export function ensureProjectWorkflowMcpConfig(
   projectRoot: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -241,14 +319,25 @@ export function ensureProjectWorkflowMcpConfig(
   const desiredServerNames = Object.keys(desiredServers);
 
   const alreadyPresent = existsSync(configPath);
-  const unchanged =
+  const mcpConfigUnchanged =
     desiredServerNames.every((serverName) => (
       JSON.stringify(previousServers[serverName] ?? null)
         === JSON.stringify(desiredServers[serverName])
     ))
     && existing.mcpServers !== undefined;
 
-  if (unchanged) {
+  if (!mcpConfigUnchanged) {
+    const nextConfig: McpConfigFile = {
+      ...existing,
+      mcpServers: nextServers,
+    };
+
+    writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
+  }
+
+  const localSettingsChanged = ensureClaudeCodeMcpJsonServersEnabled(resolvedProjectRoot, desiredServerNames);
+
+  if (mcpConfigUnchanged && !localSettingsChanged) {
     return {
       configPath,
       serverName: workflowServerName,
@@ -257,13 +346,6 @@ export function ensureProjectWorkflowMcpConfig(
     };
   }
 
-  const nextConfig: McpConfigFile = {
-    ...existing,
-    mcpServers: nextServers,
-  };
-
-  writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
-
   return {
     configPath,
     serverName: workflowServerName,

package/src/resources/extensions/gsd/migration-auto-check.ts

@@ -118,10 +118,10 @@ export async function checkMarkdownHierarchyAgainstDb(
     markdown,
     beforeDb,
     afterDb: beforeDb,
-    recoveryCommand: "/gsd recover",
+    recoveryCommand: "/gsd recover --confirm",
     message:
       `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
       `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
-      "Runtime startup will not import markdown automatically; run `/gsd recover` if markdown should repopulate the database.",
+      "Runtime startup will not import markdown automatically; run `/gsd recover --confirm` if markdown should repopulate the database.",
   };
 }

package/src/resources/extensions/gsd/preferences-types.ts

@@ -423,7 +423,7 @@ export interface GSDPreferences {
   search_provider?: "brave" | "tavily" | "ollama" | "native" | "auto";
   /** Context selection mode for file inlining. "full" inlines entire files, "smart" uses semantic chunking. Default derived from token profile. */
   context_selection?: ContextSelectionMode;
-  /** Default widget display mode for auto-mode dashboard. "full" | "small" | "min" | "off". Default: "full". */
+  /** Default widget display mode for auto-mode dashboard. "full" | "small" | "min" | "off". Default: "small". */
   widget_mode?: "full" | "small" | "min" | "off";
   /** Reactive (graph-derived parallel) task execution within slices. Disabled by default. */
   reactive_execution?: ReactiveExecutionConfig;