gsd-pi 2.44.0 → 2.45.0-dev.6b9da3e

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -1,7 +1,9 @@
 import { Type } from "@sinclair/typebox";
+import { Text } from "@gsd/pi-tui";
 import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMilestoneIds } from "../guided-flow.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
+import { StringEnum } from "@gsd/pi-ai";
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -77,6 +79,26 @@ export function registerDbTools(pi) {
             ], { description: "Who made this decision: 'human' (user directed), 'agent' (LLM decided autonomously), or 'collaborative' (discussed and agreed). Default: 'agent'" })),
         }),
         execute: decisionSaveExecute,
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("decision_save "));
+            if (args.scope)
+                text += theme.fg("accent", `[${args.scope}] `);
+            if (args.decision)
+                text += theme.fg("muted", args.decision);
+            if (args.choice)
+                text += theme.fg("dim", ` — ${args.choice}`);
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = result.details;
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", `Decision ${d?.id ?? ""} saved`);
+            if (d?.id)
+                text += theme.fg("dim", ` → DECISIONS.md`);
+            return new Text(text, 0, 0);
+        },
     };
     pi.registerTool(decisionSaveTool);
     registerAlias(pi, decisionSaveTool, "gsd_save_decision", "gsd_decision_save");
@@ -149,6 +171,24 @@ export function registerDbTools(pi) {
             supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
         }),
         execute: requirementUpdateExecute,
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("requirement_update "));
+            if (args.id)
+                text += theme.fg("accent", args.id);
+            const fields = ["status", "validation", "notes", "description"].filter((f) => args[f]);
+            if (fields.length > 0)
+                text += theme.fg("dim", ` (${fields.join(", ")})`);
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = result.details;
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", `Requirement ${d?.id ?? ""} updated`);
+            text += theme.fg("dim", ` → REQUIREMENTS.md`);
+            return new Text(text, 0, 0);
+        },
     };
     pi.registerTool(requirementUpdateTool);
     registerAlias(pi, requirementUpdateTool, "gsd_update_requirement", "gsd_requirement_update");
@@ -222,6 +262,25 @@ export function registerDbTools(pi) {
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
         execute: summarySaveExecute,
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("summary_save "));
+            if (args.artifact_type)
+                text += theme.fg("accent", args.artifact_type);
+            const path = [args.milestone_id, args.slice_id, args.task_id].filter(Boolean).join("/");
+            if (path)
+                text += theme.fg("dim", ` ${path}`);
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = result.details;
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", `${d?.artifact_type ?? "Artifact"} saved`);
+            if (d?.path)
+                text += theme.fg("dim", ` → ${d.path}`);
+            return new Text(text, 0, 0);
+        },
     };
     pi.registerTool(summarySaveTool);
     registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
