@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

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

@@ -166,6 +166,6 @@ export async function handleVerdict(rawArgs, ctx, basePath) {
         ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`, "success");
     }
     if (effectiveVerdict === "needs-remediation") {
-        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+        ctx.ui.notify("Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.", "info");
     }
 }

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

@@ -9,6 +9,7 @@
 import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, resolveDynamicRoutingConfig, resolveEffectiveProfile, resolveModelWithFallbacksForUnit, resolveAutoSupervisorConfig, } from "./preferences.js";
+const DEFAULT_WIDGET_MODE = "small";
 function collectConfigSections() {
     const sections = [];
     const globalPrefs = loadGlobalGSDPreferences();
@@ -157,7 +158,7 @@ function collectConfigSections() {
         toggleRows.push({ label: "search_provider", value: prefs.search_provider });
     if (prefs?.context_selection)
         toggleRows.push({ label: "context_selection", value: prefs.context_selection });
-    if (prefs?.widget_mode && prefs.widget_mode !== "full")
+    if (prefs?.widget_mode && prefs.widget_mode !== DEFAULT_WIDGET_MODE)
         toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
     if (prefs?.experimental?.rtk)
         toggleRows.push({ label: "experimental.rtk", value: "on" });

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -62,6 +62,8 @@ export class GSDDashboardOverlay {
     refreshInFlight = null;
     disposed = false;
     resizeHandler = null;
+    cachedMetrics = null;
+    lastSeenUnitCount = -1;
     constructor(tui, theme, onClose) {
         this.tui = tui;
         this.theme = theme;
@@ -105,7 +107,8 @@ export class GSDDashboardOverlay {
             return;
         this.dashData = getAutoDashboardData();
         const nextIdentity = this.computeDashboardIdentity(this.dashData);
-        if (initial || nextIdentity !== this.loadedDashboardIdentity) {
+        const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
+        if (identityChanged) {
             const loaded = await this.loadData();
             if (this.disposed)
                 return;
@@ -116,7 +119,9 @@ export class GSDDashboardOverlay {
         if (initial) {
             this.loading = false;
         }
-        this.invalidate();
+        if (identityChanged) {
+            this.invalidate();
+        }
         this.tui.requestRender();
     }
     async loadData() {
@@ -392,7 +397,7 @@ export class GSDDashboardOverlay {
         }
         const ledger = getLedger();
         if (ledger && ledger.units.length > 0) {
-            const totals = getProjectTotals(ledger.units);
+            const { totals, promptStats, phases, slices, models } = this.ensureMetricsCache(ledger.units);
             lines.push(blank());
             lines.push(hr());
             lines.push(row(th.fg("text", th.bold("Cost & Usage"))));
@@ -424,7 +429,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(budgetParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const promptStats = getPromptSizeStats(ledger.units);
             if (promptStats) {
                 const promptParts = [
                     `${th.fg("dim", "avg prompt:")} ${th.fg("text", formatCharCount(promptStats.averagePromptChars))}`,
@@ -435,7 +439,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(promptParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const phases = aggregateByPhase(ledger.units);
             if (phases.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Phase")));
@@ -446,7 +449,6 @@ export class GSDDashboardOverlay {
                     lines.push(row(joinColumns(left, right, contentWidth)));
                 }
             }
-            const slices = aggregateBySlice(ledger.units);
             if (slices.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Slice")));
@@ -475,7 +477,6 @@ export class GSDDashboardOverlay {
                     }
                 }
             }
-            const models = aggregateByModel(ledger.units);
             if (models.length >= 1) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Model")));
@@ -534,6 +535,19 @@ export class GSDDashboardOverlay {
         const bar = th.fg(color, "█".repeat(filled)) + th.fg("dim", "░".repeat(Math.max(0, barWidth - filled)));
         return `${th.fg("dim", labelText)}${" ".repeat(gap)}${bar}${" ".repeat(gap)}${th.fg("dim", rightText)}`;
     }
+    ensureMetricsCache(units) {
+        if (!this.cachedMetrics || units.length !== this.lastSeenUnitCount) {
+            this.cachedMetrics = {
+                totals: getProjectTotals(units),
+                promptStats: getPromptSizeStats(units),
+                phases: aggregateByPhase(units),
+                slices: aggregateBySlice(units),
+                models: aggregateByModel(units),
+            };
+            this.lastSeenUnitCount = units.length;
+        }
+        return this.cachedMetrics;
+    }
     invalidate() {
         this.cachedWidth = undefined;
         this.cachedLines = undefined;

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -305,10 +305,18 @@ This config sets a parent workspace with two child repositories. The implicit `p
   - `max_cycles`: number — max times this hook fires per trigger (default: 1, max: 10).
   - `model`: string — optional model override.
   - `artifact`: string — expected output file name (relative to task/slice dir). Hook is skipped if file already exists (idempotent).
+  - `criticality`: `"advisory"` or `"blocking"` — advisory preserves current best-effort behavior; blocking requires clean hook completion plus a valid outcome verdict before auto-mode advances. Default: `"advisory"`.
   - `retry_on`: string — if this file is produced instead of the artifact, re-run the trigger unit then re-run hooks.
+  - `on_block`: object — optional routing for blocking findings:
+    - `action`: `"retry-unit"`, `"retry-task"`, `"queue-task"`, `"queue-slice"`, or `"pause"`.
+    - `artifact`: string — optional compatibility artifact for retry routing.
   - `agent`: string — agent definition file to use for hook execution.
   - `enabled`: boolean — toggle without removing (default: `true`).
 
+  Blocking hook artifacts must begin with YAML frontmatter containing either `verdict` or `outcome.verdict`.
+  Supported verdicts are `pass`, `advisory`, `needs-rework`, `needs-remediation`, and `needs-attention`.
+  `pass` and `advisory` continue; `needs-rework` retries the trigger unit when routed with `retry-unit`/`retry-task`; `needs-remediation` and `needs-attention` pause with recovery guidance.
+
 - `pre_dispatch_hooks`: array — hooks that fire before a unit is dispatched. Each entry has:
   - `name`: string — unique hook identifier.
   - `before`: string[] — unit types to intercept.

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -258,14 +258,14 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 catch {
                     count = MAX_UAT_ATTEMPTS + 1;
                 }
-                if (count <= MAX_UAT_ATTEMPTS)
+                if (count < MAX_UAT_ATTEMPTS)
                     continue;
                 issues.push({
                     severity: "warning",
                     code: "uat_retry_exhausted",
                     scope: "slice",
                     unitId: `${mid}/${sid}`,
-                    message: `run-uat for ${mid}/${sid} exhausted ${count - 1} retry attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
+                    message: `run-uat for ${mid}/${sid} exhausted ${count} attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
                     file: `.gsd/runtime/${fileName}`,
                     fixable: true,
                 });

package/dist/resources/extensions/gsd/error-classifier.js

@@ -21,9 +21,10 @@ export function resetRetryState(state) {
 const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
 // Include provider-specific quota-window phrasing like:
 // - "You've hit your limit"
+// - "You've reached your limit"
 // - "usage limit" / "quota reached"
 // - "out of extra usage"
-const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429|(?:hit|reached) your (?:\w+ )?limit|(?:usage|session|weekly|daily|monthly|quota) limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
 // OpenRouter affordability-style quota errors should be treated as transient
 // so core retry logic can lower maxTokens and continue in-session.
 const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;

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

@@ -140,13 +140,13 @@ export function readEscalationArtifact(path) {
 }
 // ─── Detection ────────────────────────────────────────────────────────────
 /**
- * Returns the task id of the first task with an un-resolved pause-escalation
- * (escalation_pending=1, not yet respondedAt). awaiting_review slices are NOT
- * returned — they don't pause the loop.
+ * Returns the task id of the first task with an unresolved escalation.
+ * `continueWithDefault=true` artifacts keep the awaiting_review flag for
+ * compatibility, but still pause dispatch until the user explicitly responds.
  */
 export function detectPendingEscalation(tasks, basePath) {
     for (const t of tasks) {
-        if (t.escalation_pending !== 1)
+        if (t.escalation_pending !== 1 && t.escalation_awaiting_review !== 1)
             continue;
         if (!t.escalation_artifact_path)
             continue;

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -247,6 +247,7 @@ function writeMeta(path, result, request, now) {
         id: result.id,
         runtime: result.runtime,
         purpose: request.purpose ?? null,
+        ...(request.metadata ? { metadata: request.metadata } : {}),
         script_chars: request.script.length,
         started_at: now.toISOString(),
         finished_at: new Date(now.getTime() + result.duration_ms).toISOString(),
@@ -260,6 +261,7 @@ function writeMeta(path, result, request, now) {
         stderr_truncated: result.stderr_truncated,
         stdout_path: result.stdout_path,
         stderr_path: result.stderr_path,
+        ...(request.metadata ? { metadata: request.metadata } : {}),
     };
     writeFileSync(path, `${JSON.stringify(meta, null, 2)}\n`);
 }

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

@@ -32,6 +32,68 @@ import { isInteractiveCommandContext, notifyForensicsNeedsInteractiveMenu, } fro
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 import { summarizeWorktreeTelemetry, percentile } from "./worktree-telemetry.js";
 import { homedir } from "node:os";
+// ─── Filing Tool Scope ───────────────────────────────────────────────────────
+const FORENSICS_FILING_TOOLS = ["bash", "write"];
+function uniqueAppend(base, additions) {
+    const seen = new Set(base);
+    const next = [...base];
+    for (const name of additions) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        next.push(name);
+    }
+    return next;
+}
+function sameOrderedTools(a, b) {
+    return a.length === b.length && a.every((name, index) => name === b[index]);
+}
+function getRegisteredToolNames(pi, fallback) {
+    if (typeof pi.getAllTools === "function") {
+        return pi.getAllTools().map((tool) => tool.name);
+    }
+    return [...fallback];
+}
+export function createForensicsToolScope(pi) {
+    const savedTools = [...pi.getActiveTools()];
+    const registeredTools = new Set([...getRegisteredToolNames(pi, savedTools), ...savedTools]);
+    const availableFilingTools = FORENSICS_FILING_TOOLS.filter((name) => registeredTools.has(name));
+    const missingFilingTools = FORENSICS_FILING_TOOLS.filter((name) => !registeredTools.has(name));
+    const activeToolsForTurn = uniqueAppend(savedTools, availableFilingTools);
+    return {
+        savedTools,
+        activeToolsForTurn,
+        availableFilingTools,
+        missingFilingTools,
+        toolsChanged: !sameOrderedTools(savedTools, activeToolsForTurn),
+    };
+}
+export function applyForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.activeToolsForTurn);
+}
+export function restoreForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.savedTools);
+}
+export function buildForensicsToolingSection(scope) {
+    const available = new Set(scope.availableFilingTools);
+    const requested = scope.availableFilingTools.length
+        ? scope.availableFilingTools.map((name) => `\`${name}\``).join(", ")
+        : "none";
+    const statusFor = (name) => available.has(name)
+        ? `- \`${name}\`: available for this queued forensics turn`
+        : `- \`${name}\`: unavailable in this host session`;
+    return `
+## Filing Tool Availability
+
+For this queued forensic turn, the extension requested the registered filing tools: ${requested}.
+
+${FORENSICS_FILING_TOOLS.map(statusFor).join("\n")}
+
+If \`bash\` is available, use the GitHub duplicate-check and issue-creation protocols below. If \`bash\` is unavailable, do not attempt duplicate-check or issue-creation tool calls with another tool; provide the paste-once shell script fallback instead.
+`;
+}
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
 ## Pre-Investigation: Duplicate Check (REQUIRED)
