@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -1,7 +1,7 @@
 // gsd-pi - Claude Code stream adapter regression tests
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import {
@@ -33,6 +33,8 @@ import {
 	resolveBundledClaudeCliPath,
 	normalizeClaudePathForSdk,
 	roundResultToElicitationContent,
+	autoInitClaudeCodeWorkflowMcp,
+	inferGsdPhaseFromContext,
 } from "../stream-adapter.ts";
 import type { AssistantMessage, Context, Message } from "@gsd/pi-ai";
 import type { SDKUserMessage } from "../sdk-types.ts";
@@ -794,6 +796,11 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal(options.persistSession, true, "persistSession must default to true");
 	});
 
+	test("buildSdkOptions loads project and local settings so approved .mcp.json servers are active", () => {
+		const options = buildSdkOptions("claude-sonnet-4-20250514", "test prompt");
+		assert.deepEqual(options.settingSources, ["project", "local"]);
+	});
+
 	test("buildSdkOptions sets model and prompt correctly", () => {
 		const options = buildSdkOptions("claude-sonnet-4-20250514", "hello world");
 		assert.equal(options.model, "claude-sonnet-4-20250514");
@@ -829,6 +836,29 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
+	test("autoInitClaudeCodeWorkflowMcp writes and approves project GSD MCP config", () => {
+		const projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "claude-sdk-auto-init-")));
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["server.js"]),
+			GSD_WORKFLOW_MCP_CWD: projectRoot,
+		});
+
+		try {
+			autoInitClaudeCodeWorkflowMcp(projectRoot);
+			assert.equal(existsSync(join(projectRoot, ".mcp.json")), true);
+
+			const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {
+				enabledMcpjsonServers?: string[];
+			};
+			assert.deepEqual(settings.enabledMcpjsonServers, ["gsd-workflow", "gsd-browser"]);
+		} finally {
+			restore();
+			rmSync(projectRoot, { recursive: true, force: true });
+		}
+	});
+
 	test("resolveClaudeCodeCwd falls back to process cwd when no stream cwd is provided", () => {
 		assert.equal(resolveClaudeCodeCwd(), process.cwd());
 		assert.equal(resolveClaudeCodeCwd({ cwd: "   " }), process.cwd());
@@ -1013,21 +1043,118 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-		test("buildSdkOptions prefers custom workflow MCP question tools over native AskUserQuestion", () => {
-			const restore = setWorkflowMcpEnv({
-				GSD_WORKFLOW_MCP_COMMAND: "node",
+	test("buildSdkOptions scopes run-uat to exact workflow MCP tools", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+		});
+		const originalCwd = process.cwd();
+		const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-uat-"));
+		try {
+			process.chdir(emptyDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { gsdPhase: "run-uat" });
+			const allowedTools = options.allowedTools as string[];
+			const disallowedTools = options.disallowedTools as string[];
+
+			assert.deepEqual(allowedTools, [
+				"Read",
+				"Glob",
+				"Grep",
+				"mcp__gsd-workflow__gsd_uat_exec",
+				"mcp__gsd-workflow__gsd_uat_result_save",
+				"mcp__gsd-workflow__gsd_resume",
+				"mcp__gsd-workflow__gsd_milestone_status",
+				"mcp__gsd-workflow__gsd_journal_query",
+				"mcp__gsd-browser__*",
+			]);
+			assert.ok(!allowedTools.includes("Bash"));
+			assert.ok(!allowedTools.includes("Write"));
+			assert.ok(!allowedTools.includes("Edit"));
+			assert.ok(!allowedTools.includes("WebSearch"));
+			assert.ok(!allowedTools.includes("mcp__gsd-workflow__*"));
+			assert.ok(disallowedTools.includes("Bash"));
+			assert.ok(disallowedTools.includes("Write"));
+			assert.ok(disallowedTools.includes("Edit"));
+			assert.ok(disallowedTools.includes("WebSearch"));
+			assert.ok(disallowedTools.includes("mcp__gsd-workflow__gsd_exec"));
+			assert.ok(disallowedTools.includes("mcp__gsd-workflow__gsd_summary_save"));
+			assert.ok(disallowedTools.includes("mcp__gsd-workflow__gsd_save_gate_result"));
+			assert.equal(options.strictMcpConfig, true);
+			assert.deepEqual(options.settingSources, []);
+			assert.ok((options.mcpServers as Record<string, unknown>)?.["gsd-workflow"]);
+			assert.ok((options.mcpServers as Record<string, unknown>)?.["gsd-browser"]);
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(emptyDir, { recursive: true, force: true });
+			restore();
+		}
+	});
+
+	test("buildSdkOptions presents exact required workflow MCP tools for non-UAT GSD phases", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+		});
+		const originalCwd = process.cwd();
+		const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-plan-"));
+		try {
+			process.chdir(emptyDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { gsdPhase: "plan-milestone" });
+			const allowedTools = options.allowedTools as string[];
+
+			assert.ok(
+				allowedTools.includes("mcp__gsd-workflow__gsd_plan_milestone"),
+				"plan-milestone must expose exact planning tool",
+			);
+			assert.ok(
+				allowedTools.includes("mcp__gsd-workflow__gsd_milestone_status"),
+				"plan-milestone must expose exact milestone status helper before ToolSearch is needed",
+			);
+			assert.ok(
+				allowedTools.includes("mcp__gsd-workflow__*"),
+				"non-UAT workflow phases keep the wildcard for existing broad workflow behavior",
+			);
+			assert.ok((options.disallowedTools as string[]).includes("AskUserQuestion"));
+			assert.equal(options.strictMcpConfig, true);
+			assert.ok((options.mcpServers as Record<string, unknown>)?.["gsd-workflow"]);
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(emptyDir, { recursive: true, force: true });
+			restore();
+		}
+	});
+
+	test("inferGsdPhaseFromContext recognizes non-UAT unit prompts", () => {
+		const context = {
+			messages: [
+				{ role: "user", content: "## UNIT: Plan Milestone M002 (\"Plan by Priority\")" },
+			],
+		} as Context;
+
+		assert.equal(inferGsdPhaseFromContext(context), "plan-milestone");
+	});
+
+	test("buildSdkOptions prefers custom workflow MCP question tools over native AskUserQuestion", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "custom-workflow",
 			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
-				GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
-				GSD_WORKFLOW_MCP_CWD: "/tmp/project",
-			});
-			const originalCwd = process.cwd();
-			const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-custom-inject-"));
-			try {
-				process.chdir(emptyDir);
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+		});
+		const originalCwd = process.cwd();
+		const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-custom-inject-"));
+		try {
+			process.chdir(emptyDir);
 
-				const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
-				const mcpServers = options.mcpServers as Record<string, any>;
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			const mcpServers = options.mcpServers as Record<string, any>;
 			assert.ok(mcpServers?.["custom-workflow"], "expected custom workflow server config");
 			assert.ok(mcpServers?.["gsd-browser"], "expected gsd-browser server config");
 			assert.deepEqual(options.disallowedTools, ["ToolSearch", "AskUserQuestion"]);
@@ -1041,15 +1168,15 @@ describe("stream-adapter — session persistence (#2859)", () => {
 				"Agent",
 				"WebFetch",
 				"WebSearch",
-					"mcp__custom-workflow__*",
-					"mcp__gsd-browser__*",
-				]);
-			} finally {
-				process.chdir(originalCwd);
-				rmSync(emptyDir, { recursive: true, force: true });
-				restore();
-			}
-		});
+				"mcp__custom-workflow__*",
+				"mcp__gsd-browser__*",
+			]);
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(emptyDir, { recursive: true, force: true });
+			restore();
+		}
+	});
 
 	test("buildSdkOptions auto-discovers bundled MCP server even without env hints", () => {
 		// Use setWorkflowMcpEnv with no values to save current state;
@@ -1162,7 +1289,41 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-		test("buildSdkOptions does not inject workflow MCP when already declared in project .mcp.json (avoids duplicate registration)", () => {
+	test("buildSdkOptions force-inlines workflow MCP for GSD phases when project .mcp.json already declares it", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+		});
+		const originalCwd = process.cwd();
+		const projectDir = mkdtempSync(join(tmpdir(), "claude-mcp-inline-project-"));
+		try {
+			writeFileSync(
+				join(projectDir, ".mcp.json"),
+				JSON.stringify({ mcpServers: { "gsd-workflow": { command: "node", args: ["old-cli.js"] }, "other-mcp": { command: "npx", args: ["other"] } } }),
+			);
+			process.chdir(projectDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { gsdPhase: "plan-milestone" });
+
+			assert.equal(options.strictMcpConfig, true);
+			assert.deepEqual(options.settingSources, []);
+			assert.deepEqual(options.mcpServers, {
+				"gsd-workflow": { command: "node", args: ["old-cli.js"] },
+			});
+			const allowedTools = options.allowedTools as string[];
+			assert.ok(allowedTools.includes("mcp__gsd-workflow__gsd_plan_milestone"));
+			assert.ok(allowedTools.includes("mcp__gsd-workflow__gsd_milestone_status"));
+			assert.ok(allowedTools.includes("mcp__gsd-workflow__*"));
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(projectDir, { recursive: true, force: true });
+			restore();
+		}
+	});
+
+	test("buildSdkOptions does not inject workflow MCP when already declared in project .mcp.json outside GSD phases", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
@@ -1194,50 +1355,65 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			process.chdir(originalCwd);
 			rmSync(projectDir, { recursive: true, force: true });
 			restore();
-			}
+		}
+	});
+
+	test("buildSdkOptions uses project-declared custom workflow MCP namespace", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
 		});
