gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.351157b

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

@@ -23,7 +23,7 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -57,7 +57,7 @@ import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.j
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
 import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
-import { bootstrapAutoSession } from "./auto-start.js";
+import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -192,6 +192,19 @@ export function markToolStart(toolCallId, toolName) {
 export function markToolEnd(toolCallId) {
     _markToolEnd(toolCallId);
 }
+/**
+ * Record a tool invocation error on the current session (#2883).
+ * Called from tool_execution_end when a GSD tool fails with isError.
+ * Only stores the error if it matches the tool-invocation-error pattern
+ * (malformed/truncated JSON), not normal business-logic errors.
+ */
+export function recordToolInvocationError(toolName, errorMsg) {
+    if (!s.active)
+        return;
+    if (isToolInvocationError(errorMsg)) {
+        s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
+    }
+}
 export function getOldestInFlightToolAgeMs() {
     return _getOldestInFlightToolAgeMs();
 }
@@ -909,6 +922,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         ctx.ui.setFooter(hideFooter);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
+        // Open the project DB before rebuild/derive so resume uses DB-backed
+        // state instead of falling back to stale markdown parsing (#2940).
+        await openProjectDbIfPresent(s.basePath);
         try {
             await rebuildState(s.basePath);
             syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
@@ -1005,6 +1021,7 @@ const widgetStateAccessors = {
     getBasePath: () => s.basePath,
     isVerbose: () => s.verbose,
     isSessionSwitching: isSessionSwitchInFlight,
+    getCurrentDispatchedModelId: () => s.currentDispatchedModelId,
 };
 // ─── Preconditions ────────────────────────────────────────────────────────────
 /**

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

@@ -486,28 +486,10 @@ export function registerDbTools(pi) {
             "Use the canonical name gsd_plan_milestone; gsd_milestone_plan is only an alias.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             title: Type.String({ description: "Milestone title" }),
-            status: Type.Optional(Type.String({ description: "Milestone status (defaults to active)" })),
-            dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Milestone dependencies" })),
             vision: Type.String({ description: "Milestone vision" }),
-            successCriteria: Type.Array(Type.String(), { description: "Top-level success criteria bullets" }),
-            keyRisks: Type.Array(Type.Object({
-                risk: Type.String({ description: "Risk statement" }),
-                whyItMatters: Type.String({ description: "Why the risk matters" }),
-            }), { description: "Structured risk entries" }),
-            proofStrategy: Type.Array(Type.Object({
-                riskOrUnknown: Type.String({ description: "Risk or unknown to retire" }),
-                retireIn: Type.String({ description: "Where it will be retired" }),
-                whatWillBeProven: Type.String({ description: "What proof will be produced" }),
-            }), { description: "Structured proof strategy entries" }),
-            verificationContract: Type.String({ description: "Verification contract text" }),
-            verificationIntegration: Type.String({ description: "Integration verification text" }),
-            verificationOperational: Type.String({ description: "Operational verification text" }),
-            verificationUat: Type.String({ description: "UAT verification text" }),
-            definitionOfDone: Type.Array(Type.String(), { description: "Definition of done bullets" }),
-            requirementCoverage: Type.String({ description: "Requirement coverage text" }),
-            boundaryMapMarkdown: Type.String({ description: "Boundary map markdown block" }),
             slices: Type.Array(Type.Object({
                 sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
                 title: Type.String({ description: "Slice title" }),
@@ -520,6 +502,26 @@ export function registerDbTools(pi) {
                 integrationClosure: Type.String({ description: "Slice integration closure" }),
                 observabilityImpact: Type.String({ description: "Slice observability impact" }),
             }), { description: "Planned slices for the milestone" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            status: Type.Optional(Type.String({ description: "Milestone status (defaults to active)" })),
+            dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Milestone dependencies" })),
+            successCriteria: Type.Optional(Type.Array(Type.String(), { description: "Top-level success criteria bullets" })),
+            keyRisks: Type.Optional(Type.Array(Type.Object({
+                risk: Type.String({ description: "Risk statement" }),
+                whyItMatters: Type.String({ description: "Why the risk matters" }),
+            }), { description: "Structured risk entries" })),
+            proofStrategy: Type.Optional(Type.Array(Type.Object({
+                riskOrUnknown: Type.String({ description: "Risk or unknown to retire" }),
+                retireIn: Type.String({ description: "Where it will be retired" }),
+                whatWillBeProven: Type.String({ description: "What proof will be produced" }),
+            }), { description: "Structured proof strategy entries" })),
+            verificationContract: Type.Optional(Type.String({ description: "Verification contract text" })),
+            verificationIntegration: Type.Optional(Type.String({ description: "Integration verification text" })),
+            verificationOperational: Type.Optional(Type.String({ description: "Operational verification text" })),
+            verificationUat: Type.Optional(Type.String({ description: "UAT verification text" })),
+            definitionOfDone: Type.Optional(Type.Array(Type.String(), { description: "Definition of done bullets" })),
+            requirementCoverage: Type.Optional(Type.String({ description: "Requirement coverage text" })),
+            boundaryMapMarkdown: Type.Optional(Type.String({ description: "Boundary map markdown block" })),
         }),
         execute: planMilestoneExecute,
     };
@@ -575,13 +577,10 @@ export function registerDbTools(pi) {
             "Use the canonical name gsd_plan_slice; gsd_slice_plan is only an alias.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             goal: Type.String({ description: "Slice goal" }),
-            successCriteria: Type.String({ description: "Slice success criteria block" }),
-            proofLevel: Type.String({ description: "Slice proof level" }),
-            integrationClosure: Type.String({ description: "Slice integration closure" }),
-            observabilityImpact: Type.String({ description: "Slice observability impact" }),
             tasks: Type.Array(Type.Object({
                 taskId: Type.String({ description: "Task ID (e.g. T01)" }),
                 title: Type.String({ description: "Task title" }),
@@ -593,6 +592,11 @@ export function registerDbTools(pi) {
                 expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
                 observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
             }), { description: "Planned tasks for the slice" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            successCriteria: Type.Optional(Type.String({ description: "Slice success criteria block" })),
+            proofLevel: Type.Optional(Type.String({ description: "Slice proof level" })),
+            integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure" })),
+            observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact" })),
         }),
         execute: planSliceExecute,
     };
@@ -716,23 +720,25 @@ export function registerDbTools(pi) {
             "Idempotent — calling with the same params twice will upsert (INSERT OR REPLACE) without error.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             taskId: Type.String({ description: "Task ID (e.g. T01)" }),
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             oneLiner: Type.String({ description: "One-line summary of what was accomplished" }),
             narrative: Type.String({ description: "Detailed narrative of what happened during the task" }),
             verification: Type.String({ description: "What was verified and how — commands run, tests passed, behavior confirmed" }),
-            deviations: Type.String({ description: "Deviations from the task plan, or 'None.'" }),
-            knownIssues: Type.String({ description: "Known issues discovered but not fixed, or 'None.'" }),
-            keyFiles: Type.Array(Type.String(), { description: "List of key files created or modified" }),
-            keyDecisions: Type.Array(Type.String(), { description: "List of key decisions made during this task" }),
-            blockerDiscovered: Type.Boolean({ description: "Whether a plan-invalidating blocker was discovered" }),
-            verificationEvidence: Type.Array(Type.Object({
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            deviations: Type.Optional(Type.String({ description: "Deviations from the task plan, or 'None.'" })),
+            knownIssues: Type.Optional(Type.String({ description: "Known issues discovered but not fixed, or 'None.'" })),
+            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "List of key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "List of key decisions made during this task" })),
+            blockerDiscovered: Type.Optional(Type.Boolean({ description: "Whether a plan-invalidating blocker was discovered" })),
+            verificationEvidence: Type.Optional(Type.Array(Type.Object({
                 command: Type.String({ description: "Verification command that was run" }),
                 exitCode: Type.Number({ description: "Exit code of the command" }),
                 verdict: Type.String({ description: "Pass/fail verdict (e.g. '✅ pass', '❌ fail')" }),
                 durationMs: Type.Number({ description: "Duration of the command in milliseconds" }),
-            }), { description: "Array of verification evidence entries" }),
+            }), { description: "Array of verification evidence entries" })),
         }),
         execute: taskCompleteExecute,
     };
@@ -789,44 +795,46 @@ export function registerDbTools(pi) {
             "Idempotent — calling with the same params twice will not crash.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             sliceTitle: Type.String({ description: "Title of the slice" }),
             oneLiner: Type.String({ description: "One-line summary of what the slice accomplished" }),
             narrative: Type.String({ description: "Detailed narrative of what happened across all tasks" }),
             verification: Type.String({ description: "What was verified across all tasks" }),
-            deviations: Type.String({ description: "Deviations from the slice plan, or 'None.'" }),
-            knownLimitations: Type.String({ description: "Known limitations or gaps, or 'None.'" }),
-            followUps: Type.String({ description: "Follow-up work discovered during execution, or 'None.'" }),
-            keyFiles: Type.Array(Type.String(), { description: "Key files created or modified" }),
-            keyDecisions: Type.Array(Type.String(), { description: "Key decisions made during this slice" }),
-            patternsEstablished: Type.Array(Type.String(), { description: "Patterns established by this slice" }),
-            observabilitySurfaces: Type.Array(Type.String(), { description: "Observability surfaces added" }),
-            provides: Type.Array(Type.String(), { description: "What this slice provides to downstream slices" }),
-            requirementsSurfaced: Type.Array(Type.String(), { description: "New requirements surfaced" }),
-            drillDownPaths: Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" }),
-            affects: Type.Array(Type.String(), { description: "Downstream slices affected" }),
-            requirementsAdvanced: Type.Array(Type.Object({
+            uatContent: Type.String({ description: "UAT test content (markdown body)" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
+            knownLimitations: Type.Optional(Type.String({ description: "Known limitations or gaps, or 'None.'" })),
+            followUps: Type.Optional(Type.String({ description: "Follow-up work discovered during execution, or 'None.'" })),
+            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key decisions made during this slice" })),
+            patternsEstablished: Type.Optional(Type.Array(Type.String(), { description: "Patterns established by this slice" })),
+            observabilitySurfaces: Type.Optional(Type.Array(Type.String(), { description: "Observability surfaces added" })),
+            provides: Type.Optional(Type.Array(Type.String(), { description: "What this slice provides to downstream slices" })),
+            requirementsSurfaced: Type.Optional(Type.Array(Type.String(), { description: "New requirements surfaced" })),
+            drillDownPaths: Type.Optional(Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" })),
+            affects: Type.Optional(Type.Array(Type.String(), { description: "Downstream slices affected" })),
+            requirementsAdvanced: Type.Optional(Type.Array(Type.Object({
                 id: Type.String({ description: "Requirement ID" }),
                 how: Type.String({ description: "How it was advanced" }),
-            }), { description: "Requirements advanced by this slice" }),
-            requirementsValidated: Type.Array(Type.Object({
+            }), { description: "Requirements advanced by this slice" })),
+            requirementsValidated: Type.Optional(Type.Array(Type.Object({
                 id: Type.String({ description: "Requirement ID" }),
                 proof: Type.String({ description: "What proof validates it" }),
-            }), { description: "Requirements validated by this slice" }),
-            requirementsInvalidated: Type.Array(Type.Object({
+            }), { description: "Requirements validated by this slice" })),
+            requirementsInvalidated: Type.Optional(Type.Array(Type.Object({
                 id: Type.String({ description: "Requirement ID" }),
                 what: Type.String({ description: "What changed" }),
-            }), { description: "Requirements invalidated or re-scoped" }),
-            filesModified: Type.Array(Type.Object({
+            }), { description: "Requirements invalidated or re-scoped" })),
+            filesModified: Type.Optional(Type.Array(Type.Object({
                 path: Type.String({ description: "File path" }),
                 description: Type.String({ description: "What changed" }),
-            }), { description: "Files modified with descriptions" }),
-            requires: Type.Array(Type.Object({
+            }), { description: "Files modified with descriptions" })),
+            requires: Type.Optional(Type.Array(Type.Object({
                 slice: Type.String({ description: "Dependency slice ID" }),
                 provides: Type.String({ description: "What was consumed from it" }),
-            }), { description: "Upstream slice dependencies consumed" }),
-            uatContent: Type.String({ description: "UAT test content (markdown body)" }),
+            }), { description: "Upstream slice dependencies consumed" })),
         }),
         execute: sliceCompleteExecute,
     };
@@ -912,8 +920,11 @@ export function registerDbTools(pi) {
             };
         }
         try {
+            // ── Input sanitization: normalize markdown parameters (#3013) ──────
+            const { sanitizeCompleteMilestoneParams } = await import("./sanitize-complete-milestone.js");
+            const sanitized = sanitizeCompleteMilestoneParams(params);
             const { handleCompleteMilestone } = await import("../tools/complete-milestone.js");
-            const result = await handleCompleteMilestone(params, process.cwd());
+            const result = await handleCompleteMilestone(sanitized, process.cwd());
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
@@ -951,19 +962,21 @@ export function registerDbTools(pi) {
             "On success, returns summaryPath where the MILESTONE-SUMMARY.md was written.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             title: Type.String({ description: "Milestone title" }),
             oneLiner: Type.String({ description: "One-sentence summary of what the milestone achieved" }),
             narrative: Type.String({ description: "Detailed narrative of what happened during the milestone" }),
-            successCriteriaResults: Type.String({ description: "Markdown detailing how each success criterion was met or not met" }),
-            definitionOfDoneResults: Type.String({ description: "Markdown detailing how each definition-of-done item was met" }),
-            requirementOutcomes: Type.String({ description: "Markdown detailing requirement status transitions with evidence" }),
-            keyDecisions: Type.Array(Type.String(), { description: "Key architectural/pattern decisions made during the milestone" }),
-            keyFiles: Type.Array(Type.String(), { description: "Key files created or modified during the milestone" }),
-            lessonsLearned: Type.Array(Type.String(), { description: "Lessons learned during the milestone" }),
+            verificationPassed: Type.Boolean({ description: "Must be true — confirms that code change verification, success criteria, and definition of done checks all passed before completion" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            successCriteriaResults: Type.Optional(Type.String({ description: "Markdown detailing how each success criterion was met or not met" })),
+            definitionOfDoneResults: Type.Optional(Type.String({ description: "Markdown detailing how each definition-of-done item was met" })),
+            requirementOutcomes: Type.Optional(Type.String({ description: "Markdown detailing requirement status transitions with evidence" })),
+            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key architectural/pattern decisions made during the milestone" })),
+            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified during the milestone" })),
+            lessonsLearned: Type.Optional(Type.Array(Type.String(), { description: "Lessons learned during the milestone" })),
             followUps: Type.Optional(Type.String({ description: "Follow-up items for future milestones" })),
             deviations: Type.Optional(Type.String({ description: "Deviations from the original plan" })),
-            verificationPassed: Type.Boolean({ description: "Must be true — confirms that code change verification, success criteria, and definition of done checks all passed before completion" }),
         }),
         execute: milestoneCompleteExecute,
     };

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

@@ -26,6 +26,19 @@ export function resolveProjectRootDbPath(basePath) {
         const projectRoot = basePath.slice(0, fwdIdx);
         return join(projectRoot, ".gsd", "gsd.db");
     }
+    // External-state layout: ~/.gsd/projects/<hash>/worktrees/<MID>/...
+    // Resolve to ~/.gsd/projects/<hash>/gsd.db (the canonical project DB) (#2952).
+    // Must be checked before the generic symlink-resolved handler: both match
+    // /.gsd/projects/<hash>/worktrees/ but require different resolution targets.
+    const extRe = /[/\\]\.gsd[/\\]projects[/\\][a-f0-9]+[/\\]worktrees(?:[/\\]|$)/;
+    const extMatch = extRe.exec(basePath);
+    if (extMatch) {
+        const matchStr = extMatch[0];
+        // Find the "/worktrees" portion within the match and slice up to it
+        const wtIdx = matchStr.search(/[/\\]worktrees(?:[/\\]|$)/);
+        const projectStateRoot = basePath.slice(0, extMatch.index + wtIdx);
+        return join(projectStateRoot, "gsd.db");
+    }
     // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/M001/...
     // The project root is everything before /.gsd/projects/ (#2517)
     const symlinkMarker = `${sep}.gsd${sep}projects${sep}`;

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,7 +10,7 @@ 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";
@@ -243,6 +243,14 @@ 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);
+        }
     });
     pi.on("model_select", async (_event, ctx) => {
         await syncServiceTierStatus(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/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",
+];