@@ -42,6 +104,8 @@ Before reading GSD source code or performing deep analysis, you MUST search for
 
 Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
 
+If \`bash\` is unavailable in the Filing Tool Availability section, do not attempt live duplicate-search tool calls. Say the live duplicate search must be run by the user, continue the source investigation, and include the duplicate-search commands in the paste-once fallback when issue filing is accepted.
+
 1. **Search closed issues** for similar keywords:
    \`\`\`
    gh issue list --repo open-gsd/gsd-pi --state closed --search "<keywords from root cause>" --limit 20
@@ -151,16 +215,24 @@ export async function handleForensics(args, ctx, pi) {
             gsdSourceDir = fallback;
     }
     const forensicData = formatReportForPrompt(report);
+    const toolScope = createForensicsToolScope(pi);
     const content = loadPrompt("forensics", {
         problemDescription,
         forensicData,
         gsdSourceDir,
         dedupSection,
+        toolingSection: buildForensicsToolingSection(toolScope),
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     ctx.ui.setStatus("gsd-forensics", "running");
-    pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
-    ctx.ui.setStatus("gsd-forensics", undefined);
+    try {
+        applyForensicsToolScope(pi, toolScope);
+        await pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    }
+    finally {
+        restoreForensicsToolScope(pi, toolScope);
+        ctx.ui.setStatus("gsd-forensics", undefined);
+    }
     // Persist forensics context so follow-up turns can re-inject it (#2941)
     writeForensicsMarker(basePath, savedPath, content);
 }

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

@@ -37,6 +37,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "./db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "./db-milestone-artifact-rows.js";
 import { backupDatabaseBeforeMigration } from "./db-migration-backup.js";
+import { isClosedStatus } from "./status-guards.js";
 import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, applyMigrationV28MemoryLastHitAt, applyMigrationV29RepositoryTargets, } from "./db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "./db-memory-fts-schema.js";
 import { createDbOpenState } from "./db-open-state.js";
@@ -1289,7 +1290,7 @@ export function setTaskEscalationPending(milestoneId, sliceId, taskId, artifactP
            escalation_artifact_path = :path
      WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":path": artifactPath, ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
 }
-/** Set awaiting-review state (artifact exists but continueWithDefault=true, no pause). Mutually exclusive with pending. */
+/** Set awaiting-review state (artifact exists and requires explicit user review). Mutually exclusive with pending. */
 export function setTaskEscalationAwaitingReview(milestoneId, sliceId, taskId, artifactPath) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -1419,15 +1420,47 @@ export function setMilestoneQueueOrder(order) {
         throw err;
     }
 }
+function getMilestoneStatusForUpdate(milestoneId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    const row = currentDb.prepare("SELECT status FROM milestones WHERE id = :id").get({ ":id": milestoneId });
+    return typeof row?.["status"] === "string" ? row["status"] : null;
+}
+function writeMilestoneStatus(milestoneId, status, completedAt) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE milestones SET status = :status, completed_at = :completed_at WHERE id = :id`).run({ ":status": status, ":completed_at": completedAt ?? null, ":id": milestoneId });
+}
 /**
  * Update a milestone's status in the database.
- * Used by park/unpark to keep the DB in sync with the filesystem marker.
- * See: https://github.com/open-gsd/gsd-pi/issues/2694
+ *
+ * Generic status updates may close milestones, park/unpark open milestones, or
+ * advance planned milestones. They may not reopen a closed milestone; callers
+ * must use reopenMilestoneStatus(), which is reserved for gsd_milestone_reopen.
  */
 export function updateMilestoneStatus(milestoneId, status, completedAt) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`UPDATE milestones SET status = :status, completed_at = :completed_at WHERE id = :id`).run({ ":status": status, ":completed_at": completedAt ?? null, ":id": milestoneId });