+		const originalCwd = process.cwd();
+		const projectDir = mkdtempSync(join(tmpdir(), "claude-mcp-custom-project-"));
+		try {
+			writeFileSync(
+				join(projectDir, ".mcp.json"),
+				JSON.stringify({
+					mcpServers: {
+						"custom-workflow": {
+							command: "node",
+							args: ["custom-cli.js"],
+							env: { GSD_WORKFLOW_PROJECT_ROOT: projectDir },
+						},
+					},
+				}),
+			);
+			process.chdir(projectDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.deepEqual(Object.keys(mcpServers), ["gsd-browser"], "should inject only browser when project declares a workflow server");
+			const allowedTools = options.allowedTools as string[];
+			assert.ok(allowedTools.includes("mcp__custom-workflow__*"), "allowedTools must use the project workflow namespace");
+			assert.ok(allowedTools.includes("mcp__gsd-browser__*"), "allowedTools must include default browser namespace");
+			assert.ok(!allowedTools.includes("mcp__gsd-workflow__*"), "allowedTools must not advertise the absent default namespace");
+			const disallowedTools = options.disallowedTools as string[];
+			assert.ok(disallowedTools.includes("AskUserQuestion"), "AskUserQuestion should be suppressed when workflow is available");
 
-		test("buildSdkOptions uses project-declared custom workflow MCP namespace", () => {
-			const restore = setWorkflowMcpEnv({
-				GSD_WORKFLOW_MCP_COMMAND: "node",
-				GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
-				GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
-				GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
-				GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+			const phaseOptions = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { gsdPhase: "plan-milestone" });
+			assert.equal(phaseOptions.strictMcpConfig, true);
+			assert.deepEqual(phaseOptions.settingSources, []);
+			assert.deepEqual(phaseOptions.mcpServers, {
+				"custom-workflow": {
+					command: "node",
+					args: ["custom-cli.js"],
+					env: { GSD_WORKFLOW_PROJECT_ROOT: projectDir },
+				},
 			});
-			const originalCwd = process.cwd();
-			const projectDir = mkdtempSync(join(tmpdir(), "claude-mcp-custom-project-"));
-			try {
-				writeFileSync(
-					join(projectDir, ".mcp.json"),
-					JSON.stringify({
-						mcpServers: {
-							"custom-workflow": {
-								command: "node",
-								args: ["custom-cli.js"],
-								env: { GSD_WORKFLOW_PROJECT_ROOT: projectDir },
-							},
-						},
-					}),
-				);
-				process.chdir(projectDir);
-				const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
-				const mcpServers = options.mcpServers as Record<string, any>;
-				assert.deepEqual(Object.keys(mcpServers), ["gsd-browser"], "should inject only browser when project declares a workflow server");
-				const allowedTools = options.allowedTools as string[];
-				assert.ok(allowedTools.includes("mcp__custom-workflow__*"), "allowedTools must use the project workflow namespace");
-				assert.ok(allowedTools.includes("mcp__gsd-browser__*"), "allowedTools must include default browser namespace");
-				assert.ok(!allowedTools.includes("mcp__gsd-workflow__*"), "allowedTools must not advertise the absent default namespace");
-				const disallowedTools = options.disallowedTools as string[];
-				assert.ok(disallowedTools.includes("AskUserQuestion"), "AskUserQuestion should be suppressed when workflow is available");
-			} finally {
-				process.chdir(originalCwd);
-				rmSync(projectDir, { recursive: true, force: true });
-				restore();
-			}
-		});
+			const phaseAllowedTools = phaseOptions.allowedTools as string[];
+			assert.ok(phaseAllowedTools.includes("mcp__custom-workflow__gsd_plan_milestone"));
+			assert.ok(phaseAllowedTools.includes("mcp__custom-workflow__gsd_milestone_status"));
+			assert.ok(!phaseAllowedTools.includes("mcp__gsd-workflow__*"));
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(projectDir, { recursive: true, force: true });
+			restore();
+		}
+	});
 
