gsd-pi 2.78.1-dev.82bcf6b71 → 2.78.1-dev.84c045fd2

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

@@ -9,17 +9,17 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { validateArtifact } from "./schemas/validate.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
-import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
-import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
@@ -27,7 +27,16 @@ import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
 import { EXECUTION_ENTRY_PHASES, hasFinalizedMilestoneContext } from "./uok/plan-v2.js";
 import { isAutoActive } from "./auto.js";
 import { markDepthVerified } from "./bootstrap/write-gate.js";
+import { ensureWorkflowPreferencesCaptured } from "./planning-depth.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import { PROJECT_RESEARCH_INFLIGHT_MARKER, } from "./project-research-policy.js";
+import { isWorkflowPrefsCaptured, resolveDeepProjectSetupState, } from "./deep-project-setup-policy.js";
+import { annotateBackgroundable } from "./delegation-policy.js";
 let reassessmentChecker = checkNeedsReassessment;
+let researchProjectPromptBuilder = buildResearchProjectPrompt;
+function shouldBypassMilestoneDepthGateInAuto(prefs) {
+    return isAutoActive() && prefs?.planning_depth !== "deep";
+}
 export function setReassessmentCheckerForTest(checker) {
     const previous = reassessmentChecker;
     reassessmentChecker = checker;
@@ -35,6 +44,13 @@ export function setReassessmentCheckerForTest(checker) {
         reassessmentChecker = previous;
     };
 }
+export function setResearchProjectPromptBuilderForTest(builder) {
+    const previous = researchProjectPromptBuilder;
+    researchProjectPromptBuilder = builder;
+    return () => {
+        researchProjectPromptBuilder = previous;
+    };
+}
 async function readUatGateVerdict(basePath, mid, sliceId) {
     const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
     const assessmentFile = resolveSliceFile(basePath, mid, sliceId, "ASSESSMENT");
@@ -58,6 +74,23 @@ async function readUatGateVerdict(basePath, mid, sliceId) {
     }
     return null;
 }
