@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -5,6 +5,8 @@
  * handleRunHook, handleUpdate, handleSkillHealth
  */
 import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
 import { join, resolve as resolvePath, sep } from "node:path";
 import { homedir } from "node:os";
 import { deriveState } from "./state.js";
@@ -20,7 +22,10 @@ import { loadPrompt } from "./prompt-loader.js";
 import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
 import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
+const GSD_PI_PACKAGE = "@opengsd/gsd-pi";
+const GSD_BROWSER_PACKAGE = "@opengsd/gsd-browser";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-pi/latest";
+const BROWSER_UPDATE_REGISTRY_URL = "https://registry.npmjs.org/@opengsd%2fgsd-browser/latest";
 const UPDATE_FETCH_TIMEOUT_MS = 5000;
 // Detects a bun-installed gsd via `process.argv[1]`. Mirrors isBunInstall in
 // src/update-check.ts — duplicated because tsconfig.resources.json rootDir
@@ -47,11 +52,11 @@ function resolveInstallCommand(pkg) {
         return `pnpm add -g ${pkg}`;
     return `npm install -g ${pkg}`;
 }
-async function fetchLatestVersionForCommand() {
+async function fetchLatestVersionForCommand(registryUrl = UPDATE_REGISTRY_URL) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
     try {
-        const res = await fetch(UPDATE_REGISTRY_URL, { signal: controller.signal });
+        const res = await fetch(registryUrl, { signal: controller.signal });
         if (!res.ok)
             return null;
         const data = (await res.json());
@@ -65,6 +70,19 @@ async function fetchLatestVersionForCommand() {
         clearTimeout(timeout);
     }
 }
+function resolveInstalledPackageVersionForCommand(packageName) {
+    try {
+        const requireFromHere = createRequire(import.meta.url);
+        const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        return typeof pkg.version === "string" && pkg.version.trim().length > 0
+            ? pkg.version.trim().replace(/^v/, "")
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
@@ -386,27 +404,74 @@ function compareSemverLocal(a, b) {
     }
     return 0;
 }
-export async function handleUpdate(ctx) {
+function formatCommandVersion(version) {
+    return version ? `v${version}` : "unknown";
+}
+function pickHigherVersionForCommand(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return compareSemverLocal(a, b) >= 0 ? a : b;
+}
+// Mirrors resolveGsdBrowserPathVersion in src/update-check.ts — duplicated because
+// tsconfig.resources.json rootDir prevents importing from src/.
+function resolveGsdBrowserPathVersionForCommand(env = process.env) {
+    const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+    if (explicit)
+        return explicit.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    try {
+        const out = execFileSync("gsd-browser", ["--version"], {
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        });
+        return out.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleUpdate(ctx, args = "") {
     const { execSync } = await import("node:child_process");
-    const NPM_PACKAGE = "@opengsd/gsd-pi";
-    const current = process.env.GSD_VERSION || "0.0.0";
-    ctx.ui.notify(`Current version: v${current}\nChecking npm registry...`, "info");
-    const latest = await fetchLatestVersionForCommand();
+    const target = args.trim();
+    const browserUpdate = target === "browser" || target === "gsd-browser";
+    if (target && !browserUpdate) {
+        ctx.ui.notify("Usage: /gsd update [browser]", "warning");
+        return;
+    }
+    const NPM_PACKAGE = browserUpdate ? GSD_BROWSER_PACKAGE : GSD_PI_PACKAGE;
+    const registryUrl = browserUpdate ? BROWSER_UPDATE_REGISTRY_URL : UPDATE_REGISTRY_URL;
+    const bundledVersion = browserUpdate
+        ? resolveInstalledPackageVersionForCommand(GSD_BROWSER_PACKAGE)
+        : null;
+    const current = browserUpdate
+        ? pickHigherVersionForCommand(bundledVersion, resolveGsdBrowserPathVersionForCommand())
+        : process.env.GSD_VERSION || "0.0.0";
+    const label = browserUpdate ? "gsd-browser version" : "version";
+    ctx.ui.notify(`Current ${label}: ${formatCommandVersion(current)}\nChecking npm registry...`, "info");
+    const latest = await fetchLatestVersionForCommand(registryUrl);
     if (!latest) {
         ctx.ui.notify("Failed to reach npm registry. Check your network connection.", "error");
         return;
     }
-    if (compareSemverLocal(latest, current) <= 0) {
-        ctx.ui.notify(`Already up to date (v${current}).`, "info");
+    if (current && compareSemverLocal(latest, current) <= 0) {
+        ctx.ui.notify(`Already up to date (${formatCommandVersion(current)}).`, "info");
         return;
     }
-    ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    ctx.ui.notify(`Updating: ${formatCommandVersion(current)} → v${latest}...`, "info");
     const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
         execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
-        ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
+        const newPathVersion = browserUpdate ? resolveGsdBrowserPathVersionForCommand() : null;
+        const pathReady = !browserUpdate || (!!newPathVersion && compareSemverLocal(newPathVersion, latest) >= 0);
+        ctx.ui.notify(browserUpdate
+            ? `Updated gsd-browser to v${latest}. Restart your GSD session to use the new browser automation version.` +
+                (pathReady ? "" : "\nNote: Ensure the npm global bin directory is on your PATH so MCP automation uses the updated binary.")
+            : `Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
     }
     catch {
         ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");

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);
@@ -31,7 +33,8 @@ export function formatMcpInitResult(status, configPath, targetPath) {
         `Project: ${targetPath}`,
         `Config:   ${configPath}`,
         "",
-        "MCP-capable clients can now load the GSD workflow MCP server from this folder.",
+        "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
+        "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
         "Restart or reconnect any client that already has this project open.",
     ].join("\n");
 }
@@ -48,21 +51,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 +82,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 +96,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 +125,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 +212,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 +329,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 +346,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 +371,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" });