-		test("buildSdkOptions preserves runtime callbacks such as onElicitation", () => {
+	test("buildSdkOptions preserves runtime callbacks such as onElicitation", () => {
 		const restore = setWorkflowMcpEnv({});
 		const onElicitation = async () => ({ action: "decline" as const });
 		try {

package/src/resources/extensions/gsd/auto/phases.ts

@@ -88,7 +88,7 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule, type WorktreeSafetyResult } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
 import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
-import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
+import { buildPhaseHandoffOutcome, setAutoActiveStatus, setAutoOutcomeWidget } from "../auto-dashboard.js";
 import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 import {
   captureRootDirtySnapshot,
@@ -100,7 +100,7 @@ import { classifyError, isTransient } from "../error-classifier.js";
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE =
-  /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) hit your limit\b|usage limit\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
+  /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE =
   /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
 
@@ -114,6 +114,8 @@ function classifyZeroToolProviderMessage(message: string): ReturnType<typeof cla
   return classifyError(firstLine);
 }
 
+export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+
 export function resolveDispatchRecoveryAttempts(
   unitRecoveryCount: Map<string, number>,
   unitType: string,
@@ -2092,7 +2094,7 @@ export async function runUnitPhase(
   const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
 
   // Status bar (widget + preconditions deferred until after model selection — see #2899)
-  ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+  setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
   if (mid)
     deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
 

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

@@ -516,8 +516,9 @@ export const hideFooter = (_tui: unknown, theme: Theme, footerData: ReadonlyFoot
 
 /** Widget display modes: full → small → min → off → full */
 export type WidgetMode = "full" | "small" | "min" | "off";
+export const DEFAULT_WIDGET_MODE: WidgetMode = "small";
 const WIDGET_MODES: WidgetMode[] = ["full", "small", "min", "off"];
-let widgetMode: WidgetMode = "full";
+let widgetMode: WidgetMode = DEFAULT_WIDGET_MODE;
 let widgetModeInitialized = false;
 let widgetModePreferencePath: string | null = null;
 
@@ -628,7 +629,7 @@ export function getWidgetMode(projectPath?: string, globalPath?: string): Widget
 
 /** Test-only reset for widget mode caching. */
 export function _resetWidgetModeForTests(): void {
-  widgetMode = "full";
+  widgetMode = DEFAULT_WIDGET_MODE;
   widgetModeInitialized = false;
   widgetModePreferencePath = null;
 }
@@ -648,6 +649,16 @@ export interface WidgetStateAccessors {
   getCurrentDispatchedModelId(): string | null;
 }
 
+function clearAutoOutcomeWidget(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return;
+  ctx.ui.setWidget("gsd-outcome", undefined);
+}
+
+export function setAutoActiveStatus(ctx: ExtensionContext, status: "auto" | "next"): void {
+  ctx.ui.setStatus("gsd-auto", status);
+  clearAutoOutcomeWidget(ctx);
+}
+
 export function updateProgressWidget(
   ctx: ExtensionContext,
   unitType: string,
@@ -673,7 +684,7 @@ export function updateProgressWidget(
     ctx.ui.setStatus("gsd-step", undefined);
   }
   if (!accessors.isSessionSwitching()) {
-    ctx.ui.setWidget("gsd-outcome", undefined);
+    clearAutoOutcomeWidget(ctx);
   }
 
   const verb = unitVerb(unitType);
@@ -732,6 +743,7 @@ export function updateProgressWidget(
         logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }, 15_000);
+    progressRefreshTimer.unref?.();
 
     return {
       render(width: number): string[] {
@@ -1003,7 +1015,7 @@ export function setCompletionProgressWidget(
 ): void {
   if (!ctx.hasUI) return;
   const widgetKey = "gsd-progress";
-  ctx.ui.setWidget("gsd-outcome", undefined);
+  clearAutoOutcomeWidget(ctx);
 
   if (typeof ctx.ui?.setHeader === "function") {
     ctx.ui.setHeader(() => ({

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

@@ -91,6 +91,7 @@ import { nativeHasChanges, nativeIsRepo, _resetHasChangesCache } from "./native-
 import { debugLog, isDebugEnabled } from "./debug-logger.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { detectWorktreeName } from "./worktree.js";
 import { probeGitConflictState } from "./git-conflict-state.js";
 import { runTurnGitAction } from "./git-service.js";
 import { parseUnitId } from "./unit-id.js";
@@ -340,6 +341,29 @@ function isRegistryMilestoneComplete(state: GSDState, mid: string): boolean {
   );
 }
 
+function normalizeMilestoneScope(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed || !MILESTONE_ID_RE.test(trimmed)) return null;
+  return trimmed;
+}
+
+function resolveDispatchMilestoneScope(
+  ctx: DispatchContext,
+): { id: string; source: string } | null {
+  const sessionMilestone = normalizeMilestoneScope(ctx.session?.currentMilestoneId);
+  if (sessionMilestone) return { id: sessionMilestone, source: "session.currentMilestoneId" };
+
+  const sessionWorktree = normalizeMilestoneScope(
+    ctx.session?.basePath ? detectWorktreeName(ctx.session.basePath) : null,
+  );
+  if (sessionWorktree) return { id: sessionWorktree, source: "session.basePath worktree" };
+
+  const baseWorktree = normalizeMilestoneScope(detectWorktreeName(ctx.basePath));
+  if (baseWorktree) return { id: baseWorktree, source: "basePath worktree" };
+
+  return null;
+}
+
 function hasMilestonePassedDiscuss(basePath: string, mid: string): boolean {
   if (isDbAvailable()) {
     try {
@@ -1631,6 +1655,19 @@ import { getRegistry } from "./rule-registry.js";
 export async function resolveDispatch(
   ctx: DispatchContext,
 ): Promise<DispatchAction> {
+  if (ctx.mid && isDbAvailable()) {
+    const milestone = getMilestone(ctx.mid);
+    if (milestone && isClosedStatus(milestone.status)) {
+      return {
+        action: "stop",
+        reason:
+          `Milestone ${ctx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
+          "Use an explicit reopen command before planning or executing more work for this milestone.",
+        level: "warning",
+      };
+    }
+  }
+
   const activeMid = ctx.state.activeMilestone?.id;
   if (activeMid && ctx.mid !== activeMid) {
     return {
@@ -1642,6 +1679,17 @@ export async function resolveDispatch(
     };
   }
 
+  const scopedMilestone = resolveDispatchMilestoneScope(ctx);
+  if (scopedMilestone && ctx.mid !== scopedMilestone.id) {
+    return {
+      action: "stop",
+      reason:
+        `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
+        "The active worktree/session and derived project state disagree; recover, park, or discard the stranded milestone before continuing.",
+      level: "warning",
+    };
+  }
+
   // Delegate to registry when available
   try {
     const registry = getRegistry();