gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -17,6 +17,7 @@ import { createWorktree, removeWorktree, resolveGitDir, worktreePath, } from "./
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -109,6 +110,7 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(mainGsd, f);
@@ -269,8 +271,9 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
     // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
     // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
     // PROJECT, etc. These must overwrite main's copies so they survive teardown.
-    // Also includes QUEUE.md and completed-units.json which are written during
-    // milestone closeout and lost on teardown without explicit sync (#1787).
+    // Also includes QUEUE.md, completed-units.json, and metrics.json which are
+    // written during milestone closeout and lost on teardown without explicit sync
+    // (#1787, #2313).
     const rootFiles = [
         "DECISIONS.md",
         "REQUIREMENTS.md",
@@ -279,6 +282,7 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(wtGsd, f);
@@ -612,7 +616,7 @@ export function createAutoWorktree(basePath, milestoneId) {
     const hookError = runWorktreePostCreateHook(basePath, info.path);
     if (hookError) {
         // Non-fatal — log but don't prevent worktree usage
-        console.error(`[GSD] ${hookError}`);
+        logWarning("reconcile", hookError, { worktree: info.name });
     }
     const previousCwd = process.cwd();
     try {
@@ -687,9 +691,9 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     // backslashes (#1436), leaving ~1 GB+ orphaned directories.
     const wtDir = worktreePath(originalBasePath, milestoneId);
     if (existsSync(wtDir)) {
-        console.error(`[GSD] WARNING: Worktree directory still exists after teardown: ${wtDir}\n` +
-            `  This is likely an orphaned directory consuming disk space.\n` +
-            `  Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`);
+        logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
+            `This is likely an orphaned directory consuming disk space. ` +
+            `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
         // Attempt a direct filesystem removal as a fallback
         try {
             rmSync(wtDir, { recursive: true, force: true });
@@ -1133,9 +1137,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // Push failure is non-fatal
         }
     }
-    // 9b. Auto-create PR if enabled (requires push_branches + push succeeded)
+    // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
     let prCreated = false;
-    if (prefs.auto_pr === true && pushed) {
+    if (prefs.auto_pr === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         const prTarget = prefs.pr_target_branch ?? mainBranch;
         try {
@@ -1145,9 +1149,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
             });
-            // Create PR via gh CLI
+            // Create PR via gh CLI with explicit --head and --base (#2302)
             execFileSync("gh", [
-                "pr", "create",
+                "pr", "create", "--draft",
                 "--base", prTarget,
                 "--head", milestoneBranch,
                 "--title", `Milestone ${milestoneId} complete`,

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

@@ -82,11 +82,10 @@ const s = new AutoSession();
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 export function shouldUseWorktreeIsolation() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-    if (prefs?.isolation === "none")
-        return false;
-    if (prefs?.isolation === "branch")
-        return false;
-    return true; // default: worktree
+    if (prefs?.isolation === "worktree")
+        return true;
+    // Default is false — worktree isolation requires explicit opt-in
+    return false;
 }
 /** Crash recovery prompt — set by startAuto, consumed by the main loop */
 /** Pending verification retry — set when gate fails with retries remaining, consumed by autoLoop */
@@ -369,14 +368,41 @@ export async function stopAuto(ctx, pi, reason) {
             debugLog("stop-cleanup-sigterm", { error: e instanceof Error ? e.message : String(e) });
         }
         // ── Step 4: Auto-worktree exit ──
+        // When the milestone is complete (has a SUMMARY), merge the worktree branch
+        // back to main so code isn't stranded on the worktree branch (#2317).
+        // For incomplete milestones, preserve the branch for later resumption.
         try {
             if (s.currentMilestoneId) {
                 const notifyCtx = ctx
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
-                buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
-                    preserveBranch: true,
-                });
+                const resolver = buildResolver();
+                // Check if the milestone is complete — SUMMARY file is the authoritative signal.
+                let milestoneComplete = false;
+                try {
+                    const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
+                    if (!summaryPath) {
+                        // Also check in the worktree path (SUMMARY may not be synced yet)
+                        const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
+                        milestoneComplete = wtSummaryPath !== null;
+                    }
+                    else {
+                        milestoneComplete = true;
+                    }
+                }
+                catch {
+                    // Non-fatal — fall through to preserveBranch path
+                }
+                if (milestoneComplete) {
+                    // Milestone is complete — merge worktree branch back to main
+                    resolver.mergeAndExit(s.currentMilestoneId, notifyCtx);
+                }
+                else {
+                    // Milestone still in progress — preserve branch for later resumption
+                    resolver.exitMilestone(s.currentMilestoneId, notifyCtx, {
+                        preserveBranch: true,
+                    });
+                }
             }
         }
         catch (e) {

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

@@ -1,7 +1,10 @@
 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";
+import { logError } from "../workflow-logger.js";
 /**
  * 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.
@@ -43,7 +46,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_decision_save tool failed: ${msg}\n`);
+            logError("tool", `gsd_decision_save tool failed: ${msg}`, { tool: "gsd_decision_save", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error saving decision: ${msg}` }],
                 details: { operation: "save_decision", error: msg },
@@ -77,6 +80,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");
@@ -120,7 +143,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_requirement_update tool failed: ${msg}\n`);
+            logError("tool", `gsd_requirement_update tool failed: ${msg}`, { tool: "gsd_requirement_update", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error updating requirement: ${msg}` }],
                 details: { operation: "update_requirement", id: params.id, error: msg },
@@ -149,6 +172,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");
@@ -195,7 +236,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_summary_save tool failed: ${msg}\n`);
+            logError("tool", `gsd_summary_save tool failed: ${msg}`, { tool: "gsd_summary_save", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
                 details: { operation: "save_summary", error: msg },
@@ -222,6 +263,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 +292,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 +303,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 +317,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 +350,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");
@@ -302,7 +395,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_milestone tool failed: ${msg}\n`);
+            logError("tool", `plan_milestone tool failed: ${msg}`, { tool: "gsd_plan_milestone", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
                 details: { operation: "plan_milestone", error: msg },
@@ -391,7 +484,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_slice tool failed: ${msg}\n`);
+            logError("tool", `plan_slice tool failed: ${msg}`, { tool: "gsd_plan_slice", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning slice: ${msg}` }],
                 details: { operation: "plan_slice", error: msg },
@@ -464,7 +557,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_task tool failed: ${msg}\n`);
+            logError("tool", `plan_task tool failed: ${msg}`, { tool: "gsd_plan_task", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning task: ${msg}` }],
                 details: { operation: "plan_task", error: msg },
@@ -530,7 +623,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_task tool failed: ${msg}\n`);
+            logError("tool", `complete_task tool failed: ${msg}`, { tool: "gsd_task_complete", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing task: ${msg}` }],
                 details: { operation: "complete_task", error: msg },
@@ -604,7 +697,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_slice tool failed: ${msg}\n`);
+            logError("tool", `complete_slice tool failed: ${msg}`, { tool: "gsd_slice_complete", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing slice: ${msg}` }],
                 details: { operation: "complete_slice", error: msg },
@@ -696,7 +789,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_milestone tool failed: ${msg}\n`);
+            logError("tool", `complete_milestone tool failed: ${msg}`, { tool: "gsd_complete_milestone", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
                 details: { operation: "complete_milestone", error: msg },
@@ -732,6 +825,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);
+            logError("tool", `validate_milestone tool failed: ${msg}`, { tool: "gsd_validate_milestone", error: String(err) });
+            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();
@@ -763,7 +920,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: replan_slice tool failed: ${msg}\n`);
+            logError("tool", `replan_slice tool failed: ${msg}`, { tool: "gsd_replan_slice", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
                 details: { operation: "replan_slice", error: msg },
@@ -836,7 +993,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: reassess_roadmap tool failed: ${msg}\n`);
+            logError("tool", `reassess_roadmap tool failed: ${msg}`, { tool: "gsd_reassess_roadmap", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
                 details: { operation: "reassess_roadmap", error: msg },

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;
     }