gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -1,3 +1,6 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
 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;
@@ -65,6 +68,69 @@ const GATE_SAFE_TOOLS = new Set([
   "search_and_read",
 ]);
 
+export interface WriteGateSnapshot {
+  verifiedDepthMilestones: string[];
+  activeQueuePhase: boolean;
+  pendingGateId: string | null;
+}
+
+function shouldPersistWriteGateSnapshot(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.GSD_PERSIST_WRITE_GATE_STATE === "1";
+}
+
+function writeGateSnapshotPath(basePath: string = process.cwd()): string {
+  return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+}
+
+function currentWriteGateSnapshot(): WriteGateSnapshot {
+  return {
+    verifiedDepthMilestones: [...verifiedDepthMilestones].sort(),
+    activeQueuePhase,
+    pendingGateId,
+  };
+}
+
+function persistWriteGateSnapshot(basePath: string = process.cwd()): void {
+  if (!shouldPersistWriteGateSnapshot()) return;
+  const path = writeGateSnapshotPath(basePath);
+  mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+  const tempPath = `${path}.tmp`;
+  writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(), null, 2), "utf-8");
+  renameSync(tempPath, path);
+}
+
+function clearPersistedWriteGateSnapshot(basePath: string = process.cwd()): void {
+  if (!shouldPersistWriteGateSnapshot()) return;
+  const path = writeGateSnapshotPath(basePath);
+  try {
+    unlinkSync(path);
+  } catch {
+    // swallow
+  }
+}
+
+function normalizeWriteGateSnapshot(value: unknown): WriteGateSnapshot {
+  const record = value && typeof value === "object" ? value as Record<string, unknown> : {};
+  const verified = Array.isArray(record.verifiedDepthMilestones)
+    ? record.verifiedDepthMilestones.filter((item): item is string => typeof item === "string")
+    : [];
+  return {
+    verifiedDepthMilestones: [...new Set(verified)].sort(),
+    activeQueuePhase: record.activeQueuePhase === true,
+    pendingGateId: typeof record.pendingGateId === "string" ? record.pendingGateId : null,
+  };
+}
+
+export function loadWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSnapshot {
+  const path = writeGateSnapshotPath(basePath);
+  if (!existsSync(path)) return currentWriteGateSnapshot();
+  try {
+    return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return currentWriteGateSnapshot();
+  }
+}
+
 export function isDepthVerified(): boolean {
   return verifiedDepthMilestones.size > 0;
 }
@@ -77,28 +143,40 @@ export function isMilestoneDepthVerified(milestoneId: string | null | undefined)
   return verifiedDepthMilestones.has(milestoneId);
 }
 
+export function isMilestoneDepthVerifiedInSnapshot(
+  snapshot: WriteGateSnapshot,
+  milestoneId: string | null | undefined,
+): boolean {
+  if (!milestoneId) return false;
+  return snapshot.verifiedDepthMilestones.includes(milestoneId);
+}
+
 export function isQueuePhaseActive(): boolean {
   return activeQueuePhase;
 }
 
 export function setQueuePhaseActive(active: boolean): void {
   activeQueuePhase = active;
+  persistWriteGateSnapshot();
 }
 
 export function resetWriteGateState(): void {
   verifiedDepthMilestones.clear();
   pendingGateId = null;
+  persistWriteGateSnapshot();
 }
 
 export function clearDiscussionFlowState(): void {
   verifiedDepthMilestones.clear();
   activeQueuePhase = false;
   pendingGateId = null;
+  clearPersistedWriteGateSnapshot();
 }
 
