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

package/dist/resources/extensions/browser-tools/package.json

@@ -4,7 +4,7 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test": "node --test tests/*.test.mjs"
+    "test": "node --import ../gsd/tests/resolve-ts.mjs --experimental-strip-types --test tests/*.test.mjs"
   },
   "pi": {
     "extensions": [
@@ -12,10 +12,14 @@
     ]
   },
   "peerDependencies": {
+    "@opengsd/gsd-browser": ">=0.1.27",
     "playwright": ">=1.40.0",
     "sharp": ">=0.33.0"
   },
   "peerDependenciesMeta": {
+    "@opengsd/gsd-browser": {
+      "optional": true
+    },
     "playwright": {
       "optional": true
     },

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -15,10 +15,11 @@ import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
-import { buildWorkflowMcpServers, resolveWorkflowMcpProjectRoot } from "../gsd/workflow-mcp.js";
-import { buildProjectGsdMcpServers } from "../gsd/mcp-project-config.js";
+import { buildWorkflowMcpServers, getRequiredWorkflowToolsForAutoUnit, resolveWorkflowMcpProjectRoot, } from "../gsd/workflow-mcp.js";
+import { buildProjectGsdMcpServers, ensureProjectWorkflowMcpConfig } from "../gsd/mcp-project-config.js";
 import { loadProjectGSDPreferences } from "../gsd/preferences.js";
-import { discoverBrowserMcpServerName, discoverMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools } from "../gsd/mcp-filter.js";
+import { discoverBrowserMcpServerName, discoverMcpServers, discoverMcpServerNames, discoverWorkflowMcpServerName, computeMcpDisallowedTools, } from "../gsd/mcp-filter.js";
+import { RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES, RUN_UAT_FORBIDDEN_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES, resolveToolPresentationPlan } from "../gsd/tool-presentation-plan.js";
 import { showInterviewRound } from "../shared/tui.js";
 export function serverToolUseToToolCallLike(block) {
     const argumentsValue = block.input && typeof block.input === "object" && !Array.isArray(block.input)
@@ -164,6 +165,32 @@ function extractMessageText(msg) {
     }
     return "";
 }
+const GSD_PHASE_PATTERNS = [
+    ["run-uat", /\b(?:UNIT:\s*Run UAT|run-uat)\b/i],
+    ["complete-milestone", /\b(?:UNIT:\s*Complete Milestone|complete-milestone)\b/i],
+    ["validate-milestone", /\b(?:UNIT:\s*Validate Milestone|validate-milestone)\b/i],
+    ["reassess-roadmap", /\b(?:UNIT:\s*Reassess Roadmap|reassess-roadmap)\b/i],
+    ["complete-slice", /\b(?:UNIT:\s*Complete Slice|complete-slice)\b/i],
+    ["replan-slice", /\b(?:UNIT:\s*Replan Slice|replan-slice)\b/i],
+    ["plan-slice", /\b(?:UNIT:\s*Plan Slice|plan-slice|gsd_plan_slice)\b/i],
+    ["plan-milestone", /\b(?:UNIT:\s*Plan Milestone|plan-milestone|gsd_plan_milestone)\b/i],
+    ["execute-task", /\b(?:UNIT:\s*Execute Task|execute-task|execute-task-simple|reactive-execute)\b/i],
+    ["gate-evaluate", /\b(?:UNIT:\s*Gate Evaluate|gate-evaluate|gsd_save_gate_result)\b/i],
+    ["research-milestone", /\b(?:UNIT:\s*Research Milestone|research-milestone)\b/i],
+    ["research-slice", /\b(?:UNIT:\s*Research Slice|research-slice)\b/i],
+    ["discuss-milestone", /\b(?:Discuss milestone|discuss-milestone)\b/i],
+];
+export function inferGsdPhaseFromContext(context) {
+    const text = [
+        context.systemPrompt ?? "",
+        ...context.messages.map((message) => extractMessageText(message)),
+    ].join("\n");
+    for (const [phase, pattern] of GSD_PHASE_PATTERNS) {
+        if (pattern.test(text))
+            return phase;
+    }
+    return undefined;
+}
 /**
  * Build a full conversational prompt from GSD's context messages.
  *
@@ -1175,22 +1202,106 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
             return "high";
     }
 }
-function workflowMcpServerNameFromAllowedTools(allowedTools) {
+function parseAllowedMcpToolName(toolName) {
+    const match = /^mcp__(.+)__(\*|[^*]+)$/.exec(toolName);
+    return match?.[1] && match[2] ? { server: match[1], tool: match[2] } : undefined;
+}
+function browserMcpServerNameFromAllowedTools(allowedTools) {
     if (!Array.isArray(allowedTools))
         return undefined;
     for (const toolName of allowedTools) {
         if (typeof toolName !== "string")
             continue;
-        const match = /^mcp__(.+)__\*$/.exec(toolName);
-        if (match?.[1] && match[1] !== "gsd-browser")
-            return match[1];
+        const parsed = parseAllowedMcpToolName(toolName);
+        if (!parsed)
+            continue;
+        if (parsed.server === "gsd-browser" || parsed.tool.startsWith("browser_")) {
+            return parsed.server;
+        }
     }
     return undefined;
 }
-function browserMcpServerNameFromAllowedTools(allowedTools) {
+function workflowMcpServerNameFromAllowedTools(allowedTools) {
     if (!Array.isArray(allowedTools))
         return undefined;
-    return allowedTools.includes("mcp__gsd-browser__*") ? "gsd-browser" : undefined;
+    const browserServerName = browserMcpServerNameFromAllowedTools(allowedTools);
+    for (const toolName of allowedTools) {
+        if (typeof toolName !== "string")
+            continue;
+        const parsed = parseAllowedMcpToolName(toolName);
+        if (!parsed || parsed.server === browserServerName || parsed.tool.startsWith("browser_"))
+            continue;
+        return parsed.server;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function cloneSdkMcpServerConfig(config) {
+    if (!isRecord(config))
+        return undefined;
+    const cloned = {};
+    for (const key of ["type", "command", "cwd", "url"]) {
+        if (typeof config[key] === "string")
+            cloned[key] = config[key];
+    }
+    if (Array.isArray(config.args)) {
+        cloned.args = config.args.filter((arg) => typeof arg === "string");
+    }
+    if (isStringRecord(config.env))
+        cloned.env = { ...config.env };
+    if (isStringRecord(config.headers))
+        cloned.headers = { ...config.headers };
+    if (isRecord(config.oauth))
+        cloned.oauth = { ...config.oauth };
+    return Object.keys(cloned).length > 0 ? cloned : undefined;
+}
+function resolveProjectMcpServerConfig(projectRoot, serverName, fallbackServers) {
+    if (!serverName)
+        return undefined;
+    const projectServer = discoverMcpServers(projectRoot).find((server) => server.name === serverName);
+    return cloneSdkMcpServerConfig(projectServer?.config) ?? cloneSdkMcpServerConfig(fallbackServers?.[serverName]);
+}
+function resolveProjectMcpServerConfigs(projectRoot, serverNames, fallbackServers) {
+    const resolved = {};
+    for (const serverName of serverNames) {
+        const serverConfig = resolveProjectMcpServerConfig(projectRoot, serverName, fallbackServers);
+        if (serverName && serverConfig)
+            resolved[serverName] = serverConfig;
+    }
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+function resolveExactWorkflowMcpToolsForPhase(gsdPhase, workflowServerName, workflowExplicitlyBlocked) {
+    if (!gsdPhase || !workflowServerName || workflowExplicitlyBlocked)
+        return [];
+    const requiredTools = gsdPhase === "run-uat"
+        ? [...RUN_UAT_WORKFLOW_TOOL_NAMES]
+        : getRequiredWorkflowToolsForAutoUnit(gsdPhase);
+    const supportTools = gsdPhase === "run-uat" ? [] : ["gsd_milestone_status"];
+    const requestedToolNames = [...new Set([...requiredTools, ...supportTools])];
+    if (requestedToolNames.length === 0)
+        return [];
+    return resolveToolPresentationPlan({
+        phase: gsdPhase,
+        surface: "claude-code-sdk",
+        workflowMcpServerName: workflowServerName,
+        requestedToolNames,
+    }).presentedToolNames;
+}
+export function autoInitClaudeCodeWorkflowMcp(cwd) {
+    const projectRoot = resolveWorkflowMcpProjectRoot(cwd);
+    try {
+        ensureProjectWorkflowMcpConfig(projectRoot);
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG === "1") {
+            console.warn(`[claude-code] workflow MCP auto-init failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
 }
 /**
  * Build the options object passed to the Claude Agent SDK's `query()` call.
@@ -1204,7 +1315,7 @@ function browserMcpServerNameFromAllowedTools(allowedTools) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
-    const { reasoning, cwd, ...sdkExtraOptions } = extraOptions;
+    const { reasoning, cwd, gsdPhase, ...sdkExtraOptions } = extraOptions;
     const sdkCwd = typeof cwd === "string" && cwd.trim().length > 0 ? cwd : process.cwd();
     // Claude Code runs in the milestone worktree for file/shell work, but workflow MCP
     // config (.mcp.json) and server discovery live at the project root.
@@ -1283,13 +1394,38 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const browserMcpTools = !browserExplicitlyBlocked && browserServerName
         ? [`mcp__${browserServerName}__*`]
         : [];
-    const gsdMcpTools = [...workflowMcpTools, ...browserMcpTools];
+    const phaseUsesBrowserMcp = !gsdPhase || gsdPhase === "run-uat";
+    const allowedBrowserMcpTools = phaseUsesBrowserMcp ? browserMcpTools : [];
+    const inlinePhaseMcpServers = gsdPhase
+        ? resolveProjectMcpServerConfigs(projectRoot, [
+            workflowExplicitlyBlocked ? undefined : workflowServerName,
+            phaseUsesBrowserMcp && !browserExplicitlyBlocked ? browserServerName : undefined,
+        ], defaultMcpServers.servers)
+        : undefined;
+    const sdkMcpServers = inlinePhaseMcpServers ?? filteredMcpServers;
+    const strictMcpConfig = !!inlinePhaseMcpServers;
+    // Strict phase configs inline the exact MCP servers GSD needs. Loading
+    // project/local settings at the same time can duplicate those servers and
+    // leave allowed mcp__... tools with no registered backing tool.
+    const settingSources = strictMcpConfig ? [] : ["project", "local"];
+    const exactWorkflowMcpTools = resolveExactWorkflowMcpToolsForPhase(gsdPhase, workflowServerName, workflowExplicitlyBlocked);
+    const runUatDisallowedTools = gsdPhase === "run-uat" && workflowServerName
+        ? [
+            ...RUN_UAT_FORBIDDEN_TOOL_NAMES.filter((toolName) => !toolName.startsWith("mcp__")),
+            "WebFetch",
+            "Agent",
+            `mcp__${workflowServerName}__gsd_exec`,
+            `mcp__${workflowServerName}__gsd_summary_save`,
+            `mcp__${workflowServerName}__gsd_save_gate_result`,
+        ]
+        : [];
     const disallowedTools = [...new Set([
             "ToolSearch",
-            ...(workflowMcpTools.length > 0 ? ["AskUserQuestion"] : []),
+            ...(workflowMcpTools.length > 0 || exactWorkflowMcpTools.length > 0 ? ["AskUserQuestion"] : []),
+            ...runUatDisallowedTools,
             ...extraDisallowedTools,
         ])];
-    const allowedTools = [
+    const standardClaudeTools = [
         "Read",
         "Write",
         "Edit",
@@ -1299,8 +1435,19 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         "Agent",
         "WebFetch",
         "WebSearch",
-        ...(workflowMcpTools.length > 0 ? gsdMcpTools : ["AskUserQuestion", ...browserMcpTools]),
     ];
+    const allowedTools = gsdPhase === "run-uat"
+        ? [
+            ...RUN_UAT_CLAUDE_NATIVE_TOOL_NAMES,
+            ...(exactWorkflowMcpTools.length > 0 ? exactWorkflowMcpTools : []),
+            ...allowedBrowserMcpTools,
+        ]
+        : [
+            ...standardClaudeTools,
+            ...exactWorkflowMcpTools,
+            ...(workflowMcpTools.length > 0 ? workflowMcpTools : ["AskUserQuestion"]),
+            ...allowedBrowserMcpTools,
+        ];
     const supportsAdaptive = modelSupportsAdaptiveThinking(modelId);
     const effort = reasoning && supportsAdaptive
         ? mapThinkingLevelToAnthropicEffort(reasoning, modelId)
@@ -1321,11 +1468,12 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         cwd: sdkCwd,
         permissionMode,
         allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
-        settingSources: ["project"],
+        settingSources,
         systemPrompt: { type: "preset", preset: "claude_code" },
         disallowedTools,
         ...(allowedTools.length > 0 ? { allowedTools } : {}),
-        ...(filteredMcpServers ? { mcpServers: filteredMcpServers } : {}),
+        ...(sdkMcpServers ? { mcpServers: sdkMcpServers } : {}),
+        ...(strictMcpConfig ? { strictMcpConfig: true } : {}),
         betas: (modelId.includes("sonnet")
             || modelId.includes("opus-4-7")
             || modelId.includes("opus-4.7")
@@ -1599,6 +1747,8 @@ async function pumpSdkMessages(model, context, options, stream) {
         const onExternalToolCall = options?.onExternalToolCall;
         const onExternalToolResult = options?.onExternalToolResult;
         const cwd = resolveClaudeCodeCwd(options);
+        autoInitClaudeCodeWorkflowMcp(cwd);
+        const gsdPhase = inferGsdPhaseFromContext(context);
         const canUseToolHandler = createClaudeCodeCanUseToolHandler(uiContext);
         // When no UI is available (headless / auto-mode), auto-approve all
         // tool requests. This replaces the old bypassPermissions workaround.
@@ -1606,6 +1756,7 @@ async function pumpSdkMessages(model, context, options, stream) {
             ?? (async (_toolName, _input, opts) => ({ behavior: "allow", toolUseID: opts.toolUseID }));
         const sdkOpts = buildSdkOptions(modelId, "", { permissionMode }, {
             cwd,
+            gsdPhase,
             reasoning: options?.reasoning,
             canUseTool: canUseToolFallback,
             ...(uiContext

package/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -256,7 +256,6 @@ export class AutoOrchestrator {
             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({
                 name: "advance",

package/dist/resources/extensions/gsd/auto/phases.js

@@ -51,13 +51,13 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule } 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, detectRootWriteLeak, formatRootWriteLeakMessage, } from "../root-write-leak-guard.js";
 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;
+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|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;
 function classifyZeroToolProviderMessage(message) {
     const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
@@ -67,6 +67,7 @@ function classifyZeroToolProviderMessage(message) {
         return null;
     return classifyError(firstLine);
 }
+export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -1582,7 +1583,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const dispatchKey = `${unitType}/${unitId}`;
     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);
     // ── Safety harness: reset evidence + create checkpoint ──

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -1,6 +1,6 @@
 // gsd-pi + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 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 { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
@@ -196,6 +196,39 @@ export function formatRuntimeHealthSignal(record, now = Date.now()) {
 export function shouldRenderRoadmapProgress(progress) {
     return !!progress && progress.total > 0;
 }
+function widgetGridLabel(theme, text, color = "borderAccent") {
+    return theme.fg(color, theme.bold(text.toUpperCase()));
+}
+function widgetGridColumn(content, width) {
+    return padRightVisible(truncateToWidth(content, width, "…"), width);
+}
+function widgetGridColumns(theme, width, parts) {
+    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() {
+    const ledger = getLedger();
+    if (!ledger || ledger.units.length === 0)
+        return "--";
+    const totals = getProjectTotals(ledger.units);
+    const parts = [];
+    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 ──────────────────────────────────────────────────────────
 /**
  * Estimate remaining time based on average unit duration from the metrics ledger.
@@ -369,8 +402,9 @@ export const hideFooter = (_tui, theme, footerData) => ({
     invalidate() { },
     dispose() { },
 });
+export const DEFAULT_WIDGET_MODE = "small";
 const WIDGET_MODES = ["full", "small", "min", "off"];
-let widgetMode = "full";
+let widgetMode = DEFAULT_WIDGET_MODE;
 let widgetModeInitialized = false;
 let widgetModePreferencePath = null;
 function safeReadTextFile(path) {
@@ -473,10 +507,19 @@ export function getWidgetMode(projectPath, globalPath) {
 }
 /** Test-only reset for widget mode caching. */
 export function _resetWidgetModeForTests() {
-    widgetMode = "full";
+    widgetMode = DEFAULT_WIDGET_MODE;
     widgetModeInitialized = false;
     widgetModePreferencePath = null;
 }
