gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

package/dist/resources/extensions/gsd/bootstrap/notify-interceptor.js

@@ -0,0 +1,28 @@
+// GSD Extension — Notify Interceptor
+// Wraps ctx.ui.notify() in-place to persist every notification through the
+// notification store. Uses a WeakSet to prevent double-wrapping and handle
+// UI context replacement on /reload gracefully.
+import { appendNotification } from "../notification-store.js";
+// Track which ui context objects have been wrapped to prevent double-install.
+// WeakSet allows GC to collect replaced uiContext instances after /reload.
+const _wrappedContexts = new WeakSet();
+/**
+ * Install the notify interceptor on a context's UI object.
+ * Mutates ctx.ui.notify in place — the original is called after persistence.
+ * Safe to call multiple times; no-ops if already installed on the same ui object.
+ */
+export function installNotifyInterceptor(ctx) {
+    if (_wrappedContexts.has(ctx.ui))
+        return;
+    const originalNotify = ctx.ui.notify.bind(ctx.ui);
+    ctx.ui.notify = (message, type) => {
+        try {
+            appendNotification(message, (type ?? "info"), "notify");
+        }
+        catch {
+            // Non-fatal — never let persistence break the UI
+        }
+        originalNotify(message, type);
+    };
+    _wrappedContexts.add(ctx.ui);
+}

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

@@ -0,0 +1,85 @@
+// GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
+import { Type } from "@sinclair/typebox";
+import { logWarning } from "../workflow-logger.js";
+export function registerQueryTools(pi) {
+    pi.registerTool({
+        name: "gsd_milestone_status",
+        label: "Milestone Status",
+        description: "Read the current status of a milestone and all its slices from the GSD database. " +
+            "Returns milestone metadata, per-slice status, and task counts per slice. " +
+            "Use this instead of querying .gsd/gsd.db directly via sqlite3 or better-sqlite3.",
+        promptSnippet: "Get milestone status, slice statuses, and task counts for a given milestoneId",
+        promptGuidelines: [
+            "Use this tool — not sqlite3 or better-sqlite3 — to inspect milestone or slice state from the DB.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID to query (e.g. M001)" }),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            try {
+                // Strictly read-only: only use an already-open DB connection.
+                // Do NOT call ensureDbOpen() — it can create/migrate the DB as a side effect.
+                const { isDbAvailable, getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
+                if (!isDbAvailable()) {
+                    return {
+                        content: [{ type: "text", text: "Error: GSD database is not available." }],
+                        details: { operation: "milestone_status", error: "db_unavailable" },
+                    };
+                }
+                // Wrap all reads in a single transaction for snapshot consistency.
+                // SQLite WAL mode guarantees reads within a transaction see a single
+                // consistent snapshot, preventing torn reads from concurrent writes.
+                const adapter = _getAdapter();
+                adapter.exec("BEGIN"); // eslint-disable-line -- SQLite exec, not child_process
+                try {
+                    const milestone = getMilestone(params.milestoneId);
+                    if (!milestone) {
+                        adapter.exec("COMMIT"); // eslint-disable-line
+                        return {
+                            content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
+                            details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
+                        };
+                    }
+                    const sliceStatuses = getSliceStatusSummary(params.milestoneId);
+                    const slices = sliceStatuses.map((s) => {
+                        const counts = getSliceTaskCounts(params.milestoneId, s.id);
+                        return {
+                            id: s.id,
+                            status: s.status,
+                            taskCounts: counts,
+                        };
+                    });
+                    adapter.exec("COMMIT"); // eslint-disable-line
+                    const result = {
+                        milestoneId: milestone.id,
+                        title: milestone.title,
+                        status: milestone.status,
+                        createdAt: milestone.created_at,
+                        completedAt: milestone.completed_at,
+                        sliceCount: slices.length,
+                        slices,
+                    };
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+                    };
+                }
+                catch (txErr) {
+                    try {
+                        adapter.exec("ROLLBACK");
+                    }
+                    catch { /* swallow */ } // eslint-disable-line
+                    throw txErr;
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logWarning("tool", `gsd_milestone_status tool failed: ${msg}`);
+                return {
+                    content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
+                    details: { operation: "milestone_status", error: msg },
+                };
+            }
+        },
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,9 +1,11 @@
+// GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
+import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 export function handleRecoverableExtensionProcessError(err) {
@@ -48,6 +50,7 @@ export function registerGsdExtension(pi) {
     registerDynamicTools(pi);
     registerDbTools(pi);
     registerJournalTools(pi);
+    registerQueryTools(pi);
     registerShortcuts(pi);
     registerHooks(pi);
 }

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -10,11 +10,17 @@ import { getDiscussionMilestoneId } from "../guided-flow.js";
 import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { deriveState } from "../state.js";
-import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart } from "../auto.js";
+import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
 import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
+import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult } from "../safety/evidence-collector.js";
+import { classifyCommand } from "../safety/destructive-guard.js";
+import { logWarning as safetyLogWarning } from "../workflow-logger.js";
+import { installNotifyInterceptor } from "./notify-interceptor.js";
+import { initNotificationStore } from "../notification-store.js";
+import { initNotificationWidget } from "../notification-widget.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -24,6 +30,9 @@ async function syncServiceTierStatus(ctx) {
 }
 export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
