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

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -11,6 +11,7 @@ import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
+import { getErrorMessage } from "./error-utils.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -24,7 +25,11 @@ import { makeUI } from "../shared/tui.js";
 import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
-import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import {
+  getGlobalGSDPreferencesPath,
+  getProjectGSDPreferencesPath,
+  parsePreferencesMarkdown,
+} from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
 import {
@@ -370,26 +375,74 @@ export type WidgetMode = "full" | "small" | "min" | "off";
 const WIDGET_MODES: WidgetMode[] = ["full", "small", "min", "off"];
 let widgetMode: WidgetMode = "full";
 let widgetModeInitialized = false;
+let widgetModePreferencePath: string | null = null;
+
+function safeReadTextFile(path: string): string | null {
+  try {
+    if (!existsSync(path)) return null;
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function readWidgetModeFromFile(path: string): WidgetMode | undefined {
+  const raw = safeReadTextFile(path);
+  if (!raw) return undefined;
+  const prefs = parsePreferencesMarkdown(raw);
+  const saved = prefs?.widget_mode;
+  if (saved && WIDGET_MODES.includes(saved as WidgetMode)) {
+    return saved as WidgetMode;
+  }
+  return undefined;
+}
+
+function resolveWidgetModePreferencePath(
+  projectPath = getProjectGSDPreferencesPath(),
+  globalPath = getGlobalGSDPreferencesPath(),
+): string {
+  if (readWidgetModeFromFile(projectPath)) {
+    return projectPath;
+  }
+
+  if (readWidgetModeFromFile(globalPath)) {
+    return globalPath;
+  }
+
+  if (safeReadTextFile(projectPath) !== null) return projectPath;
+  if (safeReadTextFile(globalPath) !== null) return globalPath;
+  return getGlobalGSDPreferencesPath();
+}
 
 /** Load widget mode from preferences (once). */
-function ensureWidgetModeLoaded(): void {
+function ensureWidgetModeLoaded(projectPath?: string, globalPath?: string): void {
   if (widgetModeInitialized) return;
   widgetModeInitialized = true;
   try {
-    const loaded = loadEffectiveGSDPreferences();
-    const saved = loaded?.preferences?.widget_mode;
+    const resolvedProjectPath = projectPath ?? getProjectGSDPreferencesPath();
+    const resolvedGlobalPath = globalPath ?? getGlobalGSDPreferencesPath();
+    const saved = readWidgetModeFromFile(resolvedProjectPath) ?? readWidgetModeFromFile(resolvedGlobalPath);
     if (saved && WIDGET_MODES.includes(saved as WidgetMode)) {
       widgetMode = saved as WidgetMode;
     }
+    widgetModePreferencePath = resolveWidgetModePreferencePath(resolvedProjectPath, resolvedGlobalPath);
   } catch (err) { /* non-fatal — use default */
-    logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+    logWarning("dashboard", `operation failed: ${getErrorMessage(err)}`);
+    widgetModePreferencePath = getGlobalGSDPreferencesPath();
   }
 }
 
-/** Persist widget mode to global preferences YAML. */
-function persistWidgetMode(mode: WidgetMode): void {
+/**
+ * Persist widget mode to the preference file that owns the effective value.
+ * Project-scoped widget_mode wins over global; if neither scope defines it,
+ * we prefer an existing project preferences file and otherwise fall back to
+ * the global preferences file.
+ */
+function persistWidgetMode(
+  mode: WidgetMode,
+  prefsPath = widgetModePreferencePath ?? resolveWidgetModePreferencePath(),
+): void {
   try {
-    const prefsPath = getGlobalGSDPreferencesPath();
     let content = "";
     if (existsSync(prefsPath)) {
       content = readFileSync(prefsPath, "utf-8");
@@ -408,26 +461,34 @@ function persistWidgetMode(mode: WidgetMode): void {
 }
 
 /** Cycle to the next widget mode. Returns the new mode. */
-export function cycleWidgetMode(): WidgetMode {
-  ensureWidgetModeLoaded();
+export function cycleWidgetMode(projectPath?: string, globalPath?: string): WidgetMode {
+  ensureWidgetModeLoaded(projectPath, globalPath);
   const idx = WIDGET_MODES.indexOf(widgetMode);
   widgetMode = WIDGET_MODES[(idx + 1) % WIDGET_MODES.length];
-  persistWidgetMode(widgetMode);
+  persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
   return widgetMode;
 }
 
 /** Set widget mode directly. */
-export function setWidgetMode(mode: WidgetMode): void {
+export function setWidgetMode(mode: WidgetMode, projectPath?: string, globalPath?: string): void {
+  ensureWidgetModeLoaded(projectPath, globalPath);
   widgetMode = mode;
-  persistWidgetMode(widgetMode);
+  persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
 }
 
 /** Get current widget mode. */
-export function getWidgetMode(): WidgetMode {
-  ensureWidgetModeLoaded();
+export function getWidgetMode(projectPath?: string, globalPath?: string): WidgetMode {
+  ensureWidgetModeLoaded(projectPath, globalPath);
   return widgetMode;
 }
 
+/** Test-only reset for widget mode caching. */
+export function _resetWidgetModeForTests(): void {
+  widgetMode = "full";
+  widgetModeInitialized = false;
+  widgetModePreferencePath = null;
+}
+
 // ─── Progress Widget ──────────────────────────────────────────────────────────
 
 /** State accessors passed to updateProgressWidget to avoid direct global access */
@@ -901,4 +962,3 @@ function padToWidth(s: string, colWidth: number): string {
   if (vis >= colWidth) return truncateToWidth(s, colWidth, "…");
   return s + " ".repeat(colWidth - vis);
 }
-

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -379,40 +379,8 @@ export const DISPATCH_RULES: DispatchRule[] = [
     },
   },
   {
-    name: "planning (no research, not S01) → research-slice",
-    match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      if (state.phase !== "planning") return null;
-      // Phase skip: skip research when preference or profile says so
-      if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
-        return null;
-      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
-      const sid = state.activeSlice!.id;
-      const sTitle = state.activeSlice!.title;
-      const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
-      if (researchFile) return null; // has research, fall through
-      // Skip slice research for S01 when milestone research already exists —
-      // the milestone research already covers the same ground for the first slice.
-      const milestoneResearchFile = resolveMilestoneFile(
-        basePath,
-        mid,
-        "RESEARCH",
-      );
-      if (milestoneResearchFile && sid === "S01") return null; // fall through to plan-slice
-      return {
-        action: "dispatch",
-        unitType: "research-slice",
-        unitId: `${mid}/${sid}`,
-        prompt: await buildResearchSlicePrompt(
-          mid,
-          midTitle,
-          sid,
-          sTitle,
-          basePath,
-        ),
-      };
-    },
-  },
-  {
+    // Keep this rule before the single-slice research rule so the multi-slice
+    // path wins whenever 2+ slices are ready.
     name: "planning (multiple slices need research) → parallel-research-slices",
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
       if (state.phase !== "planning") return null;
@@ -459,6 +427,40 @@ export const DISPATCH_RULES: DispatchRule[] = [
       };
     },
   },
+  {
+    name: "planning (no research, not S01) → research-slice",
+    match: async ({ state, mid, midTitle, basePath, prefs }) => {
+      if (state.phase !== "planning") return null;
+      // Phase skip: skip research when preference or profile says so
+      if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
+        return null;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
+      const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+      if (researchFile) return null; // has research, fall through
+      // Skip slice research for S01 when milestone research already exists —
+      // the milestone research already covers the same ground for the first slice.
+      const milestoneResearchFile = resolveMilestoneFile(
+        basePath,
+        mid,
+        "RESEARCH",
+      );
+      if (milestoneResearchFile && sid === "S01") return null; // fall through to plan-slice
+      return {
+        action: "dispatch",
+        unitType: "research-slice",
+        unitId: `${mid}/${sid}`,
+        prompt: await buildResearchSlicePrompt(
+          mid,
+          midTitle,
+          sid,
+          sTitle,
+          basePath,
+        ),
+      };
+    },
+  },
   {
     name: "planning → plan-slice",
     match: async ({ state, mid, midTitle, basePath }) => {
@@ -883,4 +885,3 @@ export async function resolveDispatch(
 export function getDispatchRuleNames(): string[] {
   return DISPATCH_RULES.map((r) => r.name);
 }
-

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -1592,7 +1592,7 @@ export async function buildValidateMilestonePrompt(
     logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 
-  // Inline all slice summaries and UAT results
+  // Inline all slice summaries and assessment results
   let valSliceIds: string[] = [];
   try {
     const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
@@ -1617,10 +1617,10 @@ export async function buildValidateMilestonePrompt(
     const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
     inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
 
-    const uatPath = resolveSliceFile(base, mid, sid, "UAT");
-    const uatRel = relSliceFile(base, mid, sid, "UAT");
-    const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
-    if (uatInline) inlined.push(uatInline);
+    const assessmentPath = resolveSliceFile(base, mid, sid, "ASSESSMENT");
+    const assessmentRel = relSliceFile(base, mid, sid, "ASSESSMENT");
+    const assessmentInline = await inlineFileOptional(assessmentPath, assessmentRel, `${sid} Assessment`);
+    if (assessmentInline) inlined.push(assessmentInline);
   }
 
   // Aggregate unresolved follow-ups and known limitations across slices
@@ -2150,4 +2150,3 @@ export async function buildRewriteDocsPrompt(
     overridesPath: relGsdRootFile("OVERRIDES"),
   });
 }
-

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -13,7 +13,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -248,8 +248,7 @@ export function verifyExpectedArtifact(
     if (gateIds.length === 0) return true;
 
     try {
-      const { getPendingGates: getPending } = require("./gsd-db.js");
-      const pending = getPending(mid, sid, "slice");
+      const pending = getPendingGates(mid, sid, "slice");
       const pendingIds = new Set(pending.map((g: any) => g.gate_id));
       // All dispatched gates must no longer be pending
       for (const gid of gateIds) {
@@ -480,22 +479,23 @@ function abortAndResetMerge(
   }
 }
 
+export type MergeReconcileResult = "clean" | "reconciled" | "blocked";
+
 /**
  * Detect leftover merge state from a prior session and reconcile it.
  * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
- * If resolved: finalize the commit. If still conflicted: abort and reset.
- *
- * Returns true if state was dirty and re-derivation is needed.
+ * If resolved: finalize the commit. If only .gsd conflicts remain: auto-resolve.
+ * If code conflicts remain: fail safe without modifying the worktree.
  */
 export function reconcileMergeState(
   basePath: string,
   ctx: ExtensionContext,
-): boolean {
+): MergeReconcileResult {
   const mergeHeadPath = join(basePath, ".git", "MERGE_HEAD");
   const squashMsgPath = join(basePath, ".git", "SQUASH_MSG");
   const hasMergeHead = existsSync(mergeHeadPath);
   const hasSquashMsg = existsSync(squashMsgPath);
-  if (!hasMergeHead && !hasSquashMsg) return false;
+  if (!hasMergeHead && !hasSquashMsg) return "clean";
 
   const conflictedFiles = nativeConflictFiles(basePath);
   if (conflictedFiles.length === 0) {
@@ -511,7 +511,7 @@ export function reconcileMergeState(
     } catch (err) {
       const errorMessage = getErrorMessage(err);
       ctx.ui.notify(`Failed to finalize leftover merge/squash commit: ${errorMessage}`, "error");
-      return false;
+      return "blocked";
     }
   } else {
     // Still conflicted — try auto-resolving .gsd/ state file conflicts (#530)
@@ -551,15 +551,16 @@ export function reconcileMergeState(
         );
       }
     } else {
-      // Code conflicts present — abort and reset
-      abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
+      // Code conflicts present — fail safe and preserve any manual resolution
+      // work instead of discarding it with merge --abort/reset --hard.
       ctx.ui.notify(
-        "Detected leftover merge state with unresolved conflicts — cleaned up. Re-deriving state.",
-        "warning",
+        "Detected leftover merge state with unresolved code conflicts. Auto-mode will pause without modifying the worktree so manual conflict resolution is preserved.",
+        "error",
       );
+      return "blocked";
     }
   }
-  return true;
+  return "reconciled";
 }
 
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
@@ -618,4 +619,3 @@ export function buildLoopRemediationSteps(
   }
   return null;
 }
-

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -7,6 +7,16 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
+import { getErrorMessage } from "../error-utils.js";
+import { shouldBlockContextArtifactSave } from "./write-gate.js";
+
+const SUPPORTED_SUMMARY_ARTIFACT_TYPES = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT"] as const;
+
+export function isSupportedSummaryArtifactType(
+  artifactType: string,
+): artifactType is (typeof SUPPORTED_SUMMARY_ARTIFACT_TYPES)[number] {
+  return (SUPPORTED_SUMMARY_ARTIFACT_TYPES as readonly string[]).includes(artifactType);
+}
 
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
@@ -283,13 +293,23 @@ export function registerDbTools(pi: ExtensionAPI): void {
         details: { operation: "save_summary", error: "db_unavailable" } as any,
       };
     }
-    const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
-    if (!validTypes.includes(params.artifact_type)) {
+    if (!isSupportedSummaryArtifactType(params.artifact_type)) {
       return {
-        content: [{ type: "text" as const, text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+        content: [{ type: "text" as const, 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" } as any,
       };
     }
+    const contextGuard = shouldBlockContextArtifactSave(
+      params.artifact_type,
+      params.milestone_id ?? null,
+      params.slice_id ?? null,
+    );
+    if (contextGuard.block) {
+      return {
+        content: [{ type: "text" as const, text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
+        details: { operation: "save_summary", error: "context_write_blocked" } as any,
+      };
+    }
     try {
       let relativePath: string;
       if (params.task_id && params.slice_id) {
@@ -333,16 +353,17 @@ export function registerDbTools(pi: ExtensionAPI): void {
       "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/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -6,7 +6,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";
@@ -24,6 +24,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).
@@ -39,6 +40,7 @@ export function registerHooks(pi: ExtensionAPI): void {
     initNotificationStore(process.cwd());
     installNotifyInterceptor(ctx);
     initNotificationWidget(ctx);
+    initHealthWidget(ctx);
     resetWriteGateState();
     resetToolCallLoopGuard();
     resetAskUserQuestionsCache();
@@ -162,12 +164,50 @@ export function registerHooks(pi: ExtensionAPI): void {
   });
 
   pi.on("tool_call", async (event) => {
+    const discussionBasePath = process.cwd();
     // ── Loop guard: block repeated identical tool calls ──
     const loopCheck = checkToolCallLoop(event.toolName, event.input as Record<string, unknown>);
     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: any[] = (event.input as any)?.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
@@ -210,8 +250,7 @@ export function registerHooks(pi: ExtensionAPI): void {
     const result = shouldBlockContextWrite(
       event.toolName,
       event.input.path,
-      getDiscussionMilestoneId(),
-      isDepthVerified(),
+      getDiscussionMilestoneId(discussionBasePath),
       isQueuePhaseActive(),
     );
     if (result.block) return result;
@@ -239,21 +278,43 @@ export function registerHooks(pi: ExtensionAPI): void {
 
   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 as any;
-    if (details?.cancelled || !details?.response) return;
 
+    // ── 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: any[] = (event.input as any)?.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;
+
     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/src/resources/extensions/gsd/bootstrap/register-shortcuts.ts

@@ -7,18 +7,20 @@ 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: ExtensionAPI): void {
   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<void>(
-        (tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()),
+      await ctx.ui.custom<boolean>(
+        (tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)),
         {
           overlay: true,
           overlayOptions: {
@@ -35,8 +37,8 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   pi.registerShortcut(Key.ctrlAlt("n"), {
     description: shortcutDesc("Open notification history", "/gsd notifications"),
     handler: async (ctx) => {
-      await ctx.ui.custom<void>(
-        (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()),
+      await ctx.ui.custom<boolean>(
+        (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)),
         {
           overlay: true,
           overlayOptions: {
@@ -54,13 +56,14 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   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<void>(
-        (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done()),
+      await ctx.ui.custom<boolean>(
+        (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(true)),
         {
           overlay: true,
           overlayOptions: {