+function clearAutoOutcomeWidget(ctx) {
+    if (!ctx.hasUI)
+        return;
+    ctx.ui.setWidget("gsd-outcome", undefined);
+}
+export function setAutoActiveStatus(ctx, status) {
+    ctx.ui.setStatus("gsd-auto", status);
+    clearAutoOutcomeWidget(ctx);
+}
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;
@@ -495,7 +538,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         ctx.ui.setStatus("gsd-step", undefined);
     }
     if (!accessors.isSessionSwitching()) {
-        ctx.ui.setWidget("gsd-outcome", undefined);
+        clearAutoOutcomeWidget(ctx);
     }
     const verb = unitVerb(unitType);
     const phaseLabel = unitPhaseLabel(unitType);
@@ -548,6 +591,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }, 15_000);
+        progressRefreshTimer.unref?.();
         return {
             render(width) {
                 if (cachedLines && cachedWidth === width)
@@ -631,26 +675,57 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     cachedWidth = width;
                     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));
-                    // Progress bar
+                    lines.length = 0;
+                    lines.push(...ui.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;
@@ -789,7 +864,7 @@ export function setCompletionProgressWidget(ctx, snapshot) {
     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(() => ({
             render() { return []; },

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -30,10 +30,12 @@ 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";
 import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { checkCloseoutConsistencyGate, formatCloseoutConsistencyBlock, } from "./closeout-consistency-gate.js";
 function resolveExistingExpectedArtifact(unitType, unitId, basePath) {
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
     return artifactPath && existsSync(artifactPath) ? artifactPath : null;
@@ -178,6 +180,24 @@ function missingSliceStop(mid, phase) {
 function isRegistryMilestoneComplete(state, mid) {
     return state.registry.some((milestone) => milestone.id === mid && milestone.status === "complete");
 }
+function normalizeMilestoneScope(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || !MILESTONE_ID_RE.test(trimmed))
+        return null;
+    return trimmed;
+}
+function resolveDispatchMilestoneScope(ctx) {
+    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, mid) {
     if (isDbAvailable()) {
         try {
@@ -424,6 +444,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -559,6 +580,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -598,6 +620,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-project",
                 unitId: "PROJECT",
                 prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -623,6 +646,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-requirements",
                 unitId: "REQUIREMENTS",
                 prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -738,6 +762,7 @@ export const DISPATCH_RULES = [
                 unitType: "discuss-milestone",
                 unitId: mid,
                 prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable, { headless: !!process.env.GSD_HEADLESS }),
+                pauseAfterDispatch: !process.env.GSD_HEADLESS,
             };
         },
     },
@@ -1331,6 +1356,16 @@ export const DISPATCH_RULES = [
                         prompt: await buildCompleteMilestonePrompt(mid, midTitle, basePath),
                     };
                 }
+                if (milestone) {
+                    const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+                    if (!closeoutGate.ok) {
+                        return {
+                            action: "stop",
+                            reason: formatCloseoutConsistencyBlock(closeoutGate),
+                            level: "warning",
+                        };
+                    }
+                }
             }
             return {
                 action: "stop",
@@ -1351,6 +1386,17 @@ import { getRegistry } from "./rule-registry.js";
  * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
+    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 {
@@ -1360,6 +1406,15 @@ export async function resolveDispatch(ctx) {
             level: "warning",
         };
     }
+    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();