+/**
+ * Deep planning mode: check whether any project-level stage gate
+ * (workflow-preferences, discuss-project, discuss-requirements,
+ * research-decision, research-project) still has work pending.
+ *
+ * Used by the milestone-level discuss rules to yield to project-level
+ * deep-mode rules when the project hasn't finished its setup interview.
+ * Returns false in light mode (or when prefs absent) so the milestone
+ * rules behave exactly as before.
+ */
+export function getDeepStageGate(prefs, basePath) {
+    return resolveDeepProjectSetupState(prefs, basePath);
+}
+export function hasPendingDeepStage(prefs, basePath) {
+    const gate = getDeepStageGate(prefs, basePath);
+    return gate.status === "pending" || gate.status === "blocked";
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -205,21 +238,20 @@ export const DISPATCH_RULES = [
         // Fire BEFORE the execution-entry phase rules so we redispatch to
         // `discuss-milestone` instead of hitting the plan-v2 gate.
         name: "execution-entry phase (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (!EXECUTION_ENTRY_PHASES.has(state.phase))
                 return null;
+            if (!MILESTONE_ID_RE.test(mid))
+                return null;
             // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
             // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
             if (hasFinalizedMilestoneContext(basePath, mid))
                 return null;
-            // H6 fix (#4973): In auto-mode there is no human to answer the
-            // depth-verification ask_user_questions, so the write-gate deadlocks.
-            // Pre-mark the milestone as depth-verified so gsd_summary_save({artifact_type:"CONTEXT"})
-            // is not blocked. Safe ordering: session_switch fires clearDiscussionFlowState()
-            // (register-hooks.ts:106) before before_agent_start, which fires before resolveDispatch
-            // reaches this match fn — so this call always happens after any session-switch reset.
-            // Interactive sessions (isAutoActive()===false) are unaffected.
-            if (isAutoActive()) {
+            // H6 fix (#4973): non-deep auto-mode has no human to answer the
+            // depth-verification question, so pre-marking avoids a write-gate
+            // deadlock. Deep planning is still user-driven even inside auto-mode,
+            // so it must wait for explicit approval instead of taking this bypass.
+            if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
                 markDepthVerified(mid, basePath);
             }
             return {
@@ -340,13 +372,19 @@ export const DISPATCH_RULES = [
     },
     {
         name: "needs-discussion → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (state.phase !== "needs-discussion")
                 return null;
-            // H6 fix (#4973): auto-mark depth-verified so the write-gate does not
-            // deadlock in non-interactive (auto-mode) runs. See ordering note at
-            // "execution-entry phase (no context) → discuss-milestone" above.
-            if (isAutoActive()) {
+            // Deep mode bypass: yield to the project-level deep stage gates
+            // (workflow-prefs, discuss-project, discuss-requirements,
+            // research-decision, research-project) when any of them still have
+            // work pending. Without this guard, the milestone discuss rule wins
+            // before the deep rules ever get a chance to fire.
+            if (hasPendingDeepStage(prefs, basePath))
+                return null;
+            // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
+            // pre-verify deep planning's user-facing milestone approval gate.
+            if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
                 markDepthVerified(mid, basePath);
             }
             return {
@@ -357,19 +395,171 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        // Deep mode stage gate: workflow preferences not yet captured.
+        // This used to dispatch an agent unit, but the step is deterministic
+        // defaults-writing. Keep it in-process so missing preferences cannot loop
+        // on the same no-input unit until stuck detection fires.
+        name: "deep: pre-planning (no workflow prefs) → workflow-preferences",
+        match: async ({ state, basePath, prefs }) => {
+            if (prefs?.planning_depth !== "deep")
+                return null;
+            if (state.phase !== "pre-planning" && state.phase !== "needs-discussion")
+                return null;
+            if (isWorkflowPrefsCaptured(basePath))
+                return null; // already captured — fall through
+            ensureWorkflowPreferencesCaptured(basePath);
+            return null;
+        },
+    },
+    {
+        // Deep mode stage gate: PROJECT.md missing or invalid.
+        // Fires only when planning_depth === "deep" and PROJECT.md is missing/invalid.
+        // Project-level interview must complete before any milestone-level discussion.
+        // Light mode (default) skips this rule entirely — falls through to milestone rules.
+        name: "deep: pre-planning (no PROJECT) → discuss-project",
+        match: async ({ state, basePath, prefs, structuredQuestionsAvailable }) => {
+            if (prefs?.planning_depth !== "deep")
+                return null;
+            if (state.phase !== "pre-planning" && state.phase !== "needs-discussion")
+                return null;
+            const projectPath = join(gsdRoot(basePath), "PROJECT.md");
+            if (existsSync(projectPath) && validateArtifact(projectPath, "project").ok)
+                return null; // PROJECT.md valid — fall through
+            return {
+                action: "dispatch",
+                unitType: "discuss-project",
+                unitId: "PROJECT",
+                prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+            };
+        },
+    },
+    {
+        // Deep mode stage gate: REQUIREMENTS.md missing or invalid.
+        // Fires only when planning_depth === "deep", PROJECT.md is valid, and
+        // REQUIREMENTS.md is missing/invalid.
+        // Falls through in light mode or when REQUIREMENTS.md already exists and is valid.
+        name: "deep: pre-planning (no REQUIREMENTS) → discuss-requirements",
+        match: async ({ state, basePath, prefs, structuredQuestionsAvailable }) => {
+            if (prefs?.planning_depth !== "deep")
+                return null;
+            if (state.phase !== "pre-planning" && state.phase !== "needs-discussion")
+                return null;
+            const projectPath = join(gsdRoot(basePath), "PROJECT.md");
+            if (!existsSync(projectPath) || !validateArtifact(projectPath, "project").ok)
+                return null; // PROJECT.md missing/invalid — earlier rule handles
+            const requirementsPath = join(gsdRoot(basePath), "REQUIREMENTS.md");
+            if (existsSync(requirementsPath) && validateArtifact(requirementsPath, "requirements").ok)
+                return null; // REQUIREMENTS.md valid — fall through
+            return {
+                action: "dispatch",
+                unitType: "discuss-requirements",
+                unitId: "REQUIREMENTS",
+                prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+            };
+        },
+    },
+    {
+        // Deep mode research gate: capture user's research decision.
+        // Fires after discuss-requirements (REQUIREMENTS.md exists) when no decision
+        // marker has been written yet. Asks one yes/no question via ask_user_questions
+        // and writes .gsd/runtime/research-decision.json. Downstream research-project
+        // rule reads the marker to decide whether to fan out 4 parallel research subagents.
+        // Light mode skips entirely.
+        name: "deep: pre-planning (no research decision) → research-decision",
+        match: async ({ state, basePath, prefs, structuredQuestionsAvailable }) => {
+            if (prefs?.planning_depth !== "deep")
+                return null;
+            if (state.phase !== "pre-planning" && state.phase !== "needs-discussion")
+                return null;
+            const gate = resolveDeepProjectSetupState(prefs, basePath);
+            if (gate.status !== "pending" || gate.stage !== "research-decision")
+                return null;
+            return {
+                action: "dispatch",
+                unitType: "research-decision",
+                unitId: "RESEARCH-DECISION",
+                prompt: await buildResearchDecisionPrompt(basePath, structuredQuestionsAvailable),
+            };
+        },
+    },
+    {
+        // Deep mode parallel research.
+        // Fires when planning_depth === "deep", REQUIREMENTS.md exists,
+        // research-decision marker says "research", and any of the 4 project
+        // research files is missing. Spawns one orchestrator session that fans
+        // out 4 parallel subagents (stack, features, architecture, pitfalls).
+        // Skipped entirely when user chose "skip" at the research-decision gate.
+        name: "deep: pre-planning (research approved, files missing) → research-project",
+        match: async ({ state, basePath, prefs, structuredQuestionsAvailable }) => {
+            if (prefs?.planning_depth !== "deep")
+                return null;
+            if (state.phase !== "pre-planning" && state.phase !== "needs-discussion")
+                return null;
+            const gate = resolveDeepProjectSetupState(prefs, basePath);
+            if (gate.status === "blocked" && gate.stage === "project-research") {
+                return {
+                    action: "stop",
+                    reason: gate.reason,
+                    level: "warning",
+                };
+            }
+            if (gate.status !== "pending" || gate.stage !== "project-research")
+                return null;
+            // Idempotency guard: one orchestrator owns the project research fan-out
+            // until guided-research-project.md deletes this marker during closeout.
+            const runtimeDir = join(gsdRoot(basePath), "runtime");
+            const inflightMarkerPath = join(runtimeDir, PROJECT_RESEARCH_INFLIGHT_MARKER);
+            const researchInFlightStop = {
+                action: "stop",
+                reason: "Project research is already in progress. Wait for it to finish, or clear `.gsd/runtime/research-project-inflight` if the prior run crashed.",
+                level: "info",
+            };
+            if (existsSync(inflightMarkerPath))
+                return researchInFlightStop;
+            mkdirSync(runtimeDir, { recursive: true });
+            try {
+                writeFileSync(inflightMarkerPath, JSON.stringify({ started: new Date().toISOString() }) + "\n", { encoding: "utf-8", flag: "wx" });
+            }
+            catch (err) {
+                if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+                    return researchInFlightStop;
+                }
+                throw err;
+            }
+            try {
+                const prompt = await researchProjectPromptBuilder(basePath, structuredQuestionsAvailable);
+                return {
+                    action: "dispatch",
+                    unitType: "research-project",
+                    unitId: "RESEARCH-PROJECT",
+                    prompt,
+                };
+            }
+            catch (err) {
+                try {
+                    if (existsSync(inflightMarkerPath))
+                        unlinkSync(inflightMarkerPath);
+                }
+                catch (cleanupErr) {
+                    logWarning("dispatch", `failed to remove research-project in-flight marker after prompt assembly error: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`);
+                }
+                throw err;
+            }
+        },
+    },
     {
         name: "pre-planning (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
                 return null; // fall through to next rule
-            // H6 fix (#4973): auto-mark depth-verified so the write-gate does not
-            // deadlock in non-interactive (auto-mode) runs. See ordering note at
-            // "execution-entry phase (no context) → discuss-milestone" above.
-            if (isAutoActive()) {
+            // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
+            // pre-verify deep planning's user-facing milestone approval gate.
+            if (shouldBypassMilestoneDepthGateInAuto(prefs)) {
                 markDepthVerified(mid, basePath);
             }
             return {
@@ -530,15 +720,11 @@ export const DISPATCH_RULES = [
         // while a slice is still `is_sketch=1`, fall through to a standard
         // plan-slice so the loop doesn't dead-end.
         //
-        // Note on the flag-OFF downgrade: plan-slice does not explicitly clear
-        // `is_sketch`. After it writes PLAN.md, the auto-heal in state.ts's
-        // `deriveStateFromDb` (via `autoHealSketchFlags`) flips the flag on the
-        // next iteration. That implicit coupling is the sole mechanism that
-        // reconciles `is_sketch=1` on the plan-slice path — do not remove the
-        // auto-heal without either adding an explicit `setSliceSketchFlag(..., false)`
-        // call here or doing so inside the plan-slice tool handler.
+        // Note on the flag-OFF downgrade: DB slice metadata is authoritative.
+        // PLAN.md is only a projection, so plan-slice/refine-slice handlers must
+        // explicitly clear `is_sketch` when a sketch becomes a full plan.
         name: "refining → refine-slice",
-        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry, sessionProvider }) => {
             if (state.phase !== "refining")
                 return null;
             if (!state.activeSlice)
@@ -564,20 +750,20 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { ...(softScopeHint ? { softScopeHint } : {}), sessionContextWindow, modelRegistry }),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { ...(softScopeHint ? { softScopeHint } : {}), sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
             return {
                 action: "dispatch",
                 unitType: "refine-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
             };
         },
     },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, session }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, sessionProvider, session }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
@@ -601,7 +787,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "plan-slice",
                 unitId,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, priorPreExecFailure }),
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider, priorPreExecFailure }),
             };
         },
     },
