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

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -51,6 +51,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd keys           API key manager (LLM + tool keys)",
         "  /gsd doctor         Diagnose and repair .gsd/ state",
         "  /gsd closeout       Recover failed git closeout actions",
+        "  /gsd rebuild        Rebuild markdown projections from the DB  [markdown]",
         "",
         "Use /gsd help full for the complete command reference.",
     ];
@@ -68,7 +69,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
         "  /gsd new-project    Bootstrap a new project (use --deep for staged project-level discovery)",
         "  /gsd quick          Execute a quick task without full planning overhead",
-        "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|validate|reassess|uat|replan]",
         "  /gsd verdict <v>    Override milestone validation verdict  [pass|needs-attention|needs-remediation] [--milestone Mxxx] [--rationale \"...\"]",
         "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
         "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",
@@ -132,7 +133,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd skill-health   Skill lifecycle dashboard",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
         "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
-        "  /gsd mcp            MCP server management  [status|check|test|enable|disable|import|delete|init]",
+        "  /gsd mcp            MCP server management  [status|check|discover|test|enable|disable|import|delete|init]",
         "",
         "MAINTENANCE",
         "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",
@@ -141,6 +142,9 @@ export function showHelp(ctx, args = "") {
         "  /gsd export         Alias for /gsd report",
         "  /gsd cleanup        Remove merged branches or snapshots  [branches|snapshots]",
         "  /gsd closeout       Recover failed git closeout actions  [status|retry|resolve] [unit-id]",
+        "  /gsd rebuild markdown  Rebuild markdown projections from the canonical DB",
+        "  /gsd rebuild database  Reserved for DB-native rebuilds; does not import markdown",
+        "  /gsd recover --confirm Import markdown into the DB after DB loss/corruption",
         "  /gsd worktree       Manage worktrees from the TUI  [list|merge|clean|remove]",
         "  /gsd migrate        Migrate .planning/ (v1) to DB-backed .gsd/ with backup + audit",
         "  /gsd remote         Control remote auto-mode  [slack|discord|status|disconnect]",

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -4,7 +4,7 @@ import { handleDoctor, handleCapture, handleKnowledge, handleRunHook, handleSkil
 import { handleInspect } from "../../commands-inspect.js";
 import { handleLogs } from "../../commands-logs.js";
 import { handleDebug } from "../../commands-debug.js";
-import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleCleanupProjects, handleCleanupWorktrees, handleRecover } from "../../commands-maintenance.js";
+import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleCleanupProjects, handleCleanupWorktrees, handleRecover, handleRebuild } from "../../commands-maintenance.js";
 import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
 import { handleUndo } from "../../undo.js";
@@ -130,8 +130,12 @@ export async function handleOpsCommand(trimmed, ctx, pi) {
         await handleSkip(trimmed.replace(/^skip\s*/, "").trim(), ctx, projectRoot());
         return true;
     }