-export function markDepthVerified(milestoneId?: string | null): void {
+export function markDepthVerified(milestoneId?: string | null, basePath: string = process.cwd()): void {
   if (!milestoneId) return;
   verifiedDepthMilestones.add(milestoneId);
+  persistWriteGateSnapshot(basePath);
 }
 
 /**
@@ -130,6 +208,7 @@ function extractContextMilestoneId(inputPath: string): string | null {
  */
 export function setPendingGate(gateId: string): void {
   pendingGateId = gateId;
+  persistWriteGateSnapshot();
 }
 
 /**
@@ -137,6 +216,7 @@ export function setPendingGate(gateId: string): void {
  */
 export function clearPendingGate(): void {
   pendingGateId = null;
+  persistWriteGateSnapshot();
 }
 
 /**
@@ -154,11 +234,20 @@ export function getPendingGate(): string | null {
  * Read-only tools and ask_user_questions itself are always allowed.
  */
 export function shouldBlockPendingGate(
+  toolName: string,
+  milestoneId: string | null,
+  queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+}
+
+export function shouldBlockPendingGateInSnapshot(
+  snapshot: WriteGateSnapshot,
   toolName: string,
   _milestoneId: string | null,
   _queuePhaseActive?: boolean,
 ): { block: boolean; reason?: string } {
-  if (!pendingGateId) return { block: false };
+  if (!snapshot.pendingGateId) return { block: false };
 
   if (GATE_SAFE_TOOLS.has(toolName)) return { block: false };
 
@@ -168,7 +257,7 @@ export function shouldBlockPendingGate(
   return {
     block: true,
     reason: [
-      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `HARD BLOCK: Discussion gate "${snapshot.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.`,
@@ -182,11 +271,20 @@ export function shouldBlockPendingGate(
  * Read-only bash commands are allowed; mutating commands are blocked.
  */
 export function shouldBlockPendingGateBash(
+  command: string,
+  milestoneId: string | null,
+  queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+}
+
+export function shouldBlockPendingGateBashInSnapshot(
+  snapshot: WriteGateSnapshot,
   command: string,
   _milestoneId: string | null,
   _queuePhaseActive?: boolean,
 ): { block: boolean; reason?: string } {
-  if (!pendingGateId) return { block: false };
+  if (!snapshot.pendingGateId) return { block: false };
 
   // Allow read-only bash commands
   if (BASH_READ_ONLY_RE.test(command)) return { block: false };
@@ -194,7 +292,7 @@ export function shouldBlockPendingGateBash(
   return {
     block: true,
     reason: [
-      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `HARD BLOCK: Discussion gate "${snapshot.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.`,
@@ -275,6 +373,15 @@ export function shouldBlockContextArtifactSave(
   artifactType: string,
   milestoneId: string | null,
   sliceId?: string | null,
+): { block: boolean; reason?: string } {
+  return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+}
+
+export function shouldBlockContextArtifactSaveInSnapshot(
+  snapshot: WriteGateSnapshot,
+  artifactType: string,
+  milestoneId: string | null,
+  sliceId?: string | null,
 ): { block: boolean; reason?: string } {
   if (artifactType !== "CONTEXT") return { block: false };
   if (sliceId) return { block: false };
@@ -287,7 +394,7 @@ export function shouldBlockContextArtifactSave(
       ].join(" "),
     };
   }
-  if (isMilestoneDepthVerified(milestoneId)) return { block: false };
+  if (isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId)) return { block: false };
 
   return {
     block: true,
@@ -317,6 +424,15 @@ export function shouldBlockQueueExecution(
   toolName: string,
   input: string,
   queuePhaseActive: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockQueueExecutionInSnapshot(currentWriteGateSnapshot(), toolName, input, queuePhaseActive);
+}
+
+export function shouldBlockQueueExecutionInSnapshot(
+  snapshot: WriteGateSnapshot,
+  toolName: string,
+  input: string,
+  queuePhaseActive: boolean = snapshot.activeQueuePhase,
 ): { block: boolean; reason?: string } {
   if (!queuePhaseActive) return { block: false };
 

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -70,7 +70,7 @@ export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "templates", desc: "List available workflow templates" },
   { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
   { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
-  { cmd: "mcp", desc: "MCP server status and connectivity check (status, check <server>)" },
+  { cmd: "mcp", desc: "MCP server status, connectivity, and local config bootstrap (status, check, init)" },
   { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
   { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
   { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
@@ -201,6 +201,7 @@ const NESTED_COMPLETIONS: CompletionMap = {
   mcp: [
     { cmd: "status", desc: "Show all MCP server statuses (default)" },
     { cmd: "check", desc: "Detailed status for a specific server" },
+    { cmd: "init", desc: "Write .mcp.json for the local GSD workflow MCP server" },
   ],
   doctor: [
     { cmd: "fix", desc: "Auto-fix detected issues" },

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -60,7 +60,7 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  /gsd hooks          Show post-unit hook configuration",
     "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
     "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
-    "  /gsd mcp            MCP server status and connectivity  [status|check <server>]",
+    "  /gsd mcp            MCP server status and connectivity  [status|check <server>|init [dir]]",
     "",
     "MAINTENANCE",
     "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",
@@ -194,6 +194,56 @@ function sortModelsForSelection(models: Model<any>[], currentModel: Model<any> |
   });
 }
 
+function buildProviderModelGroups(
+  models: Model<any>[],
+  currentModel: Model<any> | undefined,
+): Map<string, Model<any>[]> {
+  const byProvider = new Map<string, Model<any>[]>();
+
+  for (const model of sortModelsForSelection(models, currentModel)) {
+    let group = byProvider.get(model.provider);
+    if (!group) {
+      group = [];
+      byProvider.set(model.provider, group);
+    }
+    group.push(model);
+  }
+  return byProvider;
+}
+
+async function selectModelByProvider(
+  title: string,
+  models: Model<any>[],
+  ctx: ExtensionCommandContext,
+  currentModel: Model<any> | undefined,
+): Promise<Model<any> | undefined> {
+  const byProvider = buildProviderModelGroups(models, currentModel);
+  const providerOptions = Array.from(byProvider.entries()).map(([provider, group]) =>
+    `${provider} (${group.length} model${group.length === 1 ? "" : "s"})`,
+  );
+  providerOptions.push("(cancel)");
+
+  const providerChoice = await ctx.ui.select(`${title} — choose provider:`, providerOptions);
+  if (!providerChoice || typeof providerChoice !== "string" || providerChoice === "(cancel)") return undefined;
+
+  const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+  const providerModels = byProvider.get(providerName);
+  if (!providerModels || providerModels.length === 0) return undefined;
+
+  const optionToModel = new Map<string, Model<any>>();
+  const modelOptions = providerModels.map((model) => {
+    const isCurrent = currentModel && model.provider === currentModel.provider && model.id === currentModel.id;
+    const label = `${isCurrent ? "* " : ""}${model.id}`;
+    optionToModel.set(label, model);
+    return label;
+  });
+  modelOptions.push("(cancel)");
+
+  const modelChoice = await ctx.ui.select(`${title} — ${providerName}:`, modelOptions);
+  if (!modelChoice || typeof modelChoice !== "string" || modelChoice === "(cancel)") return undefined;
+  return optionToModel.get(modelChoice);
+}
+
 async function resolveRequestedModel(
   query: string,
   ctx: ExtensionCommandContext,
@@ -211,19 +261,7 @@ async function resolveRequestedModel(
 
   if (partialMatches.length === 1) return partialMatches[0];
   if (partialMatches.length === 0 || !ctx.hasUI) return undefined;
-
-  const sorted = sortModelsForSelection(partialMatches, ctx.model);
-  const optionToModel = new Map<string, Model<any>>();
-  const options = sorted.map((model) => {
-    const label = `${model.provider}/${model.id}`;
-    optionToModel.set(label, model);
-    return label;
-  });
-  options.push("(cancel)");
-
-  const choice = await ctx.ui.select(`Multiple models match "${query}" — choose one:`, options);
-  if (!choice || typeof choice !== "string" || choice === "(cancel)") return undefined;
-  return optionToModel.get(choice);
+  return selectModelByProvider(`Multiple models match "${query}"`, partialMatches, ctx, ctx.model);
 }
 
 async function handleModel(trimmedArgs: string, ctx: ExtensionCommandContext, pi: ExtensionAPI | undefined): Promise<void> {
@@ -247,18 +285,7 @@ async function handleModel(trimmedArgs: string, ctx: ExtensionCommandContext, pi
       return;
     }
 
-    const optionToModel = new Map<string, Model<any>>();
-    const options = sortModelsForSelection(availableModels, ctx.model).map((model) => {
-      const isCurrent = ctx.model && model.provider === ctx.model.provider && model.id === ctx.model.id;
-      const label = `${isCurrent ? "* " : ""}${model.provider}/${model.id}`;
-      optionToModel.set(label, model);
-      return label;
-    });
-    options.push("(cancel)");
-
-    const choice = await ctx.ui.select("Select session model:", options);
-    if (!choice || typeof choice !== "string" || choice === "(cancel)") return;
-    targetModel = optionToModel.get(choice);
+    targetModel = await selectModelByProvider("Select session model:", availableModels, ctx, ctx.model);
   } else {
     targetModel = await resolveRequestedModel(trimmed, ctx);
   }

package/src/resources/extensions/gsd/commands/index.ts

@@ -8,7 +8,13 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
     getArgumentCompletions: getGsdArgumentCompletions,
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       const { handleGSDCommand } = await import("./dispatcher.js");
-      await handleGSDCommand(args, ctx, pi);
+      const { setStderrLoggingEnabled } = await import("../workflow-logger.js");
+      const previousStderrSetting = setStderrLoggingEnabled(false);
+      try {
+        await handleGSDCommand(args, ctx, pi);
+      } finally {
+        setStderrLoggingEnabled(previousStderrSetting);
+      }
     },
   });
 }

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -7,12 +7,15 @@
  *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
  *   /gsd mcp status      — Same as bare /gsd mcp
  *   /gsd mcp check <srv> — Detailed status for a specific server
+ *   /gsd mcp init [dir]  — Write project-local GSD workflow MCP config
  */
 
 import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+
+import { ensureProjectWorkflowMcpConfig } from "./mcp-project-config.js";
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -28,6 +31,28 @@ export interface McpServerDetail extends McpServerStatus {
   tools: string[];
 }
 
+export function formatMcpInitResult(
+  status: "created" | "updated" | "unchanged",
+  configPath: string,
+  targetPath: string,
+): string {
+  const summary =
+    status === "created"
+      ? "Created project MCP config."
+      : status === "updated"
+        ? "Updated project MCP config."
+        : "Project MCP config is already up to date.";
+
+  return [
+    summary,
+    "",
+    `Project: ${targetPath}`,
+    `Config:   ${configPath}`,
+    "",
+    "Claude Code can now load the GSD workflow MCP server from this folder.",
+  ].join("\n");
+}
+
 // ─── Config reader (standalone — does not import mcp-client internals) ──────
 
 interface McpServerRawConfig {
@@ -94,6 +119,7 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
       "No MCP servers configured.",
       "",
       "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+      "Tip: run /gsd mcp init . to write the local GSD workflow MCP config.",
       "See: https://modelcontextprotocol.io/quickstart",
     ].join("\n");
   }
@@ -153,12 +179,31 @@ export async function handleMcpStatus(
   args: string,
   ctx: ExtensionCommandContext,
 ): Promise<void> {
-  const trimmed = args.trim().toLowerCase();
+  const trimmed = args.trim();
+  const lowered = trimmed.toLowerCase();
   const configs = readMcpConfigs();
 
+  // /gsd mcp init [dir]
+  if (!lowered || lowered === "status") {
+    // handled below
+  } else if (lowered === "init" || lowered.startsWith("init ")) {
+    const rawPath = trimmed.slice("init".length).trim();
+    const targetPath = resolve(rawPath || ".");
+    try {
+      const result = ensureProjectWorkflowMcpConfig(targetPath);
+      ctx.ui.notify(formatMcpInitResult(result.status, result.configPath, targetPath), "info");
+    } catch (err) {
+      ctx.ui.notify(
+        `Failed to prepare MCP config for ${targetPath}: ${err instanceof Error ? err.message : String(err)}`,
+        "error",
+      );
+    }
+    return;
+  }
+
   // /gsd mcp check <server>
-  if (trimmed.startsWith("check ")) {
-    const serverName = args.trim().slice("check ".length).trim();
+  if (lowered.startsWith("check ")) {
+    const serverName = trimmed.slice("check ".length).trim();
     const config = configs.find((c) => c.name === serverName);
     if (!config) {
       const available = configs.map((c) => c.name).join(", ") || "(none)";
@@ -202,7 +247,7 @@ export async function handleMcpStatus(
   }
 
   // /gsd mcp or /gsd mcp status
-  if (!trimmed || trimmed === "status") {
+  if (!lowered || lowered === "status") {
     // Build status for each server
     const statuses: McpServerStatus[] = [];
 
@@ -239,9 +284,10 @@ export async function handleMcpStatus(
 
   // Unknown subcommand
   ctx.ui.notify(
-    "Usage: /gsd mcp [status|check <server>]\n\n" +
+    "Usage: /gsd mcp [status|check <server>|init [dir]]\n\n" +
     "  status           Show all MCP server statuses (default)\n" +
-    "  check <server>   Detailed status for a specific server",
+    "  check <server>   Detailed status for a specific server\n" +
+    "  init [dir]       Write .mcp.json for the local GSD workflow MCP server",
     "warning",
   );
 }

package/src/resources/extensions/gsd/doctor-git-checks.ts

@@ -10,7 +10,7 @@ import { deriveState, isMilestoneComplete } from "./state.js";
 import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 
@@ -386,19 +386,19 @@ export async function checkGitHealth(
             code: "stale_uncommitted_changes",
             scope: "project",
             unitId: "project",
-            message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting uncommitted changes.`,
+            message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting tracked files.`,
             fixable: true,
           });
 
           if (shouldFix("stale_uncommitted_changes")) {
             try {
-              nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
+              nativeAddTracked(basePath);
               const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
               const result = nativeCommit(basePath, commitMsg);
               if (result) {
                 fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
               } else {
-                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging changes");
+                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
               }
             } catch {
               fixesApplied.push("failed to create gsd snapshot commit");

package/src/resources/extensions/gsd/doctor-proactive.ts

@@ -21,8 +21,8 @@ import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.j
 import { abortAndReset } from "./git-self-heal.js";
 import { rebuildState } from "./doctor.js";
 import { deriveState } from "./state.js";
-import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
+import { resolveMilestoneIntegrationBranch } from "./git-service.js";
+import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 
@@ -312,7 +312,7 @@ export async function preDispatchHealthGate(basePath: string): Promise<PreDispat
         if (minutesSinceCommit >= thresholdMinutes) {
           const mins = Math.floor(minutesSinceCommit);
           try {
-            nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
+            nativeAddTracked(basePath);
             const commitMsg = `gsd snapshot: pre-dispatch, uncommitted changes after ${mins}m inactivity`;
             const result = nativeCommit(basePath, commitMsg);
             if (result) {

package/src/resources/extensions/gsd/doctor.ts

@@ -8,6 +8,7 @@ import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSl
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences, type GSDPreferences } from "./preferences.js";
+import { isClosedStatus } from "./status-guards.js";
 
 import type { DoctorIssue, DoctorIssueCode, DoctorReport } from "./doctor-types.js";
 import { GLOBAL_STATE_CODES } from "./doctor-types.js";
@@ -474,15 +475,16 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
     if (!roadmapContent) continue;
 
     // Normalize slices: prefer DB, fall back to parser
-    type NormSlice = RoadmapSliceEntry & { pending?: boolean };
+    type NormSlice = RoadmapSliceEntry & { pending?: boolean; skipped?: boolean };
     let slices: NormSlice[];
     if (isDbAvailable()) {
       const dbSlices = getMilestoneSlices(milestoneId);
       slices = dbSlices.map(s => ({
         id: s.id,
         title: s.title,
-        done: s.status === "complete",
+        done: isClosedStatus(s.status),
         pending: s.status === "pending",
+        skipped: s.status === "skipped",
         risk: (s.risk || "medium") as RoadmapSliceEntry["risk"],
         depends: s.depends,
         demo: s.demo,
@@ -578,8 +580,9 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
       const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
       if (!slicePath) {
         // Pending slices haven't been planned yet — directories are created
-        // lazily by ensurePreconditions() at dispatch time. Skip them.
-        if (slice.pending) continue;
+        // lazily by ensurePreconditions() at dispatch time. Skipped slices are
+        // intentionally allowed to remain summary-less and directory-less.
+        if (slice.pending || slice.skipped) continue;
         const expectedPath = relSlicePath(basePath, milestoneId, slice.id);
         issues.push({
           severity: slice.done ? "warning" : "error",
@@ -603,7 +606,8 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
       const tasksDir = resolveTasksDir(basePath, milestoneId, slice.id);
       if (!tasksDir) {
         // Pending slices haven't been planned yet — tasks/ is created on demand.
-        if (slice.pending) continue;
+        // Skipped slices may legitimately never create tasks/.
+        if (slice.pending || slice.skipped) continue;
         issues.push({
           severity: slice.done ? "warning" : "error",
           code: "missing_tasks_dir",

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

@@ -778,6 +778,7 @@ let currentDb: DbAdapter | null = null;
 let currentPath: string | null = null;
 let currentPid: number = 0;
 let _exitHandlerRegistered = false;
+let _dbOpenAttempted = false;
 
 export function getDbProvider(): ProviderName | null {
   loadProvider();
@@ -788,7 +789,18 @@ export function isDbAvailable(): boolean {
   return currentDb !== null;
 }
 
+/**
+ * Returns true if openDatabase() has been called at least once this session.
+ * Used to distinguish "DB not yet initialized" from "DB genuinely unavailable"
+ * so that early callers (e.g. before_agent_start context injection) don't
+ * trigger a false degraded-mode warning.
+ */
+export function wasDbOpenAttempted(): boolean {
+  return _dbOpenAttempted;
+}
+
 export function openDatabase(path: string): boolean {
+  _dbOpenAttempted = true;
   if (currentDb && currentPath !== path) closeDatabase();
   if (currentDb && currentPath === path) return true;