@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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/orchestrator.ts

@@ -277,7 +277,6 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
       this.status.activeUnit = { unitType: decision.unitType, unitId: decision.unitId };
       this.status.phase = "running";
       this.lastAdvanceKey = nextKey;
-      this.lastFinalizedUnitKey = null;
       this.bumpTransition();
 
       await this.deps.runtime.journalTransition({

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

@@ -13,10 +13,11 @@ import type {
   ExtensionCommandContext,
   ReadonlyFooterDataProvider,
   Theme,
+  ThemeColor,
 } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getActiveHook } from "./post-unit-hooks.js";
-import { getLedger } from "./metrics.js";
+import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
 import {
@@ -304,6 +305,40 @@ export function shouldRenderRoadmapProgress(
   return !!progress && progress.total > 0;
 }
 
+function widgetGridLabel(theme: Theme, text: string, color: ThemeColor = "borderAccent"): string {
+  return theme.fg(color, theme.bold(text.toUpperCase()));
+}
+
+function widgetGridColumn(content: string, width: number): string {
+  return padRightVisible(truncateToWidth(content, width, "…"), width);
+}
+
+function widgetGridColumns(theme: Theme, width: number, parts: string[]): string {
+  if (parts.length === 0) return "";
+  const gap = theme.fg("dim", " │ ");
+  const gapWidth = visibleWidth(gap) * (parts.length - 1);
+  const available = Math.max(parts.length * 8, width - gapWidth);
+  const base = Math.floor(available / parts.length);
+  let remaining = available - base * parts.length;
+  const columns = parts.map((part) => {
+    const columnWidth = base + (remaining > 0 ? 1 : 0);
+    remaining--;
+    return widgetGridColumn(part, columnWidth);
+  });
+  return truncateToWidth(columns.join(gap), width, "…");
+}
+
+function formatSmallWidgetSpend(): string {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length === 0) return "--";
+
+  const totals = getProjectTotals(ledger.units);
+  const parts: string[] = [];
+  if (totals.tokens.total > 0) parts.push(formatWidgetTokens(totals.tokens.total));
+  if (totals.cost > 0) parts.push(`$${totals.cost.toFixed(2)}`);
+  return parts.length > 0 ? parts.join(" · ") : "--";
+}
+
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 
 /**
@@ -516,8 +551,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 +664,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 +684,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 +719,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 +778,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[] {
@@ -824,29 +871,62 @@ export function updateProgressWidget(
           return lines;
         }
 
-        // ── Mode: small — header + active work progress ───────────────
+        // ── Mode: small — dense horizontal grid ───────────────────────
         if (widgetMode === "small") {
-          lines.push("");
-
-          // Action line
-          const target = task ? `${task.id}: ${task.title}` : unitId;
-          const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
-          lines.push(rightAlign(actionLeft, theme.fg("dim", phaseLabel), width));
+          lines.length = 0;
+          lines.push(...ui.bar());
 
-          // Progress bar
           const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
+          const unitLabel = unitId || [mid?.id, slice?.id, task?.id].filter(Boolean).join("/");
+          const statusParts = [
+            spinner,
+            theme.fg("success", modeTag),
+            theme.fg(stateColor, activeState),
+          ];
+          if (runtimeSignal?.summary) {
+            statusParts.push(theme.fg(healthColor, healthSummary));
+          } else if (healthLevel !== "green") {
+            statusParts.push(`${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`);
+          }
+
+          const timeValue = [elapsed, etaShort].filter(Boolean).join(" · ") || "--";
+          const rowOne = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "status", "border")} ${statusParts.join(" ")}`,
+            `${widgetGridLabel(theme, "unit")} ${theme.fg("text", unitLabel || "--")}`,
+            `${widgetGridLabel(theme, "spend", "border")} ${theme.fg("dim", formatSmallWidgetSpend())}`,
+            `${widgetGridLabel(theme, "time")} ${theme.fg("dim", timeValue)}`,
+          ]);
+
+          const target = task
+            ? `${task.id}: ${task.title}`
+            : slice
+              ? `${slice.id}: ${slice.title}`
+              : unitId;
+
+          let taskValue = task?.id ?? "--";
+          let sliceValue = slice?.id ?? "--";
           if (shouldRenderRoadmapProgress(roadmapSlices)) {
             const { done, total, activeSliceTasks } = roadmapSlices;
-            const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
+            const barWidth = Math.max(4, Math.min(14, Math.floor(width * 0.12)));
             const bar = renderProgressBar(theme, done, total, barWidth);
-            let meta = `${theme.fg("text", `${done}`)}${theme.fg("dim", `/${total} slices`)}`;
+            sliceValue = `${bar} ${theme.fg("text", `${done}/${total}`)}`;
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              const tn = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
-              meta += `${theme.fg("dim", " · task ")}${theme.fg("accent", `${tn}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              taskValue = `${theme.fg("accent", `${taskNum}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
             }
-            lines.push(`${pad}${bar} ${meta}`);
           }
 
+          const rowTwo = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "phase", "border")} ${theme.fg("dim", unitType)}`,
+            `${widgetGridLabel(theme, "work")} ${theme.fg("text", target || "--")}`,
+            `${widgetGridLabel(theme, "task", "border")} ${taskValue}`,
+            `${widgetGridLabel(theme, "slice")} ${sliceValue}`,
+          ]);
+
+          lines.push(rowOne);
+          lines.push(rowTwo);
           lines.push(...ui.bar());
           cachedLines = lines;
           cachedWidth = width;
@@ -1003,7 +1083,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(() => ({