gsd-pi 2.78.0 → 2.78.1-dev.2d3fd6e71

package/dist/resources/extensions/gsd/guided-flow.js

@@ -7,22 +7,23 @@
  */
 import { showNextAction } from "../shared/tui.js";
 import { loadFile, saveFile } from "./files.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getMilestoneSlices } from "./gsd-db.js";
 import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { buildDiscussMilestonePrompt, buildSkillActivationBlock } from "./auto-prompts.js";
-import { deriveState } from "./state.js";
+import { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, } from "./auto-prompts.js";
+import { deriveState, isGhostMilestone } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAutoDetached } from "./auto.js";
 import { clearLock } from "./crash-recovery.js";
 import { assessInterruptedSession, formatInterruptedSessionRunningMessage, formatInterruptedSessionSummary, } from "./interrupted-session.js";
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
-import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
+import { gsdHome } from "./gsd-home.js";
+import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { join } from "node:path";
-import { readFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
-import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
+import { nativeAddAll, nativeCommit, nativeHasCommittedHead, nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -33,27 +34,47 @@ import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
 import { showConfirm } from "../shared/tui.js";
 import { debugLog } from "./debug-logger.js";
-import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
+import { findMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
+import { nextMilestoneIdReserved } from "./milestone-id-reservation.js";
+export { nextMilestoneIdReserved } from "./milestone-id-reservation.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, supportsStructuredQuestions, } from "./workflow-mcp.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
+import { verifyExpectedArtifact } from "./auto-recovery.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
 import { logWarning } from "./workflow-logger.js";
-// ─── ID Generation with Reservation ─────────────────────────────────────────
+// ─── Scope-based validator wrappers ──────────────────────────────────────────
+// These thin wrappers accept a MilestoneScope so callers that already hold a
+// pinned scope never have to re-derive (basePath, milestoneId) separately.
+// The underlying implementations in auto-recovery.ts / auto-artifact-paths.ts /
+// state.ts are unchanged — only the call surface in guided-flow.ts is migrated.
 /**
- * Generate the next milestone ID, accounting for reserved IDs, and reserve it.
- * Ensures any preview ID shown in the UI matches what `gsd_milestone_generate_id`
- * will later return.
+ * Scope-based overload of verifyExpectedArtifact.
+ * Uses scope.workspace.projectRoot as the authoritative base path, making
+ * the check immune to cwd-drift and worktree-path divergence.
  */
-function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
-    const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
-    const id = nextMilestoneId(allIds, uniqueEnabled);
-    reserveMilestoneId(id);
-    return id;
+export function verifyExpectedArtifactForScope(scope, unitType, unitId) {
+    return verifyExpectedArtifact(unitType, unitId, scope.workspace.projectRoot);
+}
+/**
+ * Scope-based overload of resolveExpectedArtifactPath.
+ * Returns the canonical absolute path (or null) using the scope's projectRoot.
+ */
+export function resolveExpectedArtifactPathForScope(scope, unitType, unitId) {
+    return resolveExpectedArtifactPath(unitType, unitId, scope.workspace.projectRoot);
+}
+/**
+ * Scope-based overload of isGhostMilestone.
+ * Binds basePath and milestoneId from the scope, ensuring path resolution
+ * uses the canonical project root regardless of the cwd at call time.
+ */
+export function isGhostMilestoneByScope(scope) {
+    return isGhostMilestone(scope.workspace.projectRoot, scope.milestoneId);
 }
 function needsPlanV2Gate(state) {
     return state.phase === "executing"
@@ -62,7 +83,7 @@ function needsPlanV2Gate(state) {
         || state.phase === "completing-milestone";
 }
 function runPlanV2Gate(ctx, basePath, state) {
-    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences;
     const uokFlags = resolveUokFlags(prefs);
     if (!uokFlags.planV2 || !needsPlanV2Gate(state))
         return "pass";
@@ -85,29 +106,93 @@ function buildDocsCommitInstruction(_message) {
 // #4573: cap for how many times we nudge the LLM after a premature ready
 // phrase before giving up and asking the user to re-run /gsd.
 const MAX_READY_REJECTS = 2;
+// H1 (#5012): cap for Gate 1b plan-blocked recovery hints. After this many
+// consecutive recovery attempts the loop is stopped and the user is directed
+// to investigate manually.
+const MAX_PLAN_BLOCKED_RECOVERIES = 3;
 // #4573: matches the canonical ready phrase the discuss prompt asks the LLM
 // to emit. Accepts any M-prefixed milestone ID (three digits + optional
 // suffix) with optional trailing punctuation.
 const READY_PHRASE_RE = /\bMilestone\s+M\d{3}[A-Z0-9-]*\s+ready\.?/i;
 const pendingAutoStartMap = new Map();
+const pendingDeepProjectSetupMap = new Map();
+const USER_DRIVEN_DEEP_SETUP_UNITS = new Set([
+    "discuss-project",
+    "discuss-requirements",
+    "research-decision",
+]);
+const FOREGROUND_DEEP_SETUP_RULE_NAMES = new Set([
+    "deep: pre-planning (no workflow prefs) → workflow-preferences",
+    "deep: pre-planning (no PROJECT) → discuss-project",
+    "deep: pre-planning (no REQUIREMENTS) → discuss-requirements",
+    "deep: pre-planning (no research decision) → research-decision",
+]);
+const LEGACY_DEEP_SETUP_PSEUDO_MILESTONE_DIRS = new Set([
+    "PROJECT",
+    "REQUIREMENTS",
+    "RESEARCH-DECISION",
+    "RESEARCH-PROJECT",
+    "WORKFLOW-PREFS",
+]);
+const FOREGROUND_DEEP_SETUP_QUESTION_POLICY = `## Foreground Deep Setup Question Policy
+
+This stage is running inside the foreground \`/gsd new-project --deep\` interview. Ask user questions in plain chat only.
+
+- Do NOT call \`ask_user_questions\`, \`AskUserQuestion\`, or ToolSearch to discover user-input tools.
+- Ask one focused round, then stop and wait for the user's normal chat response.`;
 /**
  * Backward-compat bridge: returns a mutable reference to the entry matching
  * basePath, or the sole entry when only one session exists.
- * Internal use only — external code should use the Map directly.
+ * Exported for testing — internal use only in production code.
  */
-function _getPendingAutoStart(basePath) {
+export function _getPendingAutoStart(basePath) {
     if (basePath)
         return pendingAutoStartMap.get(basePath) ?? null;
     if (pendingAutoStartMap.size === 1)
         return pendingAutoStartMap.values().next().value;
     return null;
 }
+function hasNestedFileOrSymlink(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isFile() || entry.isSymbolicLink())
+            return true;
+        if (entry.isDirectory() && hasNestedFileOrSymlink(join(dir, entry.name)))
+            return true;
+    }
+    return false;
+}
+function clearEmptyLegacyDeepSetupPseudoMilestones(basePath, entries) {
+    const mDir = milestonesDir(basePath);
+    const remaining = [];
+    for (const entry of entries) {
+        if (!LEGACY_DEEP_SETUP_PSEUDO_MILESTONE_DIRS.has(entry)) {
+            remaining.push(entry);
+            continue;
+        }
+        const entryPath = join(mDir, entry);
+        try {
+            if (hasNestedFileOrSymlink(entryPath)) {
+                remaining.push(entry);
+                continue;
+            }
+            rmSync(entryPath, { recursive: true, force: true });
+            logWarning("guided", `Self-heal: removed empty legacy deep setup pseudo-milestone directory ${entry}`);
+        }
+        catch (err) {
+            remaining.push(entry);
+            logWarning("guided", `legacy deep setup pseudo-milestone cleanup failed for ${entry}: ${err.message}`);
+        }
+    }
+    return remaining;
+}
 /**
  * Store pending auto-start state for a project.
  * Exported for testing (#2985).
  */
 export function setPendingAutoStart(basePath, entry) {
-    pendingAutoStartMap.set(basePath, { createdAt: Date.now(), ...entry });
+    const ws = createWorkspace(entry.basePath);
+    const scope = scopeMilestone(ws, entry.milestoneId);
+    pendingAutoStartMap.set(basePath, { createdAt: Date.now(), planBlockedRecoveryCount: 0, ...entry, scope });
 }
 /**
  * Clear pending auto-start state.
@@ -122,6 +207,14 @@ export function clearPendingAutoStart(basePath) {
         pendingAutoStartMap.clear();
     }
 }
+export function clearPendingDeepProjectSetup(basePath) {
+    if (basePath) {
+        pendingDeepProjectSetupMap.delete(basePath);
+    }
+    else {
+        pendingDeepProjectSetupMap.clear();
+    }
+}
 /**
  * Returns the milestoneId being discussed for the given project.
  * When basePath is omitted and only one session is active, returns that
@@ -138,6 +231,126 @@ export function getDiscussionMilestoneId(basePath) {
     }
     return null;
 }
+function _getPendingDeepProjectSetup(basePath) {
+    if (basePath)
+        return pendingDeepProjectSetupMap.get(basePath) ?? null;
+    if (pendingDeepProjectSetupMap.size === 1)
+        return pendingDeepProjectSetupMap.values().next().value;
+    return null;
+}
+function getDeepSetupSessionId(ctx) {
+    return ctx?.sessionManager?.getSessionId?.();
+}
+function _getPendingDeepProjectSetupForContext(ctx, basePath) {
+    if (basePath) {
+        const direct = pendingDeepProjectSetupMap.get(basePath);
+        if (direct)
+            return direct;
+    }
+    if (!ctx)
+        return _getPendingDeepProjectSetup();
+    const sessionId = getDeepSetupSessionId(ctx);
+    if (sessionId) {
+        const matches = [...pendingDeepProjectSetupMap.values()].filter(entry => entry.sessionId === sessionId);
+        if (matches.length === 1)
+            return matches[0];
+    }
+    const matches = [...pendingDeepProjectSetupMap.values()].filter(entry => entry.ctx === ctx);
+    return matches.length === 1 ? matches[0] : null;
+}
+export function getPendingDeepProjectSetupUnitForContext(ctx, basePath) {
+    const entry = _getPendingDeepProjectSetupForContext(ctx, basePath);
+    if (!entry?.currentUnitType || !entry.currentUnitId)
+        return null;
+    return {
+        unitType: entry.currentUnitType,
+        unitId: entry.currentUnitId,
+    };
+}
+export async function startDeepProjectSetupForeground(ctx, pi, basePath, step) {
+    const entry = {
+        ctx,
+        pi,
+        basePath,
+        step,
+        createdAt: Date.now(),
+        sessionId: getDeepSetupSessionId(ctx),
+    };
+    pendingDeepProjectSetupMap.set(basePath, entry);
+    await dispatchNextDeepProjectSetupStage(entry);
+}
+export async function checkDeepProjectSetupAfterTurn(_event, ctx, basePath) {
+    const entry = _getPendingDeepProjectSetupForContext(ctx, basePath);
+    if (!entry)
+        return false;
+    if (entry.currentUnitType && entry.currentUnitId) {
+        // TODO(C-future): PendingDeepProjectSetupEntry does not carry a MilestoneScope
+        // because deep-project-setup units span non-milestone unit types (discuss-project,
+        // discuss-requirements, etc.).  Migrate to verifyExpectedArtifactForScope once
+        // PendingDeepProjectSetupEntry is extended with a scope field.
+        const artifactReady = verifyExpectedArtifact(entry.currentUnitType, entry.currentUnitId, entry.basePath);
+        if (!artifactReady) {
+            return false;
+        }
+    }
+    return dispatchNextDeepProjectSetupStage(entry);
+}
+async function dispatchNextDeepProjectSetupStage(entry) {
+    invalidateAllCaches();
+    const prefs = loadEffectiveGSDPreferences(entry.basePath)?.preferences;
+    const { DISPATCH_RULES, hasPendingDeepStage } = await import("./auto-dispatch.js");
+    if (!hasPendingDeepStage(prefs, entry.basePath)) {
+        pendingDeepProjectSetupMap.delete(entry.basePath);
+        startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+        return true;
+    }
+    const state = await deriveState(entry.basePath);
+    const dispatchCtx = {
+        basePath: entry.basePath,
+        mid: "PROJECT",
+        midTitle: "Project setup",
+        state,
+        prefs,
+        // Claude Code currently surfaces workflow-MCP question calls as tool-request
+        // UI that can be cancelled outside the normal chat flow. During the
+        // foreground deep project setup interview, keep user input in plain chat so
+        // `/gsd new-project --deep` cannot bounce through cancelled tool requests.
+        structuredQuestionsAvailable: "false",
+    };
+    let result = null;
+    for (const rule of DISPATCH_RULES) {
+        // Only evaluate foreground setup gates here. Later deep rules such as
+        // research-project have dispatch-time side effects (e.g. claiming an
+        // inflight marker) and must be left to auto-mode once the interview is
+        // complete.
+        if (!FOREGROUND_DEEP_SETUP_RULE_NAMES.has(rule.name))
+            continue;
+        result = await rule.match(dispatchCtx);
+        if (result)
+            break;
+    }
+    if (!result || result.action !== "dispatch") {
+        if (result?.action === "stop") {
+            entry.ctx.ui.notify(result.reason, result.level);
+        }
+        else if (hasPendingDeepStage(prefs, entry.basePath)) {
+            pendingDeepProjectSetupMap.delete(entry.basePath);
+            startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+            return true;
+        }
+        return false;
+    }
+    if (!USER_DRIVEN_DEEP_SETUP_UNITS.has(result.unitType)) {
+        pendingDeepProjectSetupMap.delete(entry.basePath);
+        startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+        return true;
+    }
+    entry.currentUnitType = result.unitType;
+    entry.currentUnitId = result.unitId;
+    entry.createdAt = Date.now();
+    await dispatchWorkflow(entry.pi, `${result.prompt}\n\n${FOREGROUND_DEEP_SETUP_QUESTION_POLICY}`, "gsd-run", entry.ctx, result.unitType);
+    return true;
+}
 /** Called from agent_end to check if auto-mode should start after discuss */
 export function checkAutoStartAfterDiscuss() {
     const entry = _getPendingAutoStart();
@@ -146,17 +359,61 @@ export function checkAutoStartAfterDiscuss() {
     const { ctx, pi, basePath, milestoneId, step } = entry;
     // Gate 1: Primary milestone must have CONTEXT.md or ROADMAP.md
     // The "discuss" path creates CONTEXT.md; the "plan" path creates ROADMAP.md.
-    const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
-    const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    // Use pinned scope (immune to cwd-drift) for existence checks.
+    const contextFilePath = entry.scope.contextFile();
+    const roadmapFilePath = entry.scope.roadmapFile();
+    const contextFile = existsSync(contextFilePath) ? contextFilePath : null;
+    const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
     if (!contextFile && !roadmapFile)
         return false; // neither artifact yet — keep waiting
+    // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
+    // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
+    // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
+    // depth-verification gate.  Emit a recovery hint so the next agent turn can retry
+    // gsd_plan_milestone, then return false (keep blocking auto-start).
+    // If CONTEXT.md does not exist (discuss-incomplete), Gate 1 already blocked above.
+    if (isDbAvailable()) {
+        const dbRow = getMilestone(milestoneId);
+        if (dbRow?.status === "queued" && contextFile) {
+            if (entry.planBlockedRecoveryCount >= MAX_PLAN_BLOCKED_RECOVERIES) {
+                // H1: recovery loop cap reached — stop triggering new turns, escalate to user.
+                logWarning("guided", `Gate 1b: milestone ${milestoneId} plan-blocked recovery limit reached ` +
+                    `(${entry.planBlockedRecoveryCount}/${MAX_PLAN_BLOCKED_RECOVERIES}); escalating to user`);
+                ctx.ui.notify(`Milestone ${milestoneId} plan_milestone has been blocked ${entry.planBlockedRecoveryCount} times. ` +
+                    `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`, "error");
+                return false;
+            }
+            logWarning("guided", `Gate 1b: milestone ${milestoneId} queued with CONTEXT.md present — ` +
+                `plan_milestone was blocked; emitting recovery hint ` +
+                `(attempt ${entry.planBlockedRecoveryCount + 1}/${MAX_PLAN_BLOCKED_RECOVERIES})`);
+            ctx.ui.notify(`Milestone ${milestoneId}: context file exists but milestone is still queued. ` +
+                `Retrying gsd_plan_milestone to complete the blocked planning step.`, "warning");
+            try {
+                pi.sendMessage({
+                    customType: "gsd-plan-milestone-blocked-recovery",
+                    content: `Milestone ${milestoneId} has ${contextFile} on disk but its DB row is still ` +
+                        `"queued". The gsd_plan_milestone tool was previously blocked by the ` +
+                        `depth-verification gate. Call gsd_plan_milestone now to complete the ` +
+                        `planning phase.`,
+                    display: false,
+                }, { triggerTurn: true });
+                // Increment only after a successful dispatch so transient sendMessage
+                // failures do not consume recovery budget.
+                entry.planBlockedRecoveryCount += 1;
+            }
+            catch (e) {
+                logWarning("guided", `Gate 1b recovery sendMessage failed: ${e.message}`);
+            }
+            return false;
+        }
+    }
     // Gate 2: STATE.md must exist — written as the last step in the discuss
     // output phase. This prevents auto-start from firing during Phase 3
     // (sequential readiness gates for remaining milestones) in multi-milestone
     // discussions, where M001-CONTEXT.md exists but M002/M003 haven't been
     // processed yet.
-    const stateFile = resolveGsdRootFile(basePath, "STATE");
-    if (!stateFile)
+    const stateFilePath = entry.scope.stateFile();
+    if (!existsSync(stateFilePath))
         return false; // discussion not finalized yet
     // Gate 3: Multi-milestone completeness warning
     // Parse PROJECT.md for milestone sequence, warn if any are missing context.
@@ -188,7 +445,7 @@ export function checkAutoStartAfterDiscuss() {
     // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
     // When it exists, validate it before auto-starting. Project history alone is
     // not a reliable signal for the current discussion mode.
-    const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
+    const manifestPath = join(entry.scope.workspace.contract.projectGsd, "DISCUSSION-MANIFEST.json");
     if (existsSync(manifestPath)) {
         try {
             const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -284,13 +541,15 @@ function hasToolUse(msg) {
 /**
  * #4573 — Detect and recover from the "ready phrase without files" failure mode.
  *
- * When the LLM emits "Milestone {{id}} ready." but has not written CONTEXT.md
- * or ROADMAP.md, `checkAutoStartAfterDiscuss()` silently returns false and the
- * next /gsd invocation loops into the "All milestones complete" warning.
+ * When the LLM emits "Milestone {{id}} ready." but has not written the
+ * milestone CONTEXT/ROADMAP artifacts, `checkAutoStartAfterDiscuss()` silently
+ * returns false and the next /gsd invocation loops into the "All milestones
+ * complete" warning.
  *
  * This function, called from `handleAgentEnd` after `checkAutoStartAfterDiscuss`
  * returns false, pattern-matches the ready phrase on the last assistant message.
- * If it fired AND neither CONTEXT.md nor ROADMAP.md exists, it:
+ * If it fired AND neither the canonical M###-CONTEXT.md/M###-ROADMAP.md nor
+ * legacy CONTEXT.md/ROADMAP.md files exist, it:
  *   1. Notifies the user that the signal was rejected.
  *   2. Injects a system message via `pi.sendMessage(..., {triggerTurn:true})`
  *      telling the LLM the signal was premature and to emit the writes now.
@@ -310,12 +569,35 @@ export function maybeHandleReadyPhraseWithoutFiles(event) {
     const text = extractAssistantText(lastMsg);
     if (!READY_PHRASE_RE.test(text))
         return false;
+    // Bust paths.ts cached dir listings before checking for fresh writes. The
+    // LLM's Write tool calls do not invalidate paths.ts caches, so a stale
+    // listing taken before the milestone dir or its CONTEXT/ROADMAP files
+    // existed would falsely report the artifacts as missing and trigger the
+    // 3-strike "ready without files" abort even though the writes succeeded.
+    clearPathCache();
     // Gate: artifacts must still be missing — if they exist, the happy path
     // already fired and we have nothing to do.
     const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
     const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     if (contextFile || roadmapFile)
         return false;
+    // Diagnostic: when the cached resolver reports both files missing, also probe
+    // the canonical paths with uncached existsSync so we can tell whether the
+    // recovery is firing on real-missing files or a path-resolution miss
+    // (basePath/symlink mismatch, stale cache despite agent-end-recovery flush,
+    // legacy descriptor dir not matching, etc.).
+    try {
+        const mDir = resolveMilestonePath(basePath, milestoneId);
+        const canonicalCtx = mDir ? join(mDir, `${milestoneId}-CONTEXT.md`) : null;
+        const canonicalRoadmap = mDir ? join(mDir, `${milestoneId}-ROADMAP.md`) : null;
+        logWarning("guided", `ready-phrase-reject diagnostic mid=${milestoneId} basePath=${basePath} ` +
+            `mDir=${mDir ?? "null"} ` +
+            `canonical-ctx=${canonicalCtx ?? "null"} ctx-exists=${canonicalCtx ? existsSync(canonicalCtx) : "n/a"} ` +
+            `canonical-roadmap=${canonicalRoadmap ?? "null"} roadmap-exists=${canonicalRoadmap ? existsSync(canonicalRoadmap) : "n/a"}`);
+    }
+    catch (e) {
+        logWarning("guided", `ready-phrase-reject diagnostic failed: ${e.message}`);
+    }
     entry.readyRejectCount = (entry.readyRejectCount ?? 0) + 1;
     if (entry.readyRejectCount > MAX_READY_REJECTS) {
         // Give up: clear state and tell the user to re-run /gsd. Avoids an
@@ -325,10 +607,11 @@ export function maybeHandleReadyPhraseWithoutFiles(event) {
             `Stopping auto-nudge. Run /gsd to try again.`, "error");
         return true;
     }
-    ctx.ui.notify(`Milestone ${milestoneId}: "ready" signal rejected — CONTEXT.md and ROADMAP.md are missing. Asking the LLM to complete the writes.`, "warning");
+    const contextRel = relMilestoneFile(basePath, milestoneId, "CONTEXT");
+    const roadmapRel = relMilestoneFile(basePath, milestoneId, "ROADMAP");
+    ctx.ui.notify(`Milestone ${milestoneId}: "ready" signal rejected — ${contextRel} and ${roadmapRel} are missing. Asking the LLM to complete the writes.`, "warning");
     const nudge = `You emitted "Milestone ${milestoneId} ready." but neither ` +
-        `.gsd/milestones/${milestoneId}/${milestoneId}-CONTEXT.md nor ` +
-        `.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md exists on disk. ` +
+        `${contextRel} nor ${roadmapRel} exists on disk. ` +
         `The ready phrase is a POST-WRITE signal and has been rejected. ` +
         `In this turn: (1) write PROJECT.md, REQUIREMENTS.md, and the milestone ` +
         `CONTEXT.md, (2) call gsd_plan_milestone, then (3) emit the ready phrase. ` +
@@ -366,7 +649,12 @@ const emptyTurnCounterByBase = new Map();
 const MAX_EMPTY_TURN_RETRIES = 2;
 // Phrases that indicate the LLM is about to do something but has not yet.
 // Kept tight to avoid flagging legitimate narration like "I'll wait for your answer."
-const COMMIT_INTENT_RE = /\b(?:I['’]ll|I will|Next,? I['’]ll|Now I['’]ll|Let me|I['’]m going to|I am going to)\s+(?:now\s+)?(?:write|create|call|invoke|update|add|make|run|execute|generate|produce|emit|compose|implement|save|apply|commit)\b/i;
+//
+// "make" was previously in the verb list but matches conversational meta phrases
+// like "Let me make sure I understand…" which are NOT action announcements —
+// removed to prevent the empty-turn nudge from auto-replying to user questions
+// in discuss flows.
+const COMMIT_INTENT_RE = /\b(?:I['’]ll|I will|Next,? I['’]ll|Now I['’]ll|Let me|I['’]m going to|I am going to)\s+(?:now\s+)?(?:write|create|call|invoke|update|add|run|execute|generate|produce|emit|compose|implement|save|apply|commit)\b/i;
 /**
  * Reset the empty-turn counter for a basePath after a successful tool-use turn.
  * Called from handleAgentEnd when the last message contains tool_use blocks.
@@ -394,12 +682,14 @@ export function maybeHandleEmptyIntentTurn(event, isAuto) {
     // path, handled by maybeHandleReadyPhraseWithoutFiles.
     if (READY_PHRASE_RE.test(text))
         return false;
-    // Skip if the LLM is clearly handing back to the user. Keep the heuristic
-    // tight: a trailing question mark on the last non-empty line is the common
-    // signal for "I asked the user a question and stopped."
-    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-    const lastLine = lines[lines.length - 1] ?? "";
-    if (lastLine.endsWith("?"))
+    // Skip if the LLM is clearly handing back to the user. Discuss flows
+    // often pose a question and follow it with a conditional intent on the
+    // same line ("Did I capture that correctly? If so, I'll write the
+    // requirements."). A line-trailing `?` check misses these because the
+    // line ends in `.`. Match any sentence-terminating `?` (followed by
+    // whitespace or end-of-text) — false negatives here auto-reply to the
+    // user, which is a much worse failure mode than a missed nudge.
+    if (/\?(?:\s|$)/.test(text))
         return false;
     // Must contain a commit-intent phrase — this is the stall we care about.
     if (!COMMIT_INTENT_RE.test(text))
@@ -505,7 +795,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             removed: currentTools.length - scopedTools.length,
         });
     }
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType,
@@ -675,17 +965,21 @@ export async function showHeadlessMilestoneCreation(ctx, pi, basePath, seedConte
     clearReservedMilestoneIds();
     // Ensure .gsd/ is bootstrapped
     bootstrapGsdProject(basePath);
+    const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+    await ensureDbOpen(basePath);
     // Generate next milestone ID
     const existingIds = findMilestoneIds(basePath);
     const prefs = loadEffectiveGSDPreferences();
-    const nextId = nextMilestoneIdReserved(existingIds, prefs?.preferences?.unique_milestone_ids ?? false);
-    // Create milestone directory
-    const milestoneDir = join(gsdRoot(basePath), "milestones", nextId, "slices");
-    mkdirSync(milestoneDir, { recursive: true });
+    const nextId = nextMilestoneIdReserved(existingIds, prefs?.preferences?.unique_milestone_ids ?? false, basePath);
+    // Fix #4996: Do NOT pre-create the milestone directory here.
+    // atomicWriteAsync (used by all artifact writers) calls mkdir lazily before
+    // each write, so every path through saveArtifactToDb / saveFile is already
+    // lazy-mkdir-safe. Pre-creating the dir before the discuss flow runs leaves
+    // an orphan stub if discuss is abandoned — that stub later skews nextMilestoneId.
     // Build and dispatch the headless discuss prompt
     const prompt = buildHeadlessDiscussPrompt(nextId, seedContext, basePath);
     // Set pending auto start (auto-mode triggers on "Milestone X ready." via checkAutoStartAfterDiscuss)
-    pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, createdAt: Date.now() });
+    setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId });
     // Dispatch as discuss-milestone. The LLM writes PROJECT.md, REQUIREMENTS.md,
     // and CONTEXT.md, then calls gsd_plan_milestone — this is semantically the
     // discuss path, just non-interactive. Using "plan-milestone" here caused
@@ -851,13 +1145,13 @@ export async function showDiscuss(ctx, pi, basePath) {
             const seed = draftContent
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: mid, step: false, createdAt: Date.now() });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: false });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: mid, step: false, createdAt: Date.now() });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: false });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
@@ -865,10 +1159,12 @@ export async function showDiscuss(ctx, pi, basePath) {
             }), "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "skip_milestone") {
+            const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+            await ensureDbOpen(basePath);
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false, createdAt: Date.now() });
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
@@ -1122,6 +1418,9 @@ function selfHealRuntimeRecords(basePath, ctx) {
         for (const record of records) {
             const { unitType, unitId, phase } = record;
             // Clear records whose expected artifact already exists (completed but not cleaned up)
+            // TODO(C-future): selfHealRuntimeRecords iterates across all unit types (not just milestone
+            // units), so it cannot be converted to resolveExpectedArtifactPathForScope without
+            // first establishing a per-record scope.  Migrate once unit runtime records carry scope info.
             const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
             if (artifactPath && existsSync(artifactPath)) {
                 clearUnitRuntimeRecord(basePath, unitType, unitId);
@@ -1223,8 +1522,8 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
     if (choice === "skip") {
         const milestoneIds = findMilestoneIds(basePath);
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-        pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
+        setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
         await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
     }
@@ -1259,6 +1558,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     // milestones/) must trigger the init wizard, not skip it (#2942).
     const gsdPath = gsdRoot(basePath);
     const hasBootstrapArtifacts = hasGsdBootstrapArtifacts(gsdPath);
+    let skipGitBootstrap = false;
     if (!hasBootstrapArtifacts) {
         const detection = detectProjectState(basePath);
         // v1 .planning/ detected — offer migration before anything else
@@ -1277,6 +1577,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         const result = await showProjectInit(ctx, pi, basePath, detection);
         if (!result.completed)
             return; // User cancelled
+        skipGitBootstrap = result.gitEnabled === false;
         // Init wizard bootstrapped .gsd/ — fall through to the normal flow below
         // which will detect "no milestones" and start the discuss prompt
     }
@@ -1284,13 +1585,32 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     // Also handle inherited repos: if basePath is a subdirectory of another
     // git repo that has no .gsd, create a fresh repo to prevent cross-project
     // state leaks (#1639).
-    if (!nativeIsRepo(basePath) || isInheritedRepo(basePath)) {
+    if (!skipGitBootstrap && (!nativeIsRepo(basePath) || isInheritedRepo(basePath))) {
         const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
         nativeInit(basePath, mainBranch);
     }
     // ── Ensure .gitignore has baseline patterns ──────────────────────────
-    ensureGitignore(basePath);
-    untrackRuntimeFiles(basePath);
+    if (!skipGitBootstrap && nativeIsRepo(basePath)) {
+        ensureGitignore(basePath);
+        untrackRuntimeFiles(basePath);
+    }
+    // Deep setup can pre-create .gsd/PREFERENCES.md before the normal init
+    // wizard path runs. If that path also initialized git, make HEAD reachable
+    // now so later worktree/git-log operations do not run on an unborn branch.
+    if (!skipGitBootstrap && nativeIsRepo(basePath) && !nativeHasCommittedHead(basePath)) {
+        try {
+            nativeAddAll(basePath);
+            nativeCommit(basePath, "chore: init project");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logWarning("guided", `initial git commit failed; worktree isolation will remain disabled until HEAD exists: ${message}`);
+        }
+    }
+    {
+        const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+        await ensureDbOpen(basePath);
+    }
     // ── Self-heal stale runtime records from crashed auto-mode sessions ──
     selfHealRuntimeRecords(basePath, ctx);
     const interrupted = await assessInterruptedSession(basePath);
@@ -1342,6 +1662,22 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     catch (err) {
         logWarning("guided", `STATE.md rebuild failed: ${err.message}`);
     }
+    // ── Deep planning mode kickoff ────────────────────────────────────────
+    // When `planning_depth: deep` is set (e.g. via `/gsd new-project --deep`)
+    // and any project-level stage gate is still pending, keep the user-question
+    // stages in the foreground conversation. Auto-mode is resumed only after
+    // the project interview artifacts exist, so questions do not look like
+    // cancelled auto-mode runs.
+    // Light mode and fully-completed deep projects fall through to the
+    // standard wizard below.
+    {
+        const prefs = loadEffectiveGSDPreferences(basePath)?.preferences;
+        const { hasPendingDeepStage } = await import("./auto-dispatch.js");
+        if (hasPendingDeepStage(prefs, basePath)) {
+            await startDeepProjectSetupForeground(ctx, pi, basePath, stepMode);
+            return;
+        }
+    }
     const planV2GateDecision = runPlanV2Gate(ctx, basePath, state);
     if (planV2GateDecision === "block")
         return;
@@ -1352,12 +1688,12 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         // and fires another dispatchWorkflow, resetting the conversation mid-interview.
         if (pendingAutoStartMap.has(basePath)) {
             // #3274: If /clear interrupted the discussion, the pending entry is stale.
-            // Detect staleness: no manifest, no CONTEXT.md, AND entry is older than
+            // Detect staleness: no manifest, no milestone CONTEXT artifact, AND entry is older than
             // 30s (avoids race between .set() and LLM writing first artifact).
             const entry = pendingAutoStartMap.get(basePath);
             const ageMs = Date.now() - (entry.createdAt || 0);
             const manifestExists = existsSync(join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json"));
-            const milestoneHasContext = existsSync(join(gsdRoot(basePath), "milestones", entry.milestoneId, `${entry.milestoneId}-CONTEXT.md`));
+            const milestoneHasContext = !!resolveMilestoneFile(basePath, entry.milestoneId, "CONTEXT");
             if (!manifestExists && !milestoneHasContext && ageMs > 30_000) {
                 // Stale entry from an interrupted discussion — clear and continue
                 pendingAutoStartMap.delete(basePath);
@@ -1375,7 +1711,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const mDir = milestonesDir(basePath);
             if (existsSync(mDir)) {
                 try {
-                    const entries = readdirSync(mDir);
+                    const entries = clearEmptyLegacyDeepSetupPseudoMilestones(basePath, readdirSync(mDir));
                     if (entries.length > 0) {
                         ctx.ui.notify(`Milestone directory has ${entries.length} entries but none were recognized as milestones. ` +
                             `This may indicate a corrupted state or wrong working directory. Run \`/gsd doctor\` to diagnose.`, "warning");
@@ -1388,11 +1724,11 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }
         }
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
         const isFirst = milestoneIds.length === 0;
         if (isFirst) {
             // First ever — skip wizard, just ask directly
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else {
@@ -1410,7 +1746,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "new_milestone") {
-                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+                setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
                 await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
         }
@@ -1419,7 +1755,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     const milestoneId = state.activeMilestone.id;
     const milestoneTitle = state.activeMilestone.title;
     if (planV2GateDecision === "recover-missing-context") {
-        pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
+        setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
         await dispatchWorkflow(pi, await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, getStructuredQuestionsAvailability(pi, ctx)), "gsd-discuss", ctx, "discuss-milestone");
         return;
     }
@@ -1446,8 +1782,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (choice === "new_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else if (choice === "status") {
@@ -1494,13 +1830,13 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const seed = draftContent
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
@@ -1510,8 +1846,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
@@ -1567,26 +1903,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "plan") {
-                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode, createdAt: Date.now() });
-                const planMilestoneTemplates = [
-                    inlineTemplate("roadmap", "Roadmap"),
-                    inlineTemplate("plan", "Slice Plan"),
-                    inlineTemplate("task-plan", "Task Plan"),
-                    inlineTemplate("secrets-manifest", "Secrets Manifest"),
-                ].join("\n\n---\n\n");
-                const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
-                await dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
-                    milestoneId,
-                    milestoneTitle,
-                    secretsOutputPath,
-                    inlinedTemplates: planMilestoneTemplates,
-                    skillActivation: buildSkillActivationBlock({
-                        base: basePath,
-                        milestoneId,
-                        milestoneTitle,
-                        extraContext: [planMilestoneTemplates],
-                    }),
-                }), "gsd-run", ctx, "plan-milestone");
+                setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
+                await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discuss") {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
@@ -1600,8 +1918,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-                const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
+                const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
+                setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
                 await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "discard_milestone") {
@@ -1709,23 +2027,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready.",
         });
         if (choice === "plan") {
-            const planSliceTemplates = [
-                inlineTemplate("plan", "Slice Plan"),
-                inlineTemplate("task-plan", "Task Plan"),
-            ].join("\n\n---\n\n");
-            await dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
-                milestoneId,
-                sliceId,
-                sliceTitle,
-                inlinedTemplates: planSliceTemplates,
-                skillActivation: buildSkillActivationBlock({
-                    base: basePath,
-                    milestoneId,
-                    sliceId,
-                    sliceTitle,
-                    extraContext: [planSliceTemplates],
-                }),
-            }), "gsd-run", ctx, "plan-slice");
+            await dispatchWorkflow(pi, await buildPlanSlicePrompt(milestoneId, milestoneTitle, sliceId, sliceTitle, basePath), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
             const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
@@ -1784,24 +2086,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready.",
         });
         if (choice === "complete") {
-            const completeSliceTemplates = [
-                inlineTemplate("slice-summary", "Slice Summary"),
-                inlineTemplate("uat", "UAT"),
-            ].join("\n\n---\n\n");
-            await dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
-                workingDirectory: basePath,
-                milestoneId,
-                sliceId,
-                sliceTitle,
-                inlinedTemplates: completeSliceTemplates,
-                skillActivation: buildSkillActivationBlock({
-                    base: basePath,
-                    milestoneId,
-                    sliceId,
-                    sliceTitle,
-                    extraContext: [completeSliceTemplates],
-                }),
-            }), "gsd-run", ctx, "complete-slice");
+            await dispatchWorkflow(pi, await buildCompleteSlicePrompt(milestoneId, milestoneTitle, sliceId, sliceTitle, basePath), "gsd-run", ctx, "complete-slice");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1875,22 +2160,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 }), "gsd-run", ctx, "execute-task");
             }
             else {
-                const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
-                await dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
-                    milestoneId,
-                    sliceId,
-                    taskId,
-                    taskTitle,
-                    inlinedTemplates: executeTaskTemplates,
-                    skillActivation: buildSkillActivationBlock({
-                        base: basePath,
-                        milestoneId,
-                        sliceId,
-                        taskId,
-                        taskTitle,
-                        extraContext: [executeTaskTemplates],
-                    }),
-                }), "gsd-run", ctx, "execute-task");
+                await dispatchWorkflow(pi, await buildExecuteTaskPrompt(milestoneId, sliceId, sliceTitle, taskId, taskTitle, basePath), "gsd-run", ctx, "execute-task");
             }
         }
         else if (choice === "status") {