gsd-pi 2.66.1-dev.3c26b49 → 2.66.1-dev.3cea7ac

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

@@ -3,7 +3,7 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
-import { clearDiscussionFlowState, isDepthVerified, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution } from "./write-gate.js";
+import { clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { cleanupQuickBranch } from "../quick.js";
 import { getDiscussionMilestoneId } from "../guided-flow.js";
@@ -21,6 +21,7 @@ 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";
+import { initHealthWidget } from "../health-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;
@@ -33,6 +34,7 @@ export function registerHooks(pi) {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
         initNotificationWidget(ctx);
+        initHealthWidget(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -154,11 +156,42 @@ export function registerHooks(pi) {
         }
     });
     pi.on("tool_call", async (event) => {
+        const discussionBasePath = process.cwd();
         // ── Loop guard: block repeated identical tool calls ──
         const loopCheck = checkToolCallLoop(event.toolName, event.input);
         if (loopCheck.block) {
             return { block: true, reason: loopCheck.reason };
         }
+        // ── Discussion gate enforcement: track pending gate questions ─────────
+        // Only gate-shaped ask_user_questions calls should block execution.
+        // The gate stays pending until the user selects the approval option.
+        if (event.toolName === "ask_user_questions") {
+            const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+            const inDiscussion = milestoneId !== null || isQueuePhaseActive();
+            if (inDiscussion) {
+                const questions = event.input?.questions ?? [];
+                const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
+                if (typeof questionId === "string") {
+                    setPendingGate(questionId);
+                }
+            }
+        }
+        // ── Discussion gate enforcement: block tool calls while gate is pending ──
+        // If ask_user_questions was called with a gate ID but hasn't been confirmed,
+        // block all non-read-only tool calls to prevent the model from skipping gates.
+        if (getPendingGate()) {
+            const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+            if (isToolCallEventType("bash", event)) {
+                const bashGuard = shouldBlockPendingGateBash(event.input.command, milestoneId, isQueuePhaseActive());
+                if (bashGuard.block)
+                    return bashGuard;
+            }
+            else {
+                const gateGuard = shouldBlockPendingGate(event.toolName, milestoneId, isQueuePhaseActive());
+                if (gateGuard.block)
+                    return gateGuard;
+            }
+        }
         // ── Queue-mode execution guard (#2545): block source-code mutations ──
         // When /gsd queue is active, the agent should only create milestones,
         // not execute work. Block write/edit to non-.gsd/ paths and bash commands
@@ -197,7 +230,7 @@ export function registerHooks(pi) {
         }
         if (!isToolCallEventType("write", event))
             return;
-        const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(), isDepthVerified(), isQueuePhaseActive());
+        const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(discussionBasePath), isQueuePhaseActive());
         if (result.block)
             return result;
     });