@@ -650,7 +836,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → reactive-execute (parallel dispatch)",
-        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry, sessionProvider }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -725,7 +911,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry }),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
             catch (err) {
@@ -737,7 +923,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
-        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry, sessionProvider }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -756,7 +942,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
             return null;
@@ -764,7 +950,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task",
-        match: async ({ state, mid, basePath, sessionContextWindow, modelRegistry }) => {
+        match: async ({ state, mid, basePath, sessionContextWindow, modelRegistry, sessionProvider }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -777,7 +963,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "execute-task",
                 unitId: `${mid}/${sid}/${tid}`,
-                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath, { sessionContextWindow, modelRegistry }),
+                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath, { sessionContextWindow, modelRegistry, sessionProvider }),
             };
         },
     },
@@ -847,14 +1033,6 @@ export const DISPATCH_RULES = [
                     return { action: "skip" };
                 }
             }
-            const existingSummary = resolveMilestoneFile(basePath, mid, "SUMMARY");
-            let summaryOutcome = "unknown";
-            if (existingSummary) {
-                const summaryContent = await loadFile(existingSummary);
-                if (summaryContent) {
-                    summaryOutcome = classifyMilestoneSummaryContent(summaryContent);
-                }
-            }
             // Safety guard (#2675): block completion when VALIDATION verdict is
             // needs-remediation. The state machine treats needs-remediation as
             // terminal (to prevent validate-milestone loops per #832), but
