gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -1,6 +1,7 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { minimatch } from "minimatch";
+import { logWarning } from "../workflow-logger.js";
 /**
  * Regex matching milestone CONTEXT.md file names in both legacy M001
  * and unique M001-abc123 formats. Exported so regex-hardening tests
@@ -441,8 +442,67 @@ export function shouldBlockQueueExecutionInSnapshot(snapshot, toolName, input, q
     };
 }
 // ─── Planning-unit tools-policy enforcement (#4934) ───────────────────────
+//
+// Runtime half of the declarative ToolsPolicy on UnitContextManifest. The
+// manifest assigns each unit type a tools mode; this predicate is what
+// actually rejects a tool call that violates it.
+//
+// Forensics: a discuss-milestone LLM turn used the host Edit tool to modify
+// index.html in test app b23 (~/Github/test-apps/b23). With this predicate
+// wired into the tool_call hook, the same call returns block=true with a
+// HARD BLOCK reason that the model cannot rationalize past.
+//
+// Activation: the hook supplies the policy resolved from the active unit's
+// manifest. When no unit is active (interactive sessions, unknown unit
+// types), the hook passes null and this predicate is a no-op — falling
+// through to the existing pendingGate / queue-execution / context-write
+// guards.
 const PLANNING_WRITE_TOOLS = new Set(["write", "edit", "multi_edit", "notebook_edit"]);
 const PLANNING_SUBAGENT_TOOLS = new Set(["subagent", "task"]);
+/**
+ * Canonical registry for agents that planning-dispatch may consider. Unit
+ * manifests still declare per-unit subsets via ToolsPolicy.allowedSubagents.
+ */
+const PLANNING_DISPATCH_AGENT_REGISTRY = {
+    scout: { readOnlySpecialist: true },
+    planner: { readOnlySpecialist: true },
+    reviewer: { readOnlySpecialist: true },
+    security: { readOnlySpecialist: true },
+    tester: { readOnlySpecialist: true },
+};
+export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set(Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
+    .filter(([, metadata]) => metadata.readOnlySpecialist)
+    .map(([agentId]) => agentId));
+let warnedMissingPlanningDispatchAgentClasses = false;
+function isReadOnlySpecialist(agentId) {
+    const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId];
+    return metadata?.readOnlySpecialist === true;
+}
+function allowedPlanningDispatchAgentsList() {
+    return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+}
+function warnMissingPlanningDispatchAgentClasses(unitType, mode, toolName) {
+    if (warnedMissingPlanningDispatchAgentClasses)
+        return;
+    warnedMissingPlanningDispatchAgentClasses = true;
+    // TODO(#5060): Remove this migration shim once all subagent/task callers are verified to forward agent identities.
+    const message = `[write-gate] planning-dispatch: shouldBlockPlanningUnit called for tool "${toolName}" ` +
+        `on unit "${unitType}" without agentClasses - stale caller; blocking dispatch.`;
+    console.warn(message);
+    logWarning("intercept", message, {
+        unitType,
+        mode,
+        toolName,
+    });
+}
+/**
+ * Read-only / planning-safe tools that any non-"all" mode allows. Mirrors
+ * QUEUE_SAFE_TOOLS / GATE_SAFE_TOOLS but is the inclusive default for
+ * planning units (which need their full discussion + research surface).
+ *
+ * gsd_* MCP tools are passed through unconditionally — they have their own
+ * domain validation (e.g. depth-verification gate, single-writer DB).
+ */
 const PLANNING_SAFE_TOOLS = new Set([
     "read", "grep", "find", "ls", "glob",
     "ask_user_questions",
@@ -458,6 +518,7 @@ function matchesAllowedGlob(absPath, basePath, globs) {
     const rel = relative(basePath, absPath);
     if (rel.startsWith("..") || isAbsolute(rel))
         return false;
+    // Normalize Windows separators for minimatch.
     const posix = rel.split(sep).join("/");
     return globs.some(g => minimatch(posix, g, { dot: false, nocase: false }));
 }
@@ -477,17 +538,32 @@ function blockReason(unitType, mode, what) {
  *   - "read-only"  → blocks all writes, bash, and subagent dispatch.
  *   - "planning"   → blocks writes to paths outside <basePath>/.gsd/,
  *                    bash that isn't read-only, and subagent dispatch.
+ *   - "planning-dispatch"
+ *                  → like "planning", but permits subagent dispatch only
+ *                    when every forwarded agent class is globally allowed
+ *                    and listed in the policy's allowedSubagents.
  *   - "docs"       → like "planning" but also allows writes to paths
  *                    matching `allowedPathGlobs` relative to basePath.
  *
- * `policy` of null means "no manifest resolved" — pass-through.
+ * `pathOrCommand` is the file path for write/edit-shaped tools and the
+ * shell command for bash. Other tools ignore this argument.
+ *
+ * `policy` of null means "no manifest resolved" — pass-through. Callers
+ * that have no active unit (interactive sessions) pass null and this
+ * predicate is a no-op.
+ *
+ * `agentClasses` is supplied by the tool hook for subagent-shaped calls. If
+ * absent, planning-dispatch fails closed so stale callers cannot silently
+ * bypass the agent allowlists. An explicitly supplied-but-empty list is
+ * allowed through so the downstream tool call can reject the malformed input.
  */
-export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitType, policy) {
+export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitType, policy, agentClasses) {
     if (!policy)
         return { block: false };
     if (policy.mode === "all")
         return { block: false };
     const tool = toolName;
+    // Read-only mode: only Read-class tools are permitted.
     if (policy.mode === "read-only") {
         if (PLANNING_SAFE_TOOLS.has(tool))
             return { block: false };
@@ -496,14 +572,51 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
         if (PLANNING_WRITE_TOOLS.has(tool) || tool === "bash" || PLANNING_SUBAGENT_TOOLS.has(tool)) {
             return { block: true, reason: blockReason(unitType, policy.mode, `${tool} is not permitted (read-only)`) };
         }
+        // Unknown tool in read-only mode — block by default.
         return { block: true, reason: blockReason(unitType, policy.mode, `tool "${tool}" is not on the read-only allowlist`) };
     }
-    // planning / docs modes
+    // planning / planning-dispatch / docs modes share the same surface for safe tools, bash, and subagent.
     if (PLANNING_SAFE_TOOLS.has(tool))
         return { block: false };
     if (tool.startsWith("gsd_"))
         return { block: false };
     if (PLANNING_SUBAGENT_TOOLS.has(tool)) {
+        if (policy.mode === "planning-dispatch") {
+            const requested = (agentClasses ?? []).map(a => a.trim()).filter(Boolean);
+            const allowedSubagents = Array.isArray(policy.allowedSubagents) ? policy.allowedSubagents : [];
+            const allowed = new Set(allowedSubagents);
+            // When agentClasses is undefined, the caller has not been updated to extract
+            // agent identities yet. Block and warn so stale callers surface in telemetry
+            // instead of silently bypassing the gate.
+            if (agentClasses === undefined) {
+                warnMissingPlanningDispatchAgentClasses(unitType, policy.mode, tool);
+                return {
+                    block: true,
+                    reason: blockReason(unitType, policy.mode, `subagent dispatch blocked: stale caller did not supply agent identities for "${tool}"; update extractSubagentAgentClasses to handle this input shape`),
+                };
+            }
+            // agentClasses was explicitly provided but resolved to an empty list (for
+            // example, a bare tool call with no agent field). Pass through; no agents
+            // to validate means the downstream tool call itself will fail.
+            if (requested.length === 0) {
+                return { block: false };
+            }
+            const globallyDisallowed = requested.find(a => !isReadOnlySpecialist(a));
+            if (globallyDisallowed) {
+                return {
+                    block: true,
+                    reason: blockReason(unitType, policy.mode, `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from planning-dispatch units`),
+                };
+            }
+            const disallowedByPolicy = requested.find(a => !allowed.has(a));
+            if (disallowedByPolicy) {
+                return {
+                    block: true,
+                    reason: blockReason(unitType, policy.mode, `subagent dispatch of "${disallowedByPolicy}" not permitted by ToolsPolicy.allowedSubagents; permitted agents for this unit: ${allowedSubagents.join(", ")}`),
+                };
+            }
+            return { block: false };
+        }
         return { block: true, reason: blockReason(unitType, policy.mode, `subagent dispatch is not permitted in planning units`) };
     }
     if (tool === "bash") {
@@ -519,8 +632,10 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             return { block: true, reason: blockReason(unitType, policy.mode, `${tool} called with empty path`) };
         }
         const absPath = isAbsolute(pathOrCommand) ? pathOrCommand : resolve(basePath, pathOrCommand);
+        // Always allow .gsd/ writes — that's where planning artifacts live.
         if (isPathUnderGsd(absPath, basePath))
             return { block: false };
+        // docs mode additionally allows the manifest's allowedPathGlobs.
         if (policy.mode === "docs" && matchesAllowedGlob(absPath, basePath, policy.allowedPathGlobs)) {
             return { block: false };
         }
@@ -529,5 +644,8 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             reason: blockReason(unitType, policy.mode, `cannot ${tool} "${pathOrCommand}" — writes are restricted to .gsd/${policy.mode === "docs" ? " and " + policy.allowedPathGlobs.join(", ") : ""}`),
         };
     }
+    // Unknown tool name — pass through. Other layers (queue, pending-gate,
+    // CONTEXT.md write) catch known mutating shapes; defaulting to allow here
+    // avoids breaking gsd_* MCP tools or future safe additions.
     return { block: false };
 }

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