+        initNotificationWidget(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -60,6 +69,8 @@ export function registerHooks(pi) {
         loadToolApiKeys();
     });
     pi.on("session_switch", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -187,6 +198,22 @@ export function registerHooks(pi) {
         if (result.block)
             return result;
     });
+    // ── Safety harness: evidence collection + destructive command warnings ──
+    pi.on("tool_call", async (event, ctx) => {
+        if (!isAutoActive())
+            return;
+        safetyRecordToolCall(event.toolName, event.input);
+        // Destructive command classification (warn only, never block)
+        if (isToolCallEventType("bash", event)) {
+            const classification = classifyCommand(event.input.command);
+            if (classification.destructive) {
+                safetyLogWarning("safety", `destructive command: ${classification.labels.join(", ")}`, {
+                    command: String(event.input.command).slice(0, 200),
+                });
+                ctx.ui.notify(`Destructive command detected: ${classification.labels.join(", ")}`, "warning");
+            }
+        }
+    });
     pi.on("tool_result", async (event) => {
         if (event.toolName !== "ask_user_questions")
             return;
@@ -243,6 +270,18 @@ export function registerHooks(pi) {
     });
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);
+        // #2883: Capture tool invocation errors (malformed/truncated JSON arguments)
+        // so postUnitPreVerification can break the retry loop instead of re-dispatching.
+        if (event.isError && event.toolName.startsWith("gsd_")) {
+            const errorText = typeof event.result === "string"
+                ? event.result
+                : (typeof event.result?.content?.[0]?.text === "string" ? event.result.content[0].text : String(event.result));
+            recordToolInvocationError(event.toolName, errorText);
+        }
+        // Safety harness: record tool execution results for evidence cross-referencing
+        if (isAutoActive()) {
+            safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);
+        }
     });
     pi.on("model_select", async (_event, ctx) => {
         await syncServiceTierStatus(ctx);

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { GSDNotificationOverlay } from "../notification-overlay.js";
 import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
@@ -23,6 +24,20 @@ export function registerShortcuts(pi) {
             });
         },
     });
