gsd-pi 2.66.1-dev.ed243f2 → 2.67.0

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -10,7 +10,16 @@ import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
-const MAX_TRANSIENT_AUTO_RESUMES = 3;
+const MAX_TRANSIENT_AUTO_RESUMES = 8;
+/**
+ * Reset the module-level retry state so a resumed auto-session starts fresh.
+ * Called by provider-error-resume.ts before startAuto() — without this, the
+ * consecutiveTransientCount accumulates across pause/resume cycles and locks
+ * out auto-resume after MAX_TRANSIENT_AUTO_RESUMES total (not consecutive) errors.
+ */
+export function resetTransientRetryState() {
+    resetRetryState(retryState);
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -97,6 +106,28 @@ export async function handleAgentEnd(pi, event, ctx) {
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
         const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
+        // ── 1b. Defer to Core RetryHandler for transient errors ─────────────
+        // The Core RetryHandler (agent-session.ts) processes retryable errors
+        // AFTER this extension handler, in the same _processAgentEvent() call.
+        // For transient errors (overloaded, rate limit, server), the Core will
+        // retry in-context — same session, same conversation — which is strictly
+        // better than our Layer 2 pause+resume (which creates a new session).
+        //
+        // If we react here AND the Core also retries, we race: pauseAuto tears
+        // down the session while agent.continue() starts a new turn.
+        //
+        // Solution: Do nothing for transient errors. The Core RetryHandler
+        // runs next in _processAgentEvent and will either:
+        //   a) Retry successfully → new agent_end (success) → we see it next time
+        //   b) Exhaust retries → the agent stays idle, autoLoop's unit timeout
+        //      or stuck detection handles it
+        //
+        // We do NOT call resolveAgentEnd here — that would unblock autoLoop
+        // prematurely while the Core is still retrying in the same session.
+        // We do NOT call pauseAuto — that would tear down the session.
+        if (isTransient(cls)) {
+            return;
+        }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)
         // which use per-user quotas with shorter windows (#2922).
         if (cls.kind === "rate-limit") {

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

@@ -5,6 +5,11 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
+import { shouldBlockContextArtifactSave } from "./write-gate.js";
+const SUPPORTED_SUMMARY_ARTIFACT_TYPES = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT"];
+export function isSupportedSummaryArtifactType(artifactType) {
+    return SUPPORTED_SUMMARY_ARTIFACT_TYPES.includes(artifactType);
+}
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -274,13 +279,19 @@ export function registerDbTools(pi) {
                 details: { operation: "save_summary", error: "db_unavailable" },
             };
         }
-        const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
-        if (!validTypes.includes(params.artifact_type)) {
+        if (!isSupportedSummaryArtifactType(params.artifact_type)) {
             return {
-                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
                 details: { operation: "save_summary", error: "invalid_artifact_type" },
             };
         }
+        const contextGuard = shouldBlockContextArtifactSave(params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
+        if (contextGuard.block) {
+            return {
+                content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
+                details: { operation: "save_summary", error: "context_write_blocked" },
+            };
+        }
         try {
             let relativePath;
             if (params.task_id && params.slice_id) {
@@ -322,16 +333,17 @@ export function registerDbTools(pi) {
             "Computes the file path from milestone/slice/task IDs automatically.",
         promptSnippet: "Save a GSD artifact (summary/research/context/assessment) to DB and disk",
         promptGuidelines: [
-            "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
+            "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT).",
             "milestone_id is required. slice_id and task_id are optional — they determine the file path.",
             "The tool computes the relative path automatically: milestones/M001/M001-SUMMARY.md, milestones/M001/slices/S01/S01-SUMMARY.md, etc.",
-            "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT.",
+            "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT.",
+            "Use CONTEXT-DRAFT for incremental draft persistence; use CONTEXT for the final milestone context after depth verification.",
         ],
         parameters: Type.Object({
             milestone_id: Type.String({ description: "Milestone ID (e.g. M001)" }),
             slice_id: Type.Optional(Type.String({ description: "Slice ID (e.g. S01)" })),
             task_id: Type.Optional(Type.String({ description: "Task ID (e.g. T01)" })),
-            artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT" }),
+            artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT" }),
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
         execute: summarySaveExecute,

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -1,4 +1,5 @@
 import { getAutoDashboardData, startAuto } from "../auto.js";
+import { resetTransientRetryState } from "./agent-end-recovery.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
     startAuto,
@@ -13,6 +14,10 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
         ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
         return "missing-base";
     }
+    // Reset the transient retry counter before restarting — without this,
+    // consecutiveTransientCount accumulates across pause/resume cycles and
+    // permanently locks out auto-resume after MAX_TRANSIENT_AUTO_RESUMES errors.
+    resetTransientRetryState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }

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];