-    if (trimmed === "recover") {
-        await handleRecover(ctx, projectRoot());
+    if (trimmed === "recover" || trimmed.startsWith("recover ")) {
+        await handleRecover(ctx, projectRoot(), trimmed.replace(/^recover\s*/, "").trim());
+        return true;
+    }
+    if (trimmed === "rebuild" || trimmed.startsWith("rebuild ")) {
+        await handleRebuild(ctx, projectRoot(), trimmed.replace(/^rebuild\s*/, "").trim());
         return true;
     }
     if (trimmed === "closeout" || trimmed.startsWith("closeout ")) {

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

@@ -1,9 +1,12 @@
 /**
  * GSD Maintenance — cleanup, skip, dry-run, and recover handlers.
  *
- * Contains: handleCleanupBranches, handleCleanupSnapshots, handleCleanupWorktrees, handleSkip, handleDryRun, handleRecover
+ * Contains: handleCleanupBranches, handleCleanupSnapshots, handleCleanupWorktrees, handleSkip, handleDryRun, handleRecover, handleRebuild
  */
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
 import { deriveState } from "./state.js";
+import { gsdProjectionRoot, gsdRoot } from "./paths.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
 import { logWarning } from "./workflow-logger.js";
 export async function handleCleanupBranches(ctx, basePath) {
@@ -439,6 +442,30 @@ export async function handleCleanupProjects(args, ctx) {
     }
     ctx.ui.notify(lines.join("\n"), "info");
 }
+function recoverConfirmed(args) {
+    return args
+        .split(/\s+/)
+        .map((part) => part.trim().toLowerCase())
+        .some((part) => part === "--confirm" || part === "--yes" || part === "confirm");
+}
+async function confirmRecover(ctx, args) {
+    if (recoverConfirmed(args))
+        return true;
+    const warning = [
+        "gsd recover imports markdown into the database.",
+        "It clears and reconstructs milestone, slice, and task hierarchy rows from rendered markdown.",
+        "Use /gsd rebuild markdown for normal DB-to-markdown realignment.",
+    ].join("\n");
+    if (typeof ctx.ui.confirm === "function") {
+        const confirmed = await ctx.ui.confirm("Import markdown into the DB?", `${warning}\n\nContinue only if the DB is lost or corrupt and markdown is the source you intend to import.`);
+        if (confirmed)
+            return true;
+        ctx.ui.notify("gsd recover cancelled. No database changes made.", "info");
+        return false;
+    }
+    ctx.ui.notify(`${warning}\n\nNo database changes made. Re-run /gsd recover --confirm to proceed.`, "warning");
+    return false;
+}
 /**
  * `gsd recover` — Reconstruct DB hierarchy state from rendered markdown on disk.
  *
@@ -448,7 +475,7 @@ export async function handleCleanupProjects(args, ctx) {
  *
  * Prints counts of recovered items and the resulting project phase.
  */
-export async function handleRecover(ctx, basePath) {
+export async function handleRecover(ctx, basePath, args = "") {
     const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction } = await import("./gsd-db.js");
     const { migrateHierarchyToDb } = await import("./md-importer.js");
     const { invalidateStateCache } = await import("./state.js");
@@ -456,6 +483,8 @@ export async function handleRecover(ctx, basePath) {
         ctx.ui.notify("gsd recover: No database open. Run a GSD command first to initialize the DB.", "error");
         return;
     }
+    if (!(await confirmRecover(ctx, args)))
+        return;
     try {
         // 1. Delete + re-populate inside a single transaction for atomicity.
         //    clearEngineHierarchy() uses transaction() internally but transaction()
@@ -496,3 +525,144 @@ export async function handleRecover(ctx, basePath) {
         ctx.ui.notify(`gsd recover failed: ${msg}`, "error");
     }
 }
+function normalizeArtifactPath(value) {
+    return value.replace(/\\/g, "/");
+}
+function pathWithin(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel.length === 0 || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function artifactPathForDb(basePath, absPath) {
+    const projectionRoot = gsdProjectionRoot(basePath);
+    const root = pathWithin(projectionRoot, absPath) ? projectionRoot : gsdRoot(basePath);
+    return normalizeArtifactPath(relative(root, absPath));
+}
+function quarantineRelativePath(basePath, absPath) {
+    for (const root of [gsdProjectionRoot(basePath), gsdRoot(basePath)]) {
+        if (pathWithin(root, absPath)) {
+            return normalizeArtifactPath(relative(root, absPath));
+        }
+    }
+    return normalizeArtifactPath(absPath.replace(/^[/\\]+/, ""));
+}
+function uniquePath(path) {
+    if (!existsSync(path))
+        return path;
+    let idx = 2;
+    while (existsSync(`${path}.${idx}`))
+        idx++;
+    return `${path}.${idx}`;
+}
+function resolveDiskArtifactPath(basePath, artifactPath) {
+    if (isAbsolute(artifactPath))
+        return artifactPath;
+    const candidates = [
+        join(gsdProjectionRoot(basePath), artifactPath),
+        join(gsdRoot(basePath), artifactPath),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+function quarantineProjectionFile(basePath, absPath, stamp) {
+    const rel = quarantineRelativePath(basePath, absPath);
+    const target = uniquePath(join(gsdProjectionRoot(basePath), "quarantine", "projections", stamp, rel));
+    mkdirSync(dirname(target), { recursive: true });
+    renameSync(absPath, target);
+    return target;
+}
+function parseRebuildTarget(args) {
+    const trimmed = args.trim().toLowerCase();
+    if (!trimmed || trimmed === "markdown")
+        return "markdown";
+    if (trimmed === "database" || trimmed === "db")
+        return "database";
+    return "usage";
+}
+/**
+ * `gsd rebuild markdown` — Re-render markdown projections from the authoritative DB.
+ *
+ * This is the DB-first realignment command. It does not import markdown into
+ * the DB. Completion SUMMARY files that contradict open DB rows are preserved
+ * under `.gsd/quarantine/projections/` before DB projections are rendered.
+ */
+export async function handleRebuild(ctx, basePath, args = "") {
+    const { isDbAvailable: dbAvailable, deleteArtifactByPath } = await import("./gsd-db.js");
+    const { detectArtifactDbDrift } = await import("./state-reconciliation/drift/artifact-db.js");
+    const { renderAllFromDb } = await import("./markdown-renderer.js");
+    const { invalidateStateCache } = await import("./state.js");
+    const target = parseRebuildTarget(args);
+    if (target === "usage") {
+        ctx.ui.notify([
+            "Usage:",
+            "  /gsd rebuild markdown   Rebuild markdown projections from the canonical DB",
+            "  /gsd rebuild database   Reserved for DB-native rebuilds; does not import markdown",
+        ].join("\n"), "warning");
+        return;
+    }
+    if (target === "database") {
+        ctx.ui.notify([
+            "gsd rebuild database is reserved for DB-native rebuilds.",
+            "It will not import markdown projections into the DB.",
+            "For normal realignment, run /gsd rebuild markdown.",
+            "If the DB is lost or corrupt and markdown is the source to import, run /gsd recover --confirm.",
+        ].join("\n"), "warning");
+        return;
+    }
+    if (!dbAvailable()) {
+        ctx.ui.notify("gsd rebuild markdown: No database open. Run a GSD command first to initialize the DB.", "error");
+        return;
+    }
+    try {
+        invalidateStateCache();
+        const state = await deriveState(basePath);
+        const drifts = detectArtifactDbDrift(state, { basePath, state });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const quarantined = [];
+        const seen = new Set();
+        for (const drift of drifts) {
+            if (drift.kind !== "artifact-db-status-divergence")
+                continue;
+            if (drift.artifactType !== "SUMMARY" || !drift.artifactPath)
+                continue;
+            const absPath = resolveDiskArtifactPath(basePath, drift.artifactPath);
+            if (seen.has(absPath) || !existsSync(absPath))
+                continue;
+            seen.add(absPath);
+            const artifactDbPath = artifactPathForDb(basePath, absPath);
+            const target = quarantineProjectionFile(basePath, absPath, stamp);
+            deleteArtifactByPath(artifactDbPath);
+            quarantined.push(target);
+        }
+        const rendered = await renderAllFromDb(basePath);
+        invalidateStateCache();
+        const lines = [
+            "gsd rebuild markdown: rebuilt markdown projections from the canonical DB",
+            `  Rendered:    ${rendered.rendered}`,
+            `  Skipped:     ${rendered.skipped}`,
+            `  Quarantined: ${quarantined.length}`,
+        ];
+        if (rendered.errors.length > 0) {
+            lines.push(`  Errors:      ${rendered.errors.length}`);
+            for (const err of rendered.errors.slice(0, 5)) {
+                lines.push(`    - ${err}`);
+            }
+            if (rendered.errors.length > 5) {
+                lines.push(`    - ${rendered.errors.length - 5} more`);
+            }
+        }
+        if (quarantined.length > 0) {
+            lines.push("", "  Quarantine:");
+            for (const target of quarantined.slice(0, 5)) {
+                lines.push(`    - ${target}`);
+            }
+            if (quarantined.length > 5) {
+                lines.push(`    - ${quarantined.length - 5} more`);
+            }
+        }
+        ctx.ui.notify(lines.join("\n"), rendered.errors.length > 0 ? "warning" : "success");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logWarning("command", `rebuild failed: ${msg}`);
+        ctx.ui.notify(`gsd rebuild failed: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -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
@@ -15,6 +16,7 @@
 import { resolve } from "node:path";
 import { ensureProjectWorkflowMcpConfig } from "./mcp-project-config.js";
 import { deleteProjectLocalMcpServer, readMcpManagementStatus, setProjectLocalMcpServerDisabled, testMcpServerConnection, upsertProjectLocalMcpServer, } from "../mcp-client/manager.js";
+const MCP_STATUS_PROBE_TIMEOUT_MS = 10_000;
 export function hasHostMcpTool(systemPrompt, serverName) {
     const marker = `mcp__${serverName}__`;
     return systemPrompt.includes(marker);
@@ -48,21 +50,23 @@ export function formatMcpStatusReport(servers) {
     }
     const lines = [`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`
-                    : "disconnected";
+                    : 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}`);
     }
     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");
 }
 export function formatMcpServerDetail(server) {
@@ -77,8 +81,8 @@ export function formatMcpServerDetail(server) {
         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("");
@@ -91,7 +95,7 @@ export function formatMcpServerDetail(server) {
     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) {
         lines.push("");
@@ -120,9 +124,70 @@ export function formatMcpConnectionTestResult(result) {
         ...(result.warnings.length > 0 ? ["", "Warnings:", ...result.warnings.map((warning) => `  - ${warning}`)] : []),
     ].join("\n");
 }
+export function formatMcpDiscoveryResult(result) {
+    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) {
+    try {
+        const mcpClient = await import("../mcp-client/index.js");
+        const mod = mcpClient;
+        if (typeof mod.getConnectionStatus === "function") {
+            return mod.getConnectionStatus(serverName);
+        }
+    }
+    catch {
+        // mcp-client may not expose status helpers in some hosts.
+    }
+    return { connected: false, tools: [] };
+}
+function shouldProbeConfiguredServer(config) {
+    return !config.disabled && config.transport === "stdio" && (config.envWarnings?.length ?? 0) === 0;
+}
+async function resolveMcpRuntimeStatus(config, systemPrompt) {
+    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, ctx) {
     const trimmed = args.trim();
@@ -146,6 +211,24 @@ export async function handleMcpStatus(args, ctx) {
         }
         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();
@@ -245,33 +328,15 @@ export async function handleMcpStatus(args, ctx) {
             ctx.ui.notify(`Unknown MCP server: "${serverName}"\n\nAvailable: ${available}`, "warning");
             return;
         }
-        // Try to get connection/tool info from the mcp-client module if available
-        let connected = false;
-        let toolNames = [];
-        let error;
-        try {
-            const mcpClient = await import("../mcp-client/index.js");
-            // Access the module's connection state if exported; fall back gracefully
-            const mod = mcpClient;
-            if (typeof mod.getConnectionStatus === "function") {
-                const status = mod.getConnectionStatus(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,
@@ -280,38 +345,20 @@ export async function handleMcpStatus(args, ctx) {
     }
     // /gsd mcp or /gsd mcp status
     if (!lowered || lowered === "status") {
-        // Build status for each server
-        const statuses = [];
-        for (const config of configs) {
-            let connected = false;
-            let toolCount = 0;
-            let error;
-            try {
-                const mcpClient = await import("../mcp-client/index.js");
-                const mod = mcpClient;
-                if (typeof mod.getConnectionStatus === "function") {
-                    const status = mod.getConnectionStatus(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 = 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,
             ...management.duplicates.map((dup) => `Duplicate "${dup.name}" from ${dup.shadowedSourcePath} is shadowed by ${dup.keptSourcePath}.`),
@@ -323,9 +370,10 @@ export async function handleMcpStatus(args, ctx) {
         return;
     }
     // 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" +
+    ctx.ui.notify("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/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -11,6 +11,8 @@ import { fileURLToPath } from "node:url";
 import { getGlobalGSDPreferencesPath, getLegacyGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, loadGlobalGSDPreferences, loadProjectGSDPreferences, loadEffectiveGSDPreferences, normalizePreferencesShape, resolveAllSkillReferences, } from "./preferences.js";
 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"];
 /** Extract body content after frontmatter closing delimiter, or null if none. */
 function extractBodyAfterFrontmatter(content) {
     const closingIdx = content.indexOf("\n---", content.indexOf("---"));
@@ -1509,7 +1511,7 @@ async function configureAdvanced(ctx, prefs) {
     else if (minRequestInterval !== undefined) {
         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 ?? {};

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

@@ -166,6 +166,6 @@ export async function handleVerdict(rawArgs, ctx, basePath) {
         ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`, "success");
     }
     if (effectiveVerdict === "needs-remediation") {
-        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+        ctx.ui.notify("Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.", "info");
     }
 }

package/dist/resources/extensions/gsd/config-overlay.js

@@ -9,6 +9,7 @@
 import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, resolveDynamicRoutingConfig, resolveEffectiveProfile, resolveModelWithFallbacksForUnit, resolveAutoSupervisorConfig, } from "./preferences.js";
+const DEFAULT_WIDGET_MODE = "small";
 function collectConfigSections() {
     const sections = [];
     const globalPrefs = loadGlobalGSDPreferences();
@@ -157,7 +158,7 @@ function collectConfigSections() {
         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")
+    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" });

package/dist/resources/extensions/gsd/error-classifier.js

@@ -21,9 +21,10 @@ export function resetRetryState(state) {
 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/dist/resources/extensions/gsd/exec-sandbox.js

@@ -247,6 +247,7 @@ function writeMeta(path, result, request, now) {
         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(),
@@ -260,6 +261,7 @@ function writeMeta(path, result, request, now) {
         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`);
 }