@@ -931,45 +1109,6 @@ export const DISPATCH_RULES = [
             catch (err) { /* fall through — don't block on DB errors */
                 logWarning("dispatch", `verification class check failed: ${err instanceof Error ? err.message : String(err)}`);
             }
-            // Disk/DB mismatch handling (#4658): SUMMARY presence alone is not enough.
-            // Apply post-gate policy:
-            // - success summary: reconcile DB and skip re-dispatch
-            // - failure summary: pause/fail-closed
-            // - unknown summary: pause/fail-closed
-            if (existingSummary) {
-                const milestone = isDbAvailable() ? getMilestone(mid) : null;
-                const status = milestone?.status ?? (isDbAvailable() ? "missing" : "unavailable");
-                if (summaryOutcome === "success") {
-                    if (!isDbAvailable()) {
-                        logWarning("dispatch", `Milestone ${mid} SUMMARY indicates completion while DB is unavailable — skipping duplicate complete-milestone dispatch`);
-                        return { action: "skip" };
-                    }
-                    try {
-                        updateMilestoneStatus(mid, "complete", new Date().toISOString());
-                        logWarning("dispatch", `Milestone ${mid} SUMMARY indicates completion while DB status was "${status}" — reconciled DB to complete (#4658)`);
-                        return { action: "skip" };
-                    }
-                    catch (err) {
-                        return {
-                            action: "stop",
-                            level: "warning",
-                            reason: `Milestone ${mid} SUMMARY indicates completion but DB reconciliation failed (${err instanceof Error ? err.message : String(err)}). Auto-mode paused for manual review.`,
-                        };
-                    }
-                }
-                if (summaryOutcome === "failure") {
-                    return {
-                        action: "stop",
-                        level: "warning",
-                        reason: `Milestone ${mid} has a failure-path SUMMARY while DB status is "${status}". Auto-mode will not promote completion from failure artifacts. Re-run complete-milestone only after blockers are resolved and verification passes.`,
-                    };
-                }
-                return {
-                    action: "stop",
-                    level: "warning",
-                    reason: `Milestone ${mid} has an ambiguous SUMMARY while DB status is "${status}". Auto-mode paused instead of promoting completion from file presence alone.`,
-                };
-            }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",
@@ -1002,10 +1141,19 @@ import { getRegistry } from "./rule-registry.js";
  * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
+    const activeMid = ctx.state.activeMilestone?.id;
+    if (activeMid && ctx.mid !== activeMid) {
+        return {
+            action: "stop",
+            reason: `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match active milestone "${activeMid}". ` +
+                "This usually means a project-level deep setup pseudo-id leaked into milestone dispatch; rerun /gsd auto after setup state is reconciled.",
+            level: "warning",
+        };
+    }
     // Delegate to registry when available
     try {
         const registry = getRegistry();
-        return await registry.evaluateDispatch(ctx);
+        return annotateBackgroundable(await registry.evaluateDispatch(ctx));
     }
     catch (err) {
         // Registry not initialized — fall back to inline loop
@@ -1016,7 +1164,7 @@ export async function resolveDispatch(ctx) {
         if (result) {
             if (result.action !== "skip")
                 result.matchedRule = rule.name;
-            return result;
+            return annotateBackgroundable(result);
         }
     }
     // No rule matched — unhandled phase.