@@ -220,21 +253,42 @@ export function registerHooks(pi) {
     pi.on("tool_result", async (event) => {
         if (event.toolName !== "ask_user_questions")
             return;
-        const milestoneId = getDiscussionMilestoneId();
+        const milestoneId = getDiscussionMilestoneId(process.cwd());
         const queueActive = isQueuePhaseActive();
         if (!milestoneId && !queueActive)
             return;
         const details = event.details;
+        // ── Discussion gate enforcement: handle gate question responses ──
+        // If the result is cancelled or has no response, the pending gate stays active
+        // so the model is blocked from non-read-only tools until it re-asks.
+        // If the user responded at all (even "needs adjustment"), clear the pending gate
+        // because the user engaged — the prompt handles the re-ask-after-adjustment flow.
+        const questions = event.input?.questions ?? [];
+        const currentPendingGate = getPendingGate();
+        if (currentPendingGate) {
+            if (details?.cancelled || !details?.response) {
+                // Gate stays pending — model will be blocked from non-read-only tools
+                // until it re-asks and gets a valid response
+            }
+            else {
+                const pendingQuestion = questions.find((question) => question?.id === currentPendingGate);
+                if (pendingQuestion) {
+                    const answer = details.response?.answers?.[currentPendingGate];
+                    if (isDepthConfirmationAnswer(answer?.selected, pendingQuestion.options)) {
+                        clearPendingGate();
+                    }
+                }
+            }
+        }
         if (details?.cancelled || !details?.response)
             return;
-        const questions = event.input?.questions ?? [];
         for (const question of questions) {
             if (typeof question.id === "string" && question.id.includes("depth_verification")) {
                 // Only unlock the gate if the user selected the first option (confirmation).
                 // Cross-references against the question's defined options to reject free-form "Other" text.
                 const answer = details.response?.answers?.[question.id];
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
-                    markDepthVerified();
+                    markDepthVerified(extractDepthVerificationMilestoneId(question.id) ?? milestoneId);
                 }
                 break;
             }

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

@@ -4,16 +4,18 @@ 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 { projectRoot } from "../commands/context.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
     pi.registerShortcut(Key.ctrlAlt("g"), {
         description: shortcutDesc("Open GSD dashboard", "/gsd status"),
         handler: async (ctx) => {
-            if (!existsSync(join(process.cwd(), ".gsd"))) {
+            const basePath = projectRoot();
+            if (!existsSync(join(basePath, ".gsd"))) {
                 ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
                 return;
             }
-            await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()), {
+            await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
                 overlay: true,
                 overlayOptions: {
                     width: "90%",
@@ -27,7 +29,7 @@ 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()), {
+            await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)), {
                 overlay: true,
                 overlayOptions: {
                     width: "80%",
@@ -42,12 +44,13 @@ export function registerShortcuts(pi) {
     pi.registerShortcut(Key.ctrlAlt("p"), {
         description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
         handler: async (ctx) => {
-            const parallelDir = join(process.cwd(), ".gsd", "parallel");
+            const basePath = projectRoot();
+            const parallelDir = join(basePath, ".gsd", "parallel");
             if (!existsSync(parallelDir)) {
                 ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
                 return;
             }
-            await ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done()), {
+            await ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(true)), {
                 overlay: true,
                 overlayOptions: {
                     width: "90%",

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

@@ -1,4 +1,6 @@
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
+const CONTEXT_MILESTONE_RE = /(?:^|[/\\])(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/i;
+const DEPTH_VERIFICATION_MILESTONE_RE = /depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i;
 /**
  * Path segment that identifies .gsd/ planning artifacts.
  * Writes to these paths are allowed during queue mode.
@@ -22,10 +24,49 @@ const QUEUE_SAFE_TOOLS = new Set([
  * Matches the leading command in a bash invocation.
  */
 const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s)/;
-let depthVerificationDone = false;
+const verifiedDepthMilestones = new Set();
 let activeQueuePhase = false;
+/**
+ * Discussion gate enforcement state.
+ *
+ * When ask_user_questions is called with a recognized gate question ID,
+ * we track the pending gate. Until the gate is confirmed (user selects the
+ * first/recommended option), all non-read-only tool calls are blocked.
+ * This mechanically prevents the model from rationalizing past failed or
+ * cancelled gate questions.
+ */
+let pendingGateId = null;
+/**
+ * Recognized gate question ID patterns.
+ * These appear in both discuss-prepared.md (4-layer) and discuss.md (depth/requirements/roadmap).
+ */
+const GATE_QUESTION_PATTERNS = [
+    "layer1_scope_gate",
+    "layer2_architecture_gate",
+    "layer3_error_gate",
+    "layer4_quality_gate",
+    "depth_verification",
+];
+/**
+ * Tools that are safe to call while a gate is pending.
+ * Includes read-only tools and ask_user_questions itself (so the model can re-ask).
+ */
+const GATE_SAFE_TOOLS = new Set([
+    "ask_user_questions",
+    "read", "grep", "find", "ls", "glob",
+    "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
+    "search_and_read",
+]);
 export function isDepthVerified() {
-    return depthVerificationDone;
+    return verifiedDepthMilestones.size > 0;
+}
+/**
+ * Check whether a specific milestone has passed depth verification.
+ */
+export function isMilestoneDepthVerified(milestoneId) {
+    if (!milestoneId)
+        return false;
+    return verifiedDepthMilestones.has(milestoneId);
 }
 export function isQueuePhaseActive() {
     return activeQueuePhase;
@@ -34,14 +75,103 @@ export function setQueuePhaseActive(active) {
     activeQueuePhase = active;
 }
 export function resetWriteGateState() {
-    depthVerificationDone = false;
+    verifiedDepthMilestones.clear();
+    pendingGateId = null;
 }
 export function clearDiscussionFlowState() {
-    depthVerificationDone = false;
+    verifiedDepthMilestones.clear();
     activeQueuePhase = false;
+    pendingGateId = null;
+}
+export function markDepthVerified(milestoneId) {
+    if (!milestoneId)
+        return;
+    verifiedDepthMilestones.add(milestoneId);
+}
+/**
+ * Check whether a question ID matches a recognized gate pattern.
+ */
+export function isGateQuestionId(questionId) {
+    return GATE_QUESTION_PATTERNS.some(pattern => questionId.includes(pattern));
+}
+/**
+ * Extract the milestone ID embedded in a depth-verification question id.
+ * Prompts are expected to use ids like `depth_verification_M001_confirm`.
+ */
+export function extractDepthVerificationMilestoneId(questionId) {
+    const match = questionId.match(DEPTH_VERIFICATION_MILESTONE_RE);
+    return match?.[1] ?? null;
+}
+/**
+ * Extract the milestone ID from a milestone CONTEXT file path.
+ */
+function extractContextMilestoneId(inputPath) {
+    const match = inputPath.match(CONTEXT_MILESTONE_RE);
+    return match?.[1] ?? null;
+}
+/**
+ * Mark a gate as pending (called when ask_user_questions is invoked with a gate ID).
+ */
+export function setPendingGate(gateId) {
+    pendingGateId = gateId;
+}
+/**
+ * Clear the pending gate (called when the user confirms).
+ */
+export function clearPendingGate() {
+    pendingGateId = null;
+}
+/**
+ * Get the currently pending gate, if any.
+ */
+export function getPendingGate() {
+    return pendingGateId;
+}
+/**
+ * Check whether a tool call should be blocked because a discussion gate
+ * is pending (ask_user_questions was called but not confirmed).
+ *
+ * Returns { block: true, reason } if the tool should be blocked.
+ * Read-only tools and ask_user_questions itself are always allowed.
+ */
+export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive) {
+    if (!pendingGateId)
+        return { block: false };
+    if (GATE_SAFE_TOOLS.has(toolName))
+        return { block: false };
+    // Bash read-only commands are also safe
+    if (toolName === "bash")
+        return { block: false }; // bash is checked separately below
+    return {
+        block: true,
+        reason: [
+            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `You MUST re-call ask_user_questions with the gate question before making any other tool calls.`,
+            `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
+            `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
+            `Do NOT proceed, do NOT use alternative approaches, do NOT skip the gate.`,
+        ].join(" "),
+    };
 }
-export function markDepthVerified() {
-    depthVerificationDone = true;
+/**
+ * Check whether a bash command should be blocked because a discussion gate is pending.
+ * Read-only bash commands are allowed; mutating commands are blocked.
+ */
+export function shouldBlockPendingGateBash(command, _milestoneId, _queuePhaseActive) {
+    if (!pendingGateId)
+        return { block: false };
+    // Allow read-only bash commands
+    if (BASH_READ_ONLY_RE.test(command))
+        return { block: false };
+    return {
+        block: true,
+        reason: [
+            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `You MUST re-call ask_user_questions with the gate question before running mutating commands.`,
+            `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
+            `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
+        ].join(" "),
+    };
 }
 /**
  * Check whether a depth_verification answer confirms the discussion is complete.
@@ -67,16 +197,23 @@ export function isDepthConfirmationAnswer(selected, options) {
     // accept only if it contains "(Recommended)" — the prompt convention suffix.
     return value.includes("(Recommended)");
 }
-export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthVerified, queuePhaseActive) {
+export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queuePhaseActive) {
     if (toolName !== "write")
         return { block: false };
-    const inDiscussion = milestoneId !== null;
-    const inQueue = queuePhaseActive ?? false;
-    if (!inDiscussion && !inQueue)
-        return { block: false };
     if (!MILESTONE_CONTEXT_RE.test(inputPath))
         return { block: false };
-    if (depthVerified)
+    const targetMilestoneId = extractContextMilestoneId(inputPath) ?? milestoneId;
+    if (!targetMilestoneId) {
+        return {
+            block: true,
+            reason: [
+                `HARD BLOCK: Cannot write milestone CONTEXT.md without knowing which milestone it belongs to.`,
+                `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+                `Required action: call ask_user_questions with question id containing "depth_verification" and the milestone id.`,
+            ].join(" "),
+        };
+    }
+    if (isMilestoneDepthVerified(targetMilestoneId))
         return { block: false };
     return {
         block: true,
@@ -89,6 +226,37 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthV
         ].join(" "),
     };
 }
+/**
+ * Check whether a gsd_summary_save CONTEXT artifact should be blocked.
+ * Slice-level CONTEXT artifacts are allowed; milestone-level CONTEXT writes
+ * require the milestone to be depth-verified first.
+ */
+export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceId) {
+    if (artifactType !== "CONTEXT")
+        return { block: false };
+    if (sliceId)
+        return { block: false };
+    if (!milestoneId) {
+        return {
+            block: true,
+            reason: [
+                `HARD BLOCK: Cannot save milestone CONTEXT without a milestone_id.`,
+                `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+            ].join(" "),
+        };
+    }
+    if (isMilestoneDepthVerified(milestoneId))
+        return { block: false };
+    return {
+        block: true,
+        reason: [
+            `HARD BLOCK: Cannot save milestone CONTEXT without depth verification for ${milestoneId}.`,
+            `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+            `Required action: call ask_user_questions with question id containing "depth_verification_${milestoneId}".`,
+            `The user MUST select the "(Recommended)" confirmation option to unlock this gate.`,
+        ].join(" "),
+    };
+}
 /**
  * Queue-mode execution guard (#2545).
  *
@@ -130,6 +298,10 @@ export function shouldBlockQueueExecution(toolName, input, queuePhaseActive) {
                 `Use read-only commands (cat, grep, git log, etc.) to investigate, then write planning artifacts.`,
         };
     }
-    // Unknown tools — allow by default (custom extension tools, etc.)
-    return { block: false };
+    // Unknown tools — block by default in queue mode so custom tools cannot
+    // bypass execution restrictions.
+    return {
+        block: true,
+        reason: `Blocked: /gsd queue is a planning tool — it creates milestones, not executes work. Unknown tools are not permitted during queue mode.`,
+    };
 }

package/dist/resources/extensions/gsd/codebase-generator.js

@@ -15,6 +15,10 @@ import { gsdRoot } from "./paths.js";
 const DEFAULT_EXCLUDES = [
     ".gsd/",
     ".planning/",
+    ".plans/",
+    ".claude/",
+    ".cursor/",
+    ".vscode/",
     ".git/",
     "node_modules/",
     "dist/",

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

@@ -77,7 +77,7 @@ export async function handleStatus(ctx) {
         return;
     }
     const { GSDDashboardOverlay } = await import("../../dashboard-overlay.js");
-    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()), {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
         overlay: true,
         overlayOptions: {
             width: "70%",
@@ -99,7 +99,7 @@ export async function handleVisualize(ctx) {
         return;
     }
     const { GSDVisualizerOverlay } = await import("../../visualizer-overlay.js");
-    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done()), {
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done(true)), {
         overlay: true,
         overlayOptions: {
             width: "80%",
@@ -195,7 +195,7 @@ export async function handleCoreCommand(trimmed, ctx) {
     }
     if (trimmed === "show-config") {
         const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
-        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done()), {
+        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true)), {
             overlay: true,
             overlayOptions: {
                 width: "65%",

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

@@ -240,10 +240,16 @@ async function configureModels(ctx, prefs) {
         for (const group of byProvider.values()) {
             group.sort((a, b) => a.id.localeCompare(b.id));
         }
-        // Build provider menu with model counts
+        // Display names for providers in the preferences wizard UI.
+        const PROVIDER_DISPLAY_NAMES = { anthropic: "anthropic-api" };
+        const displayName = (p) => PROVIDER_DISPLAY_NAMES[p] ?? p;
+        // Build provider menu with model counts (display name → real name lookup)
+        const displayToReal = new Map();
         const providerOptions = providers.map(p => {
             const count = byProvider.get(p).length;
-            return `${p} (${count} models)`;
+            const label = `${displayName(p)} (${count} models)`;
+            displayToReal.set(label, p);
+            return label;
         });
         providerOptions.push("(keep current)", "(clear)", "(type manually)");
         for (const phase of modelPhases) {
@@ -267,13 +273,13 @@ async function configureModels(ctx, prefs) {
                 continue;
             }
             // Step 2: pick model within provider
-            const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+            const providerName = displayToReal.get(providerChoice) ?? providerChoice.replace(/ \(\d+ models?\)$/, "");
             const group = byProvider.get(providerName);
             if (!group)
                 continue;
             const modelOptions = group.map(m => m.id);
             modelOptions.push("(keep current)", "(clear)");
-            const modelChoice = await ctx.ui.select(`${phaseLabel} — ${providerName}:`, modelOptions);
+            const modelChoice = await ctx.ui.select(`${phaseLabel} — ${displayName(providerName)}:`, modelOptions);
             if (modelChoice && typeof modelChoice === "string" && modelChoice !== "(keep current)") {
                 if (modelChoice === "(clear)") {
                     delete models[phase];

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -135,7 +135,9 @@ export class CustomWorkflowEngine {
      * Returns "milestone-complete" when all steps are now done, "continue" otherwise.
      */
     async reconcile(state, completedStep) {
-        const graph = state.raw;
+        // Re-read the graph from disk so we do not overwrite concurrent
+        // workflow edits with a stale in-memory snapshot from deriveState().
+        const graph = readGraph(this.runDir);
         // Extract stepId from "<workflowName>/<stepId>"
         const { milestone, slice, task } = parseUnitId(completedStep.unitId);
         const stepId = task ?? slice ?? milestone;

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

@@ -170,6 +170,12 @@ const TEST_MARKERS = [
 /** Directories skipped during bounded recursive project scans. */
 const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     ".git",
+    ".gsd",
+    ".planning",
+    ".plans",
+    ".claude",
+    ".cursor",
+    ".vscode",
     "node_modules",
     ".venv",
     "venv",

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

@@ -104,6 +104,23 @@ export function extractAllSections(body, level = 2) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Normalize a task-plan file reference that may include inline description text
+ * after the path, for example:
+ *   "docs/file.md — explanation"
+ *   "docs/file.md - explanation"
+ */
+export function normalizePlannedFileReference(value) {
+    const trimmed = value.trim().replace(/`/g, "");
+    const match = /^(.*?)(?:\s+(?:—|-)\s+)(.+)$/.exec(trimmed);
+    if (!match)
+        return trimmed;
+    const pathCandidate = match[1].trim();
+    if (pathCandidate.includes("/") || pathCandidate.includes("\\") || pathCandidate.includes(".")) {
+        return pathCandidate;
+    }
+    return trimmed;
+}
 /** Parse bullet list items from a text block. */
 export function parseBullets(text) {
     return text.split('\n')
@@ -540,11 +557,11 @@ export function parseTaskPlanIO(content) {
             let match;
             backtickPathRegex.lastIndex = 0;
             while ((match = backtickPathRegex.exec(trimmed)) !== null) {
-                const candidate = match[1];
+                const candidate = normalizePlannedFileReference(match[1]);
                 // Filter out things that look like code tokens rather than file paths
                 // (e.g. `true`, `false`, `npm run test`). A file path has at least one
                 // dot or slash.
-                if (candidate.includes("/") || candidate.includes(".")) {
+                if (candidate.includes("/") || candidate.includes("\\") || candidate.includes(".")) {
                     paths.push(candidate);
                 }
             }

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

@@ -142,12 +142,13 @@ export function checkAutoStartAfterDiscuss() {
     // Parse PROJECT.md for milestone sequence, warn if any are missing context.
     // Don't block — milestones can be intentionally queued without context.
     const projectFile = resolveGsdRootFile(basePath, "PROJECT");
+    let projectIds = [];
     if (projectFile) {
         try {
             const projectContent = readFileSync(projectFile, "utf-8");
-            const milestoneIds = parseMilestoneSequenceFromProject(projectContent);
-            if (milestoneIds.length > 1) {
-                const missing = milestoneIds.filter(id => {
+            projectIds = parseMilestoneSequenceFromProject(projectContent);
+            if (projectIds.length > 1) {
+                const missing = projectIds.filter(id => {
                     const hasContext = !!resolveMilestoneFile(basePath, id, "CONTEXT");
                     const hasDraft = !!resolveMilestoneFile(basePath, id, "CONTEXT-DRAFT");
                     const hasDir = existsSync(join(gsdRoot(basePath), "milestones", id));
@@ -165,9 +166,14 @@ export function checkAutoStartAfterDiscuss() {
     }
     // Gate 4: Discussion manifest process verification (multi-milestone only)
     // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
-    // If the manifest exists but gates_completed < total, the LLM hasn't finished
-    // presenting all readiness gates to the user — block auto-start.
+    // If the project is multi-milestone, the manifest is required. When it is
+    // missing, fail closed instead of assuming the discussion finished.
     const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
+    const requiresManifest = projectIds.length > 1 || findMilestoneIds(basePath).length > 1;
+    if (requiresManifest && !existsSync(manifestPath)) {
+        ctx.ui.notify("Multi-milestone discussion manifest is missing. Auto-start will remain paused until the manifest is written.", "warning");
+        return false;
+    }
     if (existsSync(manifestPath)) {
         try {
             const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -178,9 +184,7 @@ export function checkAutoStartAfterDiscuss() {
                 return false;
             }
             // Cross-check manifest milestones against PROJECT.md if available
-            if (projectFile) {
-                const projectContent = readFileSync(projectFile, "utf-8");
-                const projectIds = parseMilestoneSequenceFromProject(projectContent);
+            if (projectIds.length > 0) {
                 const manifestIds = Object.keys(manifest.milestones ?? {});
                 const untracked = projectIds.filter(id => !manifestIds.includes(id));
                 if (untracked.length > 0) {

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

@@ -1,4 +1,4 @@
-export { isDepthConfirmationAnswer, isDepthVerified, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockQueueExecution, } from "./bootstrap/write-gate.js";
+export { isDepthConfirmationAnswer, isDepthVerified, isGateQuestionId, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockPendingGate, shouldBlockPendingGateBash, shouldBlockQueueExecution, setPendingGate, clearPendingGate, getPendingGate, } from "./bootstrap/write-gate.js";
 export default async function registerExtension(pi) {
     const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
     registerGsdExtension(pi);

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -406,6 +406,8 @@ export class ParallelMonitorOverlay {
         lines.push(t.fg("muted", "  ESC/q to close  │  ↑↓ scroll"));
         // Apply scroll — use terminal rows as height estimate
         const termHeight = process.stdout.rows || 40;
+        const maxScroll = Math.max(0, lines.length - termHeight);
+        this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
         const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
         this.cachedLines = visible;
         return visible;

package/dist/resources/extensions/gsd/parsers-legacy.js

@@ -177,7 +177,9 @@ function _parsePlanImpl(content) {
         for (const line of lines) {
             const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
             // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
-            const hdMatch = !cbMatch ? line.match(/^#{2,4}\s+([\w.]+)\s*(?:--|—|:)\s*(.+)/) : null;
+            const hdMatch = !cbMatch
+                ? line.match(/^#{2,4}\s+([A-Z]+\d+(?:\.[A-Z]+\d+)*)\s*(?:--|—|:)\s*(.+)/)
+                : null;
             if (cbMatch || hdMatch) {
                 const taskId = cbMatch ? cbMatch[2] : hdMatch[1];
                 // Skip tasks already found in the Tasks section

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -63,6 +63,6 @@ Then:
 13. Do not commit manually — the system auto-commits your changes after this unit completes.
 - Say: "Milestone {{milestoneId}} complete."
 
-**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run.
+**Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run. **If a verification tool itself fails, errors, or returns unexpected output, treat it as a verification failure** — never rationalize past a tool error ("tool didn't respond, assuming success" is forbidden). A tool that cannot verify is a tool that did not verify.
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.