+    pi.registerShortcut(Key.ctrlAlt("n"), {
+        description: shortcutDesc("Open notification history", "/gsd notifications"),
+        handler: async (ctx) => {
+            await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()), {
+                overlay: true,
+                overlayOptions: {
+                    width: "80%",
+                    minWidth: 60,
+                    maxHeight: "88%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
     pi.registerShortcut(Key.ctrlAlt("p"), {
         description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
         handler: async (ctx) => {

package/dist/resources/extensions/gsd/bootstrap/sanitize-complete-milestone.js

@@ -0,0 +1,54 @@
+/**
+ * Input sanitization for gsd_complete_milestone parameters.
+ *
+ * The Claude SDK deserializes tool-call JSON before the handler runs.
+ * When an LLM (especially smaller models like haiku) generates large markdown
+ * parameters, the JSON can arrive with subtly wrong types — numbers where
+ * strings are expected, null where arrays belong, string "true" instead of
+ * boolean true, etc.  This sanitizer normalizes all fields so
+ * handleCompleteMilestone never crashes on type mismatches.
+ *
+ * See: https://github.com/gsd-build/gsd-2/issues/3013
+ */
+/**
+ * Coerce an unknown value to a trimmed string.
+ * Returns "" for null / undefined.
+ */
+function toStr(v) {
+    if (v == null)
+        return "";
+    return String(v).trim();
+}
+/**
+ * Coerce an unknown value to an array of trimmed, non-empty strings.
+ * - If already an array, filter/trim each element.
+ * - Otherwise return [].
+ */
+function toStrArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v
+        .map((item) => (item == null ? "" : String(item).trim()))
+        .filter((s) => s.length > 0);
+}
+/**
+ * Sanitize raw params from the tool-call framework into well-typed
+ * CompleteMilestoneParams, tolerating type mismatches from LLM JSON quirks.
+ */
+export function sanitizeCompleteMilestoneParams(raw) {
+    return {
+        milestoneId: toStr(raw.milestoneId),
+        title: toStr(raw.title),
+        oneLiner: toStr(raw.oneLiner),
+        narrative: toStr(raw.narrative),
+        successCriteriaResults: toStr(raw.successCriteriaResults),
+        definitionOfDoneResults: toStr(raw.definitionOfDoneResults),
+        requirementOutcomes: toStr(raw.requirementOutcomes),
+        keyDecisions: toStrArray(raw.keyDecisions),
+        keyFiles: toStrArray(raw.keyFiles),
+        lessonsLearned: toStrArray(raw.lessonsLearned),
+        followUps: toStr(raw.followUps),
+        deviations: toStr(raw.deviations),
+        verificationPassed: raw.verificationPassed === true || raw.verificationPassed === "true",
+    };
+}

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

@@ -3,9 +3,10 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarning } from "../workflow-logger.js";
 import { debugTime } from "../debug-logger.js";
-import { loadPrompt } from "../prompt-loader.js";
+import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
@@ -15,6 +16,30 @@ import { formatOverridesSection, loadActiveOverrides, loadFile, parseContinue, p
 import { toPosixPath } from "../../shared/mod.js";
 import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../../cmux/index.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+/**
+ * Bundled skill triggers — resolved dynamically at runtime instead of
+ * hardcoding absolute paths in the system prompt template. Only skills
+ * that actually exist on disk are included in the table. (#3575)
+ */
+const BUNDLED_SKILL_TRIGGERS = [
+    { trigger: "Frontend UI - web components, pages, landing pages, dashboards, React/HTML/CSS, styling", skill: "frontend-design" },
+    { trigger: "macOS or iOS apps - SwiftUI, Xcode, App Store", skill: "swiftui" },
+    { trigger: "Debugging - complex bugs, failing tests, root-cause investigation after standard approaches fail", skill: "debug-like-expert" },
+];
+function buildBundledSkillsTable() {
+    const cwd = process.cwd();
+    const rows = [];
+    for (const { trigger, skill } of BUNDLED_SKILL_TRIGGERS) {
+        const resolution = resolveSkillReference(skill, cwd);
+        if (resolution.method === "unresolved")
+            continue; // skill not installed — omit from prompt
+        rows.push(`| ${trigger} | \`${resolution.resolvedPath}\` |`);
+    }
+    if (rows.length === 0) {
+        return "*No bundled skills found. Install skills to `~/.agents/skills/` or `~/.claude/skills/`.*";
+    }
+    return `| Trigger | Skill to load |\n|---|---|\n${rows.join("\n")}`;
+}
 function warnDeprecatedAgentInstructions() {
     const paths = [
         join(gsdHome, "agent-instructions.md"),
@@ -32,7 +57,10 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     if (!existsSync(join(process.cwd(), ".gsd")))
         return undefined;
     const stopContextTimer = debugTime("context-inject");
-    const systemContent = loadPrompt("system");
+    const systemContent = loadPrompt("system", {
+        bundledSkillsTable: buildBundledSkillsTable(),
+        templatesDir: getTemplatesDir(),
+    });
     const loadedPreferences = loadEffectiveGSDPreferences();
     if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
         markCmuxPromptShown();
@@ -201,6 +229,12 @@ function buildWorktreeContextBlock() {
     }
     return "";
 }
+/**
+ * Low-entropy resume intent patterns — short phrases a user types to
+ * continue work after a pause, rate limit, or context reset (#3615).
+ * Tested against the trimmed, lowercased prompt with trailing punctuation stripped.
+ */
+const RESUME_INTENT_PATTERNS = /^(continue|resume|ok|go|go ahead|proceed|keep going|carry on|next|yes|yeah|yep|sure|do it|let's go|pick up where you left off)$/;
 async function buildGuidedExecuteContextInjection(prompt, basePath) {
     const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (executeMatch) {
@@ -215,6 +249,20 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
             return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, state.activeTask.id, state.activeTask.title);
         }
     }
+    // Fallback: low-entropy resume prompt (e.g., "continue", "ok", "go ahead")
+    // during an active executing task — inject task context so the agent
+    // doesn't rebuild from scratch (#3615).
+    // Intent-gated: only fire for short, resume-like prompts to avoid hijacking
+    // control/help/diagnostic prompts with unrelated execution context.
+    // Phase-gated: only fire during "executing" to avoid misrouting during
+    // replanning, gate evaluation, or other non-execution phases.
+    const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+    if (RESUME_INTENT_PATTERNS.test(trimmed)) {
+        const state = await deriveState(basePath);
+        if (state.phase === "executing" && state.activeTask && state.activeMilestone && state.activeSlice) {
+            return buildTaskExecutionContextInjection(basePath, state.activeMilestone.id, state.activeSlice.id, state.activeTask.id, state.activeTask.title);
+        }
+    }
     return null;
 }
 async function buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, taskId, taskTitle) {

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|mcp|rethink|codebase";
+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|codebase|notifications";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -36,6 +36,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "hooks", desc: "Show configured post-unit and pre-dispatch hooks" },
     { cmd: "run-hook", desc: "Manually trigger a specific hook" },
     { cmd: "skill-health", desc: "Skill lifecycle dashboard" },
+    { cmd: "notifications", desc: "View, filter, and clear persistent notification history" },
     { cmd: "doctor", desc: "Runtime health checks with auto-fix" },
     { cmd: "logs", desc: "Browse activity logs, debug logs, and metrics" },
     { cmd: "forensics", desc: "Examine execution logs" },
@@ -97,6 +98,11 @@ const NESTED_COMPLETIONS = {
         { cmd: "keys", desc: "Manage API keys" },
         { cmd: "prefs", desc: "Configure global preferences" },
     ],
+    notifications: [
+        { cmd: "clear", desc: "Clear all notifications" },
+        { cmd: "tail", desc: "Show last N notifications (default: 20)" },
+        { cmd: "filter", desc: "Filter by severity (error|warning|info|success)" },
+    ],
     logs: [
         { cmd: "debug", desc: "List or view debug log files" },
         { cmd: "tail", desc: "Show last N activity log summaries" },

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

@@ -25,6 +25,7 @@ export function showHelp(ctx) {
         "  /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]  (Ctrl+Alt+N)",
         "",
         "COURSE CORRECTION",
         "  /gsd steer <desc>   Apply user override to active work",

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

@@ -0,0 +1,103 @@
+// GSD Extension — /gsd notifications Command Handler
+// View, filter, and clear the persistent notification history.
+import { readNotifications, clearNotifications, getUnreadCount, suppressPersistence, unsuppressPersistence, } from "../../notification-store.js";
+import { GSDNotificationOverlay } from "../../notification-overlay.js";
+function severityIcon(severity) {
+    switch (severity) {
+        case "error": return "✗";
+        case "warning": return "⚠";
+        case "success": return "✓";
+        case "info":
+        default: return "●";
+    }
+}
+function formatTimestamp(ts) {
+    try {
+        const d = new Date(ts);
+        return d.toLocaleString("en-US", { hour12: false, month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+    }
+    catch {
+        return ts.slice(0, 19);
+    }
+}
+export async function handleNotificationsCommand(args, ctx, pi) {
+    // /gsd notifications clear
+    if (args === "clear") {
+        clearNotifications();
+        // Suppress persistence so the confirmation toast doesn't re-populate the store
+        suppressPersistence();
+        try {
+            ctx.ui.notify("All notifications cleared.", "success");
+        }
+        finally {
+            unsuppressPersistence();
+        }
+        return true;
+    }
+    // /gsd notifications tail [N]
+    if (args === "tail" || args.startsWith("tail ")) {
+        const countStr = args.replace(/^tail\s*/, "").trim();
+        const count = countStr ? parseInt(countStr, 10) : 20;
+        const n = isNaN(count) || count < 1 ? 20 : Math.min(count, 100);
+        const entries = readNotifications().slice(0, n);
+        if (entries.length === 0) {
+            ctx.ui.notify("No notifications.", "info");
+            return true;
+        }
+        const lines = entries.map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        ctx.ui.notify(`Last ${entries.length} notification(s):\n${lines.join("\n")}`, "info");
+        return true;
+    }
+    // /gsd notifications filter <severity>
+    if (args.startsWith("filter ")) {
+        const severity = args.replace(/^filter\s+/, "").trim().toLowerCase();
+        if (!["error", "warning", "info", "success"].includes(severity)) {
+            ctx.ui.notify("Usage: /gsd notifications filter <error|warning|info|success>", "warning");
+            return true;
+        }
+        const entries = readNotifications().filter((e) => e.severity === severity);
+        if (entries.length === 0) {
+            ctx.ui.notify(`No ${severity} notifications.`, "info");
+            return true;
+        }
+        const lines = entries.slice(0, 20).map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        const suffix = entries.length > 20 ? `\n... and ${entries.length - 20} more` : "";
+        ctx.ui.notify(`${severity} notifications (${entries.length}):\n${lines.join("\n")}${suffix}`, "info");
+        return true;
+    }
+    // /gsd notifications (no args) — open overlay in TUI, or print summary
+    if (args === "" || args === "status") {
+        // Try overlay first (TUI mode)
+        if (ctx.hasUI) {
+            try {
+                await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()), {
+                    overlay: true,
+                    overlayOptions: {
+                        width: "80%",
+                        minWidth: 60,
+                        maxHeight: "88%",
+                        anchor: "center",
+                    },
+                });
+                return true;
+            }
+            catch {
+                // Fall through to text output if overlay fails
+            }
+        }
+        // Text fallback (RPC/headless mode)
+        const unread = getUnreadCount();
+        const entries = readNotifications().slice(0, 10);
+        if (entries.length === 0) {
+            ctx.ui.notify("No notifications.", "info");
+            return true;
+        }
+        const lines = entries.map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        const header = unread > 0 ? `${unread} unread — ` : "";
+        ctx.ui.notify(`${header}Recent notifications:\n${lines.join("\n")}`, "info");
+        return true;
+    }
+    // Unknown subcommand
+    ctx.ui.notify("Usage: /gsd notifications [clear|tail [N]|filter <severity>]", "warning");
+    return true;
+}

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

@@ -175,6 +175,11 @@ Examples:
         await dispatchDirectPhase(ctx, pi, phase, projectRoot());
         return true;
     }
+    if (trimmed === "notifications" || trimmed.startsWith("notifications ")) {
+        const { handleNotificationsCommand } = await import("./notifications-handler.js");
+        await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "inspect") {
         await handleInspect(ctx);
         return true;

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

@@ -27,21 +27,26 @@ export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
     pi.sendMessage({ customType: "gsd-doctor-heal", content, display: false }, { triggerTurn: true });
 }
-export async function handleDoctor(args, ctx, pi) {
+/** Parse doctor command args into structured flags and positionals (pure, no I/O). */
+export function parseDoctorArgs(args) {
     const trimmed = args.trim();
-    // Extract flags before positional parsing
     const jsonMode = trimmed.includes("--json");
     const dryRun = trimmed.includes("--dry-run");
+    const fixFlag = trimmed.includes("--fix");
     const includeBuild = trimmed.includes("--build");
     const includeTests = trimmed.includes("--test");
-    const stripped = trimmed.replace(/--json|--dry-run|--build|--test/g, "").trim();
+    const stripped = trimmed.replace(/--json|--dry-run|--build|--test|--fix/g, "").trim();
     const parts = stripped ? stripped.split(/\s+/) : [];
     const mode = parts[0] === "fix" || parts[0] === "heal" || parts[0] === "audit" ? parts[0] : "doctor";
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
+    return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
+}
+export async function handleDoctor(args, ctx, pi) {
+    const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
     const effectiveScope = mode === "audit" ? requestedScope : scope;
     const report = await runGSDDoctor(projectRoot(), {
-        fix: mode === "fix" || mode === "heal" || dryRun,
+        fix: mode === "fix" || mode === "heal" || dryRun || fixFlag,
         dryRun,
         scope: effectiveScope,
         includeBuild,

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

@@ -13,3 +13,45 @@ export const DEFAULT_BASH_TIMEOUT_SECS = 120;
 export const DIR_CACHE_MAX = 200;
 /** Max parse-cache entries before eviction. */
 export const CACHE_MAX = 50;
+// ─── Tool Scoping ─────────────────────────────────────────────────────────────
+/**
+ * GSD tools allowed during discuss flows (#2949).
+ *
+ * xAI/Grok (and potentially other providers with grammar-based constrained
+ * decoding) return "Grammar is too complex" (HTTP 400) when the combined
+ * tool schemas exceed their internal grammar limit. The full GSD tool set
+ * registers ~33 tools with deeply nested schemas; discuss flows only need
+ * a small subset.
+ *
+ * By scoping tools to this allowlist during discuss dispatches, the grammar
+ * sent to the provider stays well under provider limits.
+ *
+ * Included tools and why:
+ *   - gsd_summary_save: writes CONTEXT.md artifacts (all discuss prompts)
+ *   - gsd_save_summary: alias for above
+ *   - gsd_decision_save: records decisions (discuss.md output phase)
+ *   - gsd_save_decision: alias for above
+ *   - gsd_plan_milestone: writes roadmap (discuss.md single/multi milestone)
+ *   - gsd_milestone_plan: alias for above
+ *   - gsd_milestone_generate_id: generates milestone IDs (discuss.md multi-milestone)
+ *   - gsd_generate_milestone_id: alias for above
+ *   - gsd_requirement_update: updates requirements during discuss
+ *   - gsd_update_requirement: alias for above
+ */
+export const DISCUSS_TOOLS_ALLOWLIST = [
+    // Context / summary writing
+    "gsd_summary_save",
+    "gsd_save_summary",
+    // Decision recording
+    "gsd_decision_save",
+    "gsd_save_decision",
+    // Milestone planning (needed for discuss.md output phase)
+    "gsd_plan_milestone",
+    "gsd_milestone_plan",
+    // Milestone ID generation (multi-milestone flow)
+    "gsd_milestone_generate_id",
+    "gsd_generate_milestone_id",
+    // Requirement updates
+    "gsd_requirement_update",
+    "gsd_update_requirement",
+];