+    const currentStatus = getMilestoneStatusForUpdate(milestoneId);
+    if (currentStatus && isClosedStatus(currentStatus) && !isClosedStatus(status)) {
+        throw new Error(`Cannot update closed milestone ${milestoneId} from ${currentStatus} to ${status}; use gsd_milestone_reopen for an explicit reopen.`);
+    }
+    writeMilestoneStatus(milestoneId, status, completedAt);
+}
+/**
+ * Explicit closed -> active transition for gsd_milestone_reopen only.
+ */
+export function reopenMilestoneStatus(milestoneId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    const currentStatus = getMilestoneStatusForUpdate(milestoneId);
+    if (!currentStatus) {
+        throw new Error(`Cannot reopen missing milestone ${milestoneId}`);
+    }
+    if (!isClosedStatus(currentStatus)) {
+        throw new Error(`Cannot reopen milestone ${milestoneId} from status ${currentStatus}; milestone is not closed.`);
+    }
+    writeMilestoneStatus(milestoneId, "active", null);
 }
 export function getActiveMilestoneFromDb() {
     if (!currentDb)
@@ -2240,7 +2273,7 @@ export function deleteArtifactByPath(path) {
 }
 /**
  * Drop hierarchy rows in dependency order inside a transaction. Used by
- * `gsd recover` to rebuild engine state from markdown.
+ * `gsd recover --confirm` to rebuild engine state from markdown.
  */
 export function clearEngineHierarchy() {
     if (!currentDb)
@@ -2545,7 +2578,10 @@ export function decayMemoriesBefore(cutoffTs, now) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE memories
      SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-     WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).run({ ":now": now, ":cutoff": cutoffTs });
+     WHERE superseded_by IS NULL
+       AND updated_at < :cutoff
+       AND confidence > 0.1
+       AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`).run({ ":now": now, ":cutoff": cutoffTs });
 }
 export function supersedeLowestRankedMemories(limit, now) {
     if (!currentDb)

package/dist/resources/extensions/gsd/guided-flow.js

@@ -115,15 +115,10 @@ async function runQuickTaskChoice(ctx, pi) {
 }
 async function dispatchDiscussForNextMilestoneWithBacklog(ctx, pi, basePath, nextId) {
     const backlogContext = buildRequirementsBacklogDiscussContext(nextId);
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: nextId,
-        milestoneTitle: `New milestone ${nextId}`,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    const basePrompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction: [
             "> **Requirements backlog active.**",
             "> Map unmapped active requirements to this milestone before finalizing context.",
@@ -1054,7 +1049,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * @param basePath - Root directory of the project
  * @returns The discuss prompt string
  */
-async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield") {
+async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield", skipPriorContext = false) {
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
     if (prefs.discuss_preparation === false)
         return "";
@@ -1071,7 +1066,7 @@ async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield"
         const parts = [];
         if (codebaseBrief)
             parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
-        if (priorContextBrief)
+        if (priorContextBrief && !skipPriorContext)
             parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
         if (parts.length === 0)
             return "";
@@ -1103,17 +1098,11 @@ async function dispatchNewMilestoneDiscuss(ctx, pi, basePath, nextId, stepMode,
         await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
         return;
     }
-    const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone");
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
+    const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone", true);
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    let prompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: nextId,
-        milestoneTitle: `New milestone ${nextId}`,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    let prompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-        fastPathInstruction: "",
+        includeContextMode: false,
     });
     if (preparationContext)
         prompt += preparationContext;
@@ -1364,8 +1353,6 @@ export async function showDiscuss(ctx, pi, basePath, options) {
     // Special case: milestone is in needs-discussion phase (has CONTEXT-DRAFT.md but no roadmap yet).
     // Route to the draft discussion flow instead of erroring — the discussion IS how the roadmap gets created.
     if (state.phase === "needs-discussion") {
-        const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
-        const draftContent = draftFile ? await loadFile(draftFile) : null;
         const choice = await showNextAction(ctx, {
             title: `GSD — ${mid}: ${milestoneTitle}`,
             summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -1390,30 +1377,23 @@ export async function showDiscuss(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd discuss when ready to discuss this milestone.",
         });
         if (choice === "discuss_draft") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            const basePrompt = loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const seed = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "discuss_fresh") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
@@ -1631,20 +1611,12 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
             "> Ask only questions where the answer would materially change scope.",
         ].join("\n")
         : "";
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid,
-        milestoneTitle,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction,
     });
-    const prompt = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
     await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
 // ─── Smart Entry Point ────────────────────────────────────────────────────────
@@ -1908,7 +1880,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const result = await checkMarkdownHierarchyAgainstDb(basePath);
             if (result.action === "recovery-required") {
                 ctx.ui.notify(result.message ??
-                    `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover"}\` to import markdown explicitly.`, "warning");
+                    `Markdown planning artifacts do not match the authoritative DB. Run \`${result.recoveryCommand ?? "/gsd recover --confirm"}\` to import markdown explicitly.`, "warning");
             }
         }
         catch (err) {
@@ -2122,8 +2094,6 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     }
     // ── Draft milestone — needs discussion before planning ────────────────
     if (state.phase === "needs-discussion") {
-        const draftFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT-DRAFT");
-        const draftContent = draftFile ? await loadFile(draftFile) : null;
         const choice = await showNextAction(ctx, {
             title: `GSD — ${milestoneId}: ${milestoneTitle}`,
             summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -2148,30 +2118,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready to discuss this milestone.",
         });
         if (choice === "discuss_draft") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            const basePrompt = loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const seed = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "discuss_fresh") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
@@ -2279,14 +2242,12 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone", { basePath });
             }
             else if (choice === "discuss") {
-                const discussMilestoneTemplates = inlineTemplate("context", "Context");
                 const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-                await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                    workingDirectory: basePath,
-                    milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+                const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                    fastPathInstruction: "",
-                }), "gsd-run", ctx, "discuss-milestone", { basePath });
+                    includeContextMode: false,
+                });
+                await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);

package/dist/resources/extensions/gsd/mcp-filter.js

@@ -24,14 +24,17 @@ function collectServerEntries(servers) {
 export function discoverMcpServers(projectDir) {
     const mcpJsonPath = resolve(projectDir, ".mcp.json");
     const settingsPath = resolve(projectDir, ".claude", "settings.json");
+    const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
     const mcpJson = readJsonFile(mcpJsonPath);
     const settings = readJsonFile(settingsPath, true);
+    const localSettings = readJsonFile(localSettingsPath, true);
     const seen = new Set();
     const discovered = [];
     for (const entry of [
         ...collectServerEntries(mcpJson?.mcpServers),
         ...collectServerEntries(mcpJson?.servers),
         ...collectServerEntries(settings?.mcpServers),
+        ...collectServerEntries(localSettings?.mcpServers),
     ]) {
         if (seen.has(entry.name))
             continue;