@@ -1,10 +1,9 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } 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|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language";
+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|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -72,6 +71,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "add-tests", desc: "Generate tests for completed slices" },
     { cmd: "scan", desc: "Rapid codebase assessment — lightweight alternative to full map (--focus tech|arch|quality|concerns|tech+arch)" },
     { cmd: "language", desc: "Set or clear the global response language (e.g. /gsd language Chinese)" },
+    { cmd: "worktree", desc: "Manage worktrees from the TUI (list, merge, clean, remove)" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -287,6 +287,12 @@ const NESTED_COMPLETIONS = {
         { cmd: "off", desc: "Clear the language preference (revert to default)" },
         { cmd: "clear", desc: "Alias for off — clear the language preference" },
     ],
+    worktree: [
+        { cmd: "list", desc: "Show all worktrees with status" },
+        { cmd: "merge", desc: "Merge a worktree into main and clean up" },
+        { cmd: "clean", desc: "Remove all merged/empty worktrees" },
+        { cmd: "remove", desc: "Remove a worktree (--force to skip safety checks)" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";
@@ -330,6 +336,71 @@ function getExtensionCompletions(prefix, action) {
         return [];
     }
 }
+function normalizePathForCompare(path) {
+    return path.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function findWorktreeSegment(normalizedPath) {
+    const directMarker = "/.gsd/worktrees/";
+    const directIdx = normalizedPath.indexOf(directMarker);
+    if (directIdx !== -1) {
+        return { gsdIdx: directIdx, afterWorktrees: directIdx + directMarker.length };
+    }
+    const symlinkMatch = normalizedPath.match(/\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//);
+    if (symlinkMatch?.index !== undefined) {
+        return { gsdIdx: symlinkMatch.index, afterWorktrees: symlinkMatch.index + symlinkMatch[0].length };
+    }
+    return null;
+}
+function resolveProjectRootFromGitFile(worktreePath) {
+    try {
+        let dir = worktreePath;
+        for (let i = 0; i < 30; i++) {
+            const gitPath = join(dir, ".git");
+            if (existsSync(gitPath)) {
+                const content = readFileSync(gitPath, "utf8").trim();
+                if (content.startsWith("gitdir: ")) {
+                    const gitDir = resolve(dir, content.slice(8));
+                    const dotGitDir = resolve(gitDir, "..", "..");
+                    if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
+                        return resolve(dotGitDir, "..");
+                    }
+                    const commonDirPath = join(gitDir, "commondir");
+                    if (existsSync(commonDirPath)) {
+                        const commonDir = readFileSync(commonDirPath, "utf8").trim();
+                        return resolve(resolve(gitDir, commonDir), "..");
+                    }
+                }
+                break;
+            }
+            const parent = resolve(dir, "..");
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // Completion must stay best-effort.
+    }
+    return null;
+}
+function resolveProjectRootForCompletion(basePath) {
+    if (process.env.GSD_PROJECT_ROOT)
+        return process.env.GSD_PROJECT_ROOT;
+    const normalizedPath = normalizePathForCompare(basePath);
+    const segment = findWorktreeSegment(normalizedPath);
+    if (!segment)
+        return basePath;
+    const separator = basePath.includes("\\") ? "\\" : "/";
+    const gsdMarker = `${separator}.gsd${separator}`;
+    const gsdIdx = basePath.indexOf(gsdMarker);
+    const candidate = gsdIdx !== -1 ? basePath.slice(0, gsdIdx) : basePath.slice(0, segment.gsdIdx);
+    const normalizedGsdHome = normalizePathForCompare(gsdHome);
+    const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
+    if (candidateGsdPath === normalizedGsdHome || candidateGsdPath.startsWith(`${normalizedGsdHome}/`)) {
+        return resolveProjectRootFromGitFile(basePath) ?? basePath;
+    }
+    return candidate;
+}
 export function getGsdArgumentCompletions(prefix) {
     const hasTrailingSpace = prefix.endsWith(" ");
     const parts = prefix.trim().split(/\s+/);
@@ -384,7 +455,7 @@ export function getGsdArgumentCompletions(prefix) {
     // Workflow definition-name completion for `workflow run <name>` and `workflow validate <name>`
     if (command === "workflow" && (subcommand === "run" || subcommand === "validate") && parts.length <= 3) {
         try {
-            const defsDir = join(resolveProjectRoot(process.cwd()), ".gsd", "workflow-defs");
+            const defsDir = join(resolveProjectRootForCompletion(process.cwd()), ".gsd", "workflow-defs");
             if (existsSync(defsDir)) {
                 return readdirSync(defsDir)
                     .filter((f) => f.endsWith(".yaml") && f.startsWith(third))
@@ -426,7 +497,7 @@ export function getGsdArgumentCompletions(prefix) {
             catch { /* ignore */ }
         };
         try {
-            const base = resolveProjectRoot(process.cwd());
+            const base = resolveProjectRootForCompletion(process.cwd());
             scanDir(join(base, ".gsd", "workflows"), "project");
             scanDir(join(base, ".gsd", "workflow-defs"), "project-legacy");
             scanDir(join(gsdHome, "workflows"), "global");

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

@@ -58,16 +58,21 @@ export function showHelp(ctx, args = "") {
         "  /gsd pause          Pause auto-mode (preserves state, /gsd auto to resume)",
         "  /gsd discuss        Start guided milestone/slice discussion",
         "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
+        "  /gsd quick          Execute a quick task without full planning overhead",
+        "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
+        "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",
         "",
         "VISIBILITY",
         `  /gsd status         Show progress dashboard  (${formattedShortcutPair("dashboard")})`,
         `  /gsd parallel watch Open parallel worker monitor  (${formattedShortcutPair("parallel")})`,
+        "  /gsd widget         Cycle status widget  [full|small|min|off]",
         "  /gsd visualize      Interactive 10-tab TUI (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)",
         "  /gsd queue          Show queued/dispatched units and execution order",
         "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
         "  /gsd changelog      Show categorized release notes  [version]",
         `  /gsd notifications  View persistent notification history  [clear|tail|filter]  (${formattedShortcutPair("notifications")})`,
-        "  /gsd logs           Browse activity logs, debug logs, and metrics",
+        "  /gsd logs           Browse activity logs, debug logs, and metrics  [debug|tail|clear]",
         "  /gsd debug          Create/list/continue persistent debug sessions",
         "",
         "COURSE CORRECTION",
@@ -76,6 +81,9 @@ export function showHelp(ctx, args = "") {
         "  /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 undo-task      Reset a specific task's completion state  [DB + markdown]",
+        "  /gsd reset-slice    Reset a slice and all its tasks  [DB + markdown]",
+        "  /gsd rate           Rate last unit's model tier  [over|ok|under]",
         "  /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",
@@ -84,6 +92,15 @@ export function showHelp(ctx, args = "") {
         "  /gsd knowledge <type> <text>   Add rule, pattern, or lesson to KNOWLEDGE.md",
         "  /gsd codebase [generate|update|stats]   Manage the CODEBASE.md cache used in prompt context",
         "",
+        "SHIPPING & BACKLOG",
+        "  /gsd ship           Create a PR from milestone artifacts  [--dry-run|--draft|--base|--force]",
+        "  /gsd do <text>      Route freeform text to the right GSD command",
+        "  /gsd session-report Show session cost, tokens, and work summary  [--json|--save]",
+        "  /gsd backlog        Manage backlog items  [add|promote|remove|list]",
+        "  /gsd pr-branch      Create a clean PR branch filtering .gsd/ commits  [--dry-run|--name]",
+        "  /gsd add-tests      Generate tests for completed slices",
+        "  /gsd scan           Rapid codebase assessment  [--focus tech|arch|quality|concerns|tech+arch]",
+        "",
         "SETUP & CONFIGURATION",
         "  /gsd onboarding     Re-run setup wizard  [--resume|--reset|--step <name>]",
         "  /gsd setup          Configuration hub  [llm|model|search|remote|keys|prefs|onboarding]",
@@ -96,18 +113,23 @@ export function showHelp(ctx, args = "") {
         "  /gsd config         (deprecated) Set tool API keys — use /gsd keys instead",
         "  /gsd show-config    Show effective configuration (models, routing, toggles)",
         "  /gsd hooks          Show post-unit hook configuration",
+        "  /gsd run-hook       Manually trigger a specific hook",
+        "  /gsd skill-health   Skill lifecycle dashboard",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
         "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
         "  /gsd mcp            MCP server status and connectivity  [status|check <server>|init [dir]]",
         "",
         "MAINTENANCE",
         "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",
+        "  /gsd forensics      Examine execution logs and post-mortem analysis",
         "  /gsd export         Export milestone/slice results  [--json|--markdown|--html] [--all]",
         "  /gsd cleanup        Remove merged branches or snapshots  [branches|snapshots]",
+        "  /gsd worktree       Manage worktrees from the TUI  [list|merge|clean|remove]",
         "  /gsd migrate        Migrate .planning/ (v1) to .gsd/ (v2) format",
         "  /gsd remote         Control remote auto-mode  [slack|discord|status|disconnect]",
         "  /gsd inspect        Show SQLite DB diagnostics (schema, row counts, recent entries)",
         "  /gsd update         Update GSD to the latest version via npm",
+        "  /gsd language       Set or clear the global response language  [off|clear|<language>]",
     ];
     const full = ["full", "--full", "all"].includes(args.trim().toLowerCase());
     ctx.ui.notify((full ? fullLines : summaryLines).join("\n"), "info");

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

@@ -259,5 +259,13 @@ Examples:
         await handleScan(trimmed.replace(/^scan\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "worktree" ||
+        trimmed.startsWith("worktree ") ||
+        trimmed === "wt" ||
+        trimmed.startsWith("wt ")) {
+        const { handleWorktree } = await import("../../commands-worktree.js");
+        await handleWorktree(trimmed.replace(/^(worktree|wt)\s*/, "").trim(), ctx);
+        return true;
+    }
     return false;
 }

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

@@ -6,6 +6,7 @@
 import { AuthStorage } from "@gsd/pi-coding-agent";
 import { existsSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { getHomeDir } from "./home-dir.js";
 /**
  * Tool API key configurations.
  * This is the source of truth for tool credentials - used by both the config wizard
@@ -29,7 +30,7 @@ function getStoredToolKey(auth, providerId) {
  */
 export function loadToolApiKeys() {
     try {
-        const authPath = join(process.env.HOME ?? "", ".gsd", "agent", "auth.json");
+        const authPath = join(getHomeDir(), ".gsd", "agent", "auth.json");
         if (!existsSync(authPath))
             return;
         const auth = AuthStorage.create(authPath);
@@ -45,7 +46,7 @@ export function loadToolApiKeys() {
     }
 }
 export function getConfigAuthStorage() {
-    const authPath = join(process.env.HOME ?? "", ".gsd", "agent", "auth.json");
+    const authPath = join(getHomeDir(), ".gsd", "agent", "auth.json");
     mkdirSync(dirname(authPath), { recursive: true });
     return AuthStorage.create(authPath);
 }

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

@@ -10,7 +10,50 @@ import { dirname, join, resolve } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { lockSync, unlockSync } from "proper-lockfile";
-import semver from "semver";
+/**
+ * Strict numeric comparison of two npm-style version strings.
+ *
+ * Returns true when `a` is strictly greater than `b`. Compares the dotted
+ * release components numerically (so `1.10.0` > `1.9.0`) and treats any
+ * prerelease suffix (`-beta.1`, `-rc.2`) as less than the equivalent
+ * release version (`1.0.0` > `1.0.0-beta.1`). Sufficient for npm package
+ * version comparison in the extension installer; we don't need the full
+ * semver range/intersect machinery here.
+ *
+ * Replaces the earlier `import semver from "semver"` — that import broke
+ * `tsc -p tsconfig.json` whenever `@types/semver` failed to install
+ * (Issue #4946) because the file is pulled in transitively despite being
+ * under the `src/resources` exclude.
+ */
+export function isVersionGreater(a, b) {
+    const split = (v) => {
+        const dash = v.indexOf("-");
+        const release = (dash === -1 ? v : v.slice(0, dash))
+            .split(".")
+            .map(part => Number.parseInt(part, 10) || 0);
+        const pre = dash === -1 ? null : v.slice(dash + 1);
+        return { release, pre };
+    };
+    const sa = split(a);
+    const sb = split(b);
+    const len = Math.max(sa.release.length, sb.release.length);
+    for (let i = 0; i < len; i++) {
+        const ai = sa.release[i] ?? 0;
+        const bi = sb.release[i] ?? 0;
+        if (ai !== bi)
+            return ai > bi;
+    }
+    // Release components equal — a release version beats any prerelease,
+    // and prerelease strings are compared lexicographically (good enough
+    // for `beta.1` vs `beta.2`, the only realistic case here).
+    if (sa.pre === null && sb.pre !== null)
+        return true;
+    if (sa.pre !== null && sb.pre === null)
+        return false;
+    if (sa.pre !== null && sb.pre !== null)
+        return sa.pre > sb.pre;
+    return false;
+}
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function getRegistryPath() {
@@ -413,7 +456,7 @@ async function updateSingleExtension(id, registry, ctx) {
         ctx.ui.notify(`Could not fetch latest version for "${id}".`, "warning");
         return;
     }
-    if (semver.gt(latest, current)) {
+    if (isVersionGreater(latest, current)) {
         ctx.ui.notify(`Updating "${id}": v${current} → v${latest}...`, "info");
         await handleInstall(packageName, ctx);
     }
@@ -464,7 +507,7 @@ async function updateAllExtensions(registry, ctx) {
             skipped++;
             continue;
         }
-        if (semver.gt(latest, current)) {
+        if (isVersionGreater(latest, current)) {
             ctx.ui.notify(`  ${entry.id}: v${current} → v${latest} (updating)`, "info");
             await handleInstall(packageName, ctx);
             updated++;

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

@@ -9,6 +9,7 @@ import { join, resolve as resolvePath, sep } from "node:path";
 import { homedir } from "node:os";
 import { deriveState } from "./state.js";
 import { gsdRoot } from "./paths.js";
+import { getHomeDir } from "./home-dir.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { appendOverride, appendKnowledge } from "./files.js";
 import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
@@ -60,7 +61,7 @@ async function fetchLatestVersionForCommand() {
     }
 }
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(getHomeDir(), ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     const prompt = loadPrompt("doctor-heal", {
         doctorSummary: reportText,
@@ -210,7 +211,7 @@ export async function handleTriage(ctx, pi, basePath) {
         currentPlan: currentPlan || "(no active slice plan)",
         roadmapContext: roadmapContext || "(no active roadmap)",
     });
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(getHomeDir(), ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType: "gsd-triage",

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

@@ -10,6 +10,7 @@
  *   /gsd mcp init [dir]  — Write project-local GSD workflow MCP config
  */
 import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { ensureProjectWorkflowMcpConfig } from "./mcp-project-config.js";
 export function formatMcpInitResult(status, configPath, targetPath) {
@@ -33,6 +34,7 @@ function readMcpConfigs() {
     const configPaths = [
         join(process.cwd(), ".mcp.json"),
         join(process.cwd(), ".gsd", "mcp.json"),
+        join(process.env.GSD_HOME || join(homedir(), ".gsd"), "mcp.json"),
     ];
     for (const configPath of configPaths) {
         try {
@@ -77,7 +79,7 @@ export function formatMcpStatusReport(servers) {
         return [
             "No MCP servers configured.",
             "",
-            "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+            "Add servers to .mcp.json, .gsd/mcp.json, or $GSD_HOME/mcp.json (default: ~/.gsd/mcp.json) to enable MCP integrations.",
             "Tip: run /gsd mcp init . to write the local GSD workflow MCP config.",
             "See: https://modelcontextprotocol.io/quickstart",
         ].join("\n");

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -1481,6 +1481,13 @@ async function configureAdvanced(ctx, prefs) {
     const tokenCost = await promptBoolean(ctx, "Show token cost in footer", prefs.show_token_cost, false);
     if (tokenCost !== undefined)
         prefs.show_token_cost = tokenCost;
+    const minRequestInterval = await promptInteger(ctx, "Minimum interval between auto-mode LLM requests (ms, 0 to disable)", prefs.min_request_interval_ms, "0");
+    if (minRequestInterval === "clear") {
+        delete prefs.min_request_interval_ms;
+    }
+    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");
     if (widget !== undefined)
         prefs.widget_mode = widget;
@@ -1668,8 +1675,10 @@ export function serializePreferencesToFrontmatter(prefs) {
         "budget_ceiling", "budget_enforcement", "context_pause_threshold",
         "notifications", "cmux", "remote_questions", "git",
         "stale_commit_threshold_minutes",
+        "min_request_interval_ms",
         "post_unit_hooks", "pre_dispatch_hooks",
-        "dynamic_routing", "uok", "token_profile", "service_tier", "flat_rate_providers",
+        "dynamic_routing", "disabled_model_providers", "uok", "token_profile",
+        "service_tier", "flat_rate_providers",
         "phases", "parallel", "slice_parallel",
         "reactive_execution", "gate_evaluation",
         "auto_visualize", "auto_report",