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

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-1fcc10ec4a2a1496
+5f6f7839b5420a75

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/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

@@ -369,8 +369,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 +474,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 +505,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 +558,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)
@@ -789,7 +800,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,6 +30,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";
@@ -178,6 +179,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 {
@@ -1351,6 +1370,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 +1390,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();

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -323,6 +323,41 @@ function stripKnownIdPrefix(value, id) {
         return raw.slice(id.length + 1).trim() || undefined;
     return raw;
 }
+function parseReactiveBatchTaskIds(unitId) {
+    const { task: batchPart } = parseUnitId(unitId);
+    if (!batchPart?.startsWith("reactive+"))
+        return [];
+    const rawIds = batchPart
+        .slice("reactive+".length)
+        .split(",")
+        .map((taskId) => taskId.trim().toUpperCase())
+        .filter(Boolean);
+    const unique = new Set();
+    for (const taskId of rawIds) {
+        unique.add(taskId);
+    }
+    return [...unique];
+}
+function dedupePaths(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function getPlannedKeyFiles(tasks) {
+    return dedupePaths(tasks.flatMap((taskRow) => [
+        ...(taskRow.expected_output ?? []),
+        ...(taskRow.files ?? []),
+        ...(taskRow.key_files ?? []),
+    ]));
+}
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
 function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
@@ -402,6 +437,34 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
         issueNumber: ghIssueNumber,
     };
 }
+async function buildReactiveTaskCommitContext(_basePath, unitId) {
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    if (!mid || !sid || !isDbAvailable())
+        return undefined;
+    const batchTaskIds = parseReactiveBatchTaskIds(unitId);
+    if (batchTaskIds.length === 0)
+        return undefined;
+    const milestone = getMilestone(mid);
+    const slice = getSlice(mid, sid);
+    const taskRows = batchTaskIds
+        .map((tid) => getTask(mid, sid, tid))
+        .filter((taskRow) => taskRow !== null);
+    const keyFiles = getPlannedKeyFiles(taskRows);
+    if (taskRows.length === 0 || keyFiles.length === 0)
+        return undefined;
+    const taskLabel = taskRows.map((row) => row.id).join(",");
+    return {
+        taskId: `${sid}/${taskLabel}`,
+        taskDisplayId: "reactive-batch",
+        taskTitle: `Reactive batch: ${taskLabel}`,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: `Reactive execute for ${taskLabel}`,
+        keyFiles,
+    };
+}
 async function runPostUnitGitHubSyncIfNeeded(basePath, unit) {
     if (unit.type === "complete-milestone")
         return;
@@ -761,6 +824,9 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
         if (unitType === "execute-task") {
             taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
+        else if (unitType === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
+        }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
             return null;
@@ -812,6 +878,22 @@ async function runCloseoutGitAction(pctx, unit, opts) {
                 targetRepositories = getTask(mid, sid, tid)?.target_repositories;
             }
         }
+        else if (turnAction === "commit" && unit.type === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(s.basePath, unit.id);
+            const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+            if (mid && sid && isDbAvailable()) {
+                const repositories = new Set();
+                for (const tid of parseReactiveBatchTaskIds(unit.id)) {
+                    const taskRow = getTask(mid, sid, tid);
+                    for (const repoId of taskRow?.target_repositories ?? []) {
+                        repositories.add(repoId);
+                    }
+                }
+                if (repositories.size > 0) {
+                    targetRepositories = [...repositories];
+                }
+            }
+        }
         // Invalidate the nativeHasChanges cache before auto-commit (#1853).
         // The cache has a 10-second TTL and is keyed by basePath. A stale
         // `false` result causes autoCommit to skip staging entirely.
@@ -1206,12 +1288,19 @@ export async function postUnitPreVerification(pctx, opts) {
             if (safetyConfig.enabled) {
                 const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
                 // File change validation (execute-task only, after unit execution)
-                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
                     try {
-                        const taskRow = getTask(sMid, sSid, sTid);
-                        if (taskRow) {
-                            const expectedOutput = taskRow.expected_output ?? [];
-                            const plannedFiles = taskRow.files ?? [];
+                        const sliceTaskRows = isDbAvailable()
+                            ? getSliceTasks(sMid, sSid).filter((t) => isClosedStatus(t.status) || t.id === sTid)
+                            : [];
+                        if (sliceTaskRows.length > 0) {
+                            const expectedOutput = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                expected_output: taskRow.expected_output,
+                                files: taskRow.files,
+                            })));
+                            const plannedFiles = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                files: taskRow.files,
+                            })));
                             const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
                             if (audit && audit.violations.length > 0) {
                                 const warnings = audit.violations.filter(v => v.severity === "warning");
@@ -1223,6 +1312,23 @@ export async function postUnitPreVerification(pctx, opts) {
                                 }
                             }
                         }
+                        else {
+                            const taskRow = getTask(sMid, sSid, sTid);
+                            if (taskRow) {
+                                const expectedOutput = taskRow.expected_output ?? [];
+                                const plannedFiles = taskRow.files ?? [];
+                                const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
+                                if (audit && audit.violations.length > 0) {
+                                    const warnings = audit.violations.filter(v => v.severity === "warning");
+                                    for (const v of warnings) {
+                                        logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                                    }
+                                    if (warnings.length > 0) {
+                                        ctx.ui.notify(`Safety: ${warnings.length} unexpected file change(s) outside task plan`, "warning");
+                                    }
+                                }
+                            }
+                        }
                     }
                     catch (e) {
                         debugLog("postUnit", { phase: "safety-file-change", error: String(e) });
@@ -1781,8 +1887,8 @@ export async function postUnitPostVerification(pctx) {
                         }
                         catch (dbErr) {
                             // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
-                            // Use 'gsd recover' to rebuild DB state from disk if needed.
-                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.`);
+                            // Use 'gsd recover --confirm' to import markdown into the DB if needed.
+                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover --confirm' to import markdown into the DB.`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task

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

@@ -2351,6 +2351,15 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
         sliceSummaryPath,
         sliceUatPath,
         gatesToClose,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext],
+            unitType: "complete-slice",
+        }),
     });
 }
 export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {

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

@@ -802,7 +802,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             return [
                 `   1. Run \`gsd undo-task ${mid}/${sid}/${tid}\` to reset the task state`,
                 `   2. Resume auto-mode — it will re-execute the task`,
-                `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+                `   3. If the task keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
             ].join("\n");
         }
         case "plan-slice":
@@ -814,7 +814,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
                 : relSliceFile(base, mid, sid, "RESEARCH");
             return [
                 `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+                `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }
@@ -824,7 +824,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             return [
                 `   1. Run \`gsd reset-slice ${mid}/${sid}\` to reset the slice and all its tasks`,
                 `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
-                `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+                `   3. If the slice keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
             ].join("\n");
         }
         case "validate-milestone": {
@@ -833,7 +833,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
             return [
                 `   1. Write ${artifactRel} with verdict: pass`,
-                `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+                `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
                 `   3. Resume auto-mode`,
             ].join("\n");
         }