@@ -232,6 +291,7 @@ export function registerDbTools(pi) {
             // This guarantees the ID shown in the UI matches the one materialised on disk.
             const reserved = claimReservedId();
             if (reserved) {
+                await ensureMilestoneDbRow(reserved);
                 return {
                     content: [{ type: "text", text: reserved }],
                     details: { operation: "generate_milestone_id", id: reserved, source: "reserved" },
@@ -242,6 +302,7 @@ export function registerDbTools(pi) {
             const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
             const newId = nextMilestoneId(allIds, uniqueEnabled);
+            await ensureMilestoneDbRow(newId);
             return {
                 content: [{ type: "text", text: newId }],
                 details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled },
@@ -255,6 +316,24 @@ export function registerDbTools(pi) {
             };
         }
     };
+    /**
+     * Insert a minimal DB row for a milestone ID so it's visible to the state
+     * machine. Uses INSERT OR IGNORE — safe to call even if gsd_plan_milestone
+     * later writes the full row. Silently skips if the DB isn't available yet
+     * (pre-migration).
+     */
+    async function ensureMilestoneDbRow(milestoneId) {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable)
+            return;
+        try {
+            const { insertMilestone } = await import("../gsd-db.js");
+            insertMilestone({ id: milestoneId, status: "queued" });
+        }
+        catch {
+            // Non-fatal — the safety-net in deriveStateFromDb will catch this
+        }
+    }
     const milestoneGenerateIdTool = {
         name: "gsd_milestone_generate_id",
         label: "Generate Milestone ID",
@@ -270,6 +349,19 @@ export function registerDbTools(pi) {
         ],
         parameters: Type.Object({}),
         execute: milestoneGenerateIdExecute,
+        renderCall(_args, theme) {
+            return new Text(theme.fg("toolTitle", theme.bold("milestone_generate_id")), 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = result.details;
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", `Generated ${d?.id ?? "ID"}`);
+            if (d?.source === "reserved")
+                text += theme.fg("dim", " (reserved)");
+            return new Text(text, 0, 0);
+        },
     };
     pi.registerTool(milestoneGenerateIdTool);
     registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
@@ -732,6 +824,70 @@ export function registerDbTools(pi) {
     };
     pi.registerTool(milestoneCompleteTool);
     registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
+    // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
+    const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
+                details: { operation: "validate_milestone", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { handleValidateMilestone } = await import("../tools/validate-milestone.js");
+            const result = await handleValidateMilestone(params, process.cwd());
+            if ("error" in result) {
+                return {
+                    content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
+                    details: { operation: "validate_milestone", error: result.error },
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Validated milestone ${result.milestoneId} — verdict: ${result.verdict}. Written to ${result.validationPath}` }],
+                details: {
+                    operation: "validate_milestone",
+                    milestoneId: result.milestoneId,
+                    verdict: result.verdict,
+                    validationPath: result.validationPath,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`gsd-db: validate_milestone tool failed: ${msg}\n`);
+            return {
+                content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
+                details: { operation: "validate_milestone", error: msg },
+            };
+        }
+    };
+    const milestoneValidateTool = {
+        name: "gsd_validate_milestone",
+        label: "Validate Milestone",
+        description: "Validate a milestone before completion — persist validation results to the DB, render VALIDATION.md to disk. " +
+            "Records verdict (pass/needs-attention/needs-remediation) and rationale.",
+        promptSnippet: "Validate a GSD milestone (DB write + VALIDATION.md render)",
+        promptGuidelines: [
+            "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
+            "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verdictRationale, remediationPlan (optional).",
+            "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
+            "On success, returns validationPath where VALIDATION.md was written.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            verdict: StringEnum(["pass", "needs-attention", "needs-remediation"], { description: "Validation verdict" }),
+            remediationRound: Type.Number({ description: "Remediation round (0 for first validation)" }),
+            successCriteriaChecklist: Type.String({ description: "Markdown checklist of success criteria with pass/fail and evidence" }),
+            sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
+            crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
+            requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
+            verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
+            remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
+        }),
+        execute: milestoneValidateExecute,
+    };
+    pi.registerTool(milestoneValidateTool);
+    registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const dbAvailable = await ensureDbOpen();

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

@@ -45,18 +45,9 @@ export async function buildBeforeAgentStartResult(event, ctx) {
             ctx.ui.notify(`GSD skill preferences: ${report.warnings.length} unresolved skill${report.warnings.length === 1 ? "" : "s"}: ${report.warnings.join(", ")}`, "warning");
         }
     }
-    let knowledgeBlock = "";
-    const knowledgePath = resolveGsdRootFile(process.cwd(), "KNOWLEDGE");
-    if (existsSync(knowledgePath)) {
-        try {
-            const content = readFileSync(knowledgePath, "utf-8").trim();
-            if (content) {
-                knowledgeBlock = `\n\n[PROJECT KNOWLEDGE — Rules, patterns, and lessons learned]\n\n${content}`;
-            }
-        }
-        catch {
-            // skip
-        }
+    const { block: knowledgeBlock, globalSizeKb } = loadKnowledgeBlock(gsdHome, process.cwd());
+    if (globalSizeKb > 4) {
+        ctx.ui.notify(`GSD: ~/.gsd/agent/KNOWLEDGE.md is ${globalSizeKb.toFixed(1)}KB — consider trimming to keep system prompt lean.`, "warning");
     }
     let memoryBlock = "";
     try {
@@ -102,6 +93,49 @@ export async function buildBeforeAgentStartResult(event, ctx) {
             : {}),
     };
 }
+export function loadKnowledgeBlock(gsdHomeDir, cwd) {
+    // 1. Global knowledge (~/.gsd/agent/KNOWLEDGE.md) — cross-project, user-maintained
+    let globalKnowledge = "";
+    let globalSizeKb = 0;
+    const globalKnowledgePath = join(gsdHomeDir, "agent", "KNOWLEDGE.md");
+    if (existsSync(globalKnowledgePath)) {
+        try {
+            const content = readFileSync(globalKnowledgePath, "utf-8").trim();
+            if (content) {
+                globalSizeKb = Buffer.byteLength(content, "utf-8") / 1024;
+                globalKnowledge = content;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    // 2. Project knowledge (.gsd/KNOWLEDGE.md) — project-specific
+    let projectKnowledge = "";
+    const knowledgePath = resolveGsdRootFile(cwd, "KNOWLEDGE");
+    if (existsSync(knowledgePath)) {
+        try {
+            const content = readFileSync(knowledgePath, "utf-8").trim();
+            if (content)
+                projectKnowledge = content;
+        }
+        catch {
+            // skip
+        }
+    }
+    if (!globalKnowledge && !projectKnowledge) {
+        return { block: "", globalSizeKb: 0 };
+    }
+    const parts = [];
+    if (globalKnowledge)
+        parts.push(`## Global Knowledge\n\n${globalKnowledge}`);
+    if (projectKnowledge)
+        parts.push(`## Project Knowledge\n\n${projectKnowledge}`);
+    return {
+        block: `\n\n[KNOWLEDGE — Rules, patterns, and lessons learned]\n\n${parts.join("\n\n")}`,
+        globalSizeKb,
+    };
+}
 function buildWorktreeContextBlock() {
     const worktreeName = getActiveWorktreeName();
     const worktreeMainCwd = getWorktreeOriginalCwd();

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -56,6 +56,8 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "templates", desc: "List available workflow templates" },
     { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
     { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
+    { cmd: "mcp", desc: "MCP server status and connectivity check (status, check <server>)" },
+    { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
     { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
 ];
 const NESTED_COMPLETIONS = {
@@ -174,6 +176,10 @@ const NESTED_COMPLETIONS = {
         { cmd: "flex", desc: "Flex tier (0.5x cost, slower)" },
         { cmd: "status", desc: "Show current service tier setting" },
     ],
+    mcp: [
+        { cmd: "status", desc: "Show all MCP server statuses (default)" },
+        { cmd: "check", desc: "Detailed status for a specific server" },
+    ],
     doctor: [
         { cmd: "fix", desc: "Auto-fix detected issues" },
         { cmd: "heal", desc: "AI-driven deep healing" },

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

@@ -32,6 +32,7 @@ export function showHelp(ctx) {
         "  /gsd triage         Classify and route pending captures",
         "  /gsd skip <unit>    Prevent a unit from auto-mode dispatch",
         "  /gsd undo           Revert last completed unit  [--force]",
+        "  /gsd rethink        Conversational project reorganization — reorder, park, discard, add milestones",
         "  /gsd park [id]      Park a milestone — skip without deleting  [reason]",
         "  /gsd unpark [id]    Reactivate a parked milestone",
         "",
@@ -49,6 +50,7 @@ export function showHelp(ctx) {
         "  /gsd hooks          Show post-unit hook configuration",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
         "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
+        "  /gsd mcp            MCP server status and connectivity  [status|check <server>]",
         "",
         "MAINTENANCE",
         "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",

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

@@ -188,10 +188,20 @@ Examples:
         await handleFast(trimmed.replace(/^fast\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "mcp" || trimmed.startsWith("mcp ")) {
+        const { handleMcpStatus } = await import("../../commands-mcp-status.js");
+        await handleMcpStatus(trimmed.replace(/^mcp\s*/, "").trim(), ctx);
+        return true;
+    }
     if (trimmed === "extensions" || trimmed.startsWith("extensions ")) {
         const { handleExtensions } = await import("../../commands-extensions.js");
         await handleExtensions(trimmed.replace(/^extensions\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "rethink") {
+        const { handleRethink } = await import("../../rethink.js");
+        await handleRethink(trimmed, ctx, pi);
+        return true;
+    }
     return false;
 }

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

@@ -166,6 +166,11 @@ export async function handleWorkflowCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "quick" || trimmed.startsWith("quick ")) {
+        if (isAutoActive()) {
+            ctx.ui.notify("/gsd quick cannot run while auto-mode is active.\n" +
+                "Stop auto-mode first with /gsd stop, then run /gsd quick.", "error");
+            return true;
+        }
         await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
         return true;
     }

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

@@ -0,0 +1,187 @@
+/**
+ * MCP Status — `/gsd mcp` command handler.
+ *
+ * Shows configured MCP servers, their connection status, and available tools.
+ *
+ * Subcommands:
+ *   /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
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function readMcpConfigs() {
+    const servers = [];
+    const seen = new Set();
+    const configPaths = [
+        join(process.cwd(), ".mcp.json"),
+        join(process.cwd(), ".gsd", "mcp.json"),
+    ];
+    for (const configPath of configPaths) {
+        try {
+            if (!existsSync(configPath))
+                continue;
+            const raw = readFileSync(configPath, "utf-8");
+            const data = JSON.parse(raw);
+            const mcpServers = (data.mcpServers ?? data.servers);
+            if (!mcpServers || typeof mcpServers !== "object")
+                continue;
+            for (const [name, config] of Object.entries(mcpServers)) {
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                const hasCommand = typeof config.command === "string";
+                const hasUrl = typeof config.url === "string";
+                const transport = hasCommand
+                    ? "stdio"
+                    : hasUrl
+                        ? "http"
+                        : "unknown";
+                servers.push({
+                    name,
+                    transport,
+                    ...(hasCommand && {
+                        command: config.command,
+                        args: Array.isArray(config.args) ? config.args : undefined,
+                    }),
+                    ...(hasUrl && { url: config.url }),
+                });
+            }
+        }
+        catch {
+            // Non-fatal — config file may not exist or be malformed
+        }
+    }
+    return servers;
+}
+// ─── Formatters (exported for testing) ──────────────────────────────────────
+export function formatMcpStatusReport(servers) {
+    if (servers.length === 0) {
+        return [
+            "No MCP servers configured.",
+            "",
+            "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+            "See: https://modelcontextprotocol.io/quickstart",
+        ].join("\n");
+    }
+    const lines = [`MCP Server Status — ${servers.length} server(s)\n`];
+    for (const s of servers) {
+        const icon = s.error ? "✗" : s.connected ? "✓" : "○";
+        const status = s.error
+            ? `error: ${s.error}`
+            : s.connected
+                ? `connected — ${s.toolCount} tools`
+                : "disconnected";
+        lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}`);
+    }
+    lines.push("");
+    lines.push("Use /gsd mcp check <server> for details on a specific server.");
+    lines.push("Use mcp_discover to connect and list tools for a server.");
+    return lines.join("\n");
+}
+export function formatMcpServerDetail(server) {
+    const lines = [`MCP Server: ${server.name}\n`];
+    lines.push(`  Transport: ${server.transport}`);
+    if (server.error) {
+        lines.push(`  Status:    error`);
+        lines.push(`  Error:     ${server.error}`);
+    }
+    else if (server.connected) {
+        lines.push(`  Status:    connected`);
+        lines.push(`  Tools:     ${server.toolCount}`);
+        if (server.tools.length > 0) {
+            lines.push("");
+            lines.push("  Available tools:");
+            for (const tool of server.tools) {
+                lines.push(`    - ${tool}`);
+            }
+        }
+    }
+    else {
+        lines.push(`  Status:    disconnected`);
+        lines.push("");
+        lines.push(`  Run mcp_discover("${server.name}") to connect and list tools.`);
+    }
+    return lines.join("\n");
+}
+// ─── Command handler ────────────────────────────────────────────────────────
+/**
+ * Handle `/gsd mcp [status|check <server>]`.
+ */
+export async function handleMcpStatus(args, ctx) {
+    const trimmed = args.trim().toLowerCase();
+    const configs = readMcpConfigs();
+    // /gsd mcp check <server>
+    if (trimmed.startsWith("check ")) {
+        const serverName = args.trim().slice("check ".length).trim();
+        const config = configs.find((c) => c.name === serverName);
+        if (!config) {
+            const available = configs.map((c) => c.name).join(", ") || "(none)";
+            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
+        }
+        ctx.ui.notify(formatMcpServerDetail({
+            name: config.name,
+            transport: config.transport,
+            connected,
+            toolCount: toolNames.length,
+            tools: toolNames,
+            error,
+        }), "info");
+        return;
+    }
+    // /gsd mcp or /gsd mcp status
+    if (!trimmed || trimmed === "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
+            }
+            statuses.push({
+                name: config.name,
+                transport: config.transport,
+                connected,
+                toolCount,
+                error,
+            });
+        }
+        ctx.ui.notify(formatMcpStatusReport(statuses), "info");
+        return;
+    }
+    // Unknown subcommand
+    ctx.ui.notify("Usage: /gsd mcp [status|check <server>]\n\n" +
+        "  status           Show all MCP server statuses (default)\n" +
+        "  check <server>   Detailed status for a specific server", "warning");
+}

package/dist/resources/extensions/gsd/db-writer.js

@@ -8,7 +8,7 @@
 // Critical invariant: generated markdown must round-trip through
 // parseDecisionsTable() and parseRequirementsSections() with field fidelity.
 import { resolve } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
 import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
@@ -356,28 +356,46 @@ export async function updateRequirementInDb(id, updates, basePath) {
 export async function saveArtifactToDb(opts, basePath) {
     try {
         const db = await import('./gsd-db.js');
+        // Guard against path traversal before any reads/writes
+        const gsdDir = resolve(basePath, '.gsd');
+        const fullPath = resolve(basePath, '.gsd', opts.path);
+        if (!fullPath.startsWith(gsdDir)) {
+            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
+        }
+        // Shrinkage guard: if the file already exists and the new content is
+        // significantly smaller (<50%), preserve the richer file on disk and
+        // store its content in the DB instead of the abbreviated version.
+        let dbContent = opts.content;
+        let skipDiskWrite = false;
+        if (existsSync(fullPath)) {
+            const existingSize = statSync(fullPath).size;
+            const newSize = Buffer.byteLength(opts.content, 'utf-8');
+            if (existingSize > 0 && newSize < existingSize * 0.5) {
+                process.stderr.write(`gsd-db: saveArtifactToDb — new content (${newSize}B) is <50% of existing file ` +
+                    `(${existingSize}B) at ${opts.path}. Preserving disk file to prevent data loss.\n`);
+                dbContent = readFileSync(fullPath, 'utf-8');
+                skipDiskWrite = true;
+            }
+        }
         db.insertArtifact({
             path: opts.path,
             artifact_type: opts.artifact_type,
             milestone_id: opts.milestone_id ?? null,
             slice_id: opts.slice_id ?? null,
             task_id: opts.task_id ?? null,
-            full_content: opts.content,
+            full_content: dbContent,
         });
-        // Write the file to disk (guard against path traversal)
-        const gsdDir = resolve(basePath, '.gsd');
-        const fullPath = resolve(basePath, '.gsd', opts.path);
-        if (!fullPath.startsWith(gsdDir)) {
-            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
-        }
-        try {
-            await saveFile(fullPath, opts.content);
-        }
-        catch (diskErr) {
-            process.stderr.write(`gsd-db: saveArtifactToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
-            const rollbackAdapter = db._getAdapter();
-            rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
-            throw diskErr;
+        // Write the file to disk (only if we're not preserving a richer existing file)
+        if (!skipDiskWrite) {
+            try {
+                await saveFile(fullPath, opts.content);
+            }
+            catch (diskErr) {
+                process.stderr.write(`gsd-db: saveArtifactToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
+                const rollbackAdapter = db._getAdapter();
+                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                throw diskErr;
+            }
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.

package/dist/resources/extensions/gsd/doctor.js

@@ -441,6 +441,7 @@ export async function runGSDDoctor(basePath, options) {
                 id: s.id,
                 title: s.title,
                 done: s.status === "complete",
+                pending: s.status === "pending",
                 risk: (s.risk || "medium"),
                 depends: s.depends,
                 demo: s.demo,
@@ -528,6 +529,10 @@ export async function runGSDDoctor(basePath, options) {
             }
             const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
             if (!slicePath) {
+                // Pending slices haven't been planned yet — directories are created
+                // lazily by ensurePreconditions() at dispatch time. Skip them.
+                if (slice.pending)
+                    continue;
                 const expectedPath = relSlicePath(basePath, milestoneId, slice.id);
                 issues.push({
                     severity: slice.done ? "warning" : "error",
@@ -549,6 +554,9 @@ export async function runGSDDoctor(basePath, options) {
             }
             const tasksDir = resolveTasksDir(basePath, milestoneId, slice.id);
             if (!tasksDir) {
+                // Pending slices haven't been planned yet — tasks/ is created on demand.
+                if (slice.pending)
+                    continue;
                 issues.push({
                     severity: slice.done ? "warning" : "error",
                     code: "missing_tasks_dir",