gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2ff77b0ce

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

@@ -10,7 +10,7 @@ import { loadFile, saveFile } from "./files.js";
 import { isDbAvailable, 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 { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAutoDetached } from "./auto.js";
@@ -18,12 +18,12 @@ 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 { getHomeDir } from "./home-dir.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, } 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";
@@ -42,6 +42,7 @@ 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";
 // ─── 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";
@@ -53,7 +54,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";
@@ -81,6 +82,31 @@ const MAX_READY_REJECTS = 2;
 // 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.
@@ -93,6 +119,39 @@ function _getPendingAutoStart(basePath) {
         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).
@@ -113,6 +172,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
@@ -129,6 +196,122 @@ 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) {
+        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();
@@ -275,13 +458,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.
@@ -307,6 +492,23 @@ export function maybeHandleReadyPhraseWithoutFiles(event) {
     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
@@ -316,10 +518,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. ` +
@@ -357,7 +560,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.
@@ -385,12 +593,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))
@@ -496,7 +706,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             removed: currentTools.length - scopedTools.length,
         });
     }
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(getHomeDir(), ".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,
@@ -1256,6 +1466,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
@@ -1274,6 +1485,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
     }
@@ -1281,13 +1493,28 @@ 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);
@@ -1343,6 +1570,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;
@@ -1353,12 +1596,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);
@@ -1376,7 +1619,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");
@@ -1569,25 +1812,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             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");
+                await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discuss") {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
@@ -1710,23 +1935,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);
@@ -1785,24 +1994,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");
@@ -1876,22 +2068,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") {

package/dist/resources/extensions/gsd/init-wizard.js

@@ -5,10 +5,10 @@
  * Detects project ecosystem, offers v1 migration, configures project preferences,
  * bootstraps .gsd/ structure, and transitions to the first milestone discussion.
  */
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
+import { nativeInit, nativeAddAll, nativeCommit, nativeDetectMainBranch } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -41,6 +41,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     }
     // ── Step 2: Git setup ──────────────────────────────────────────────────────
     let didInitGit = false;
+    let gitEnabled = signals.isGitRepo;
     if (!signals.isGitRepo) {
         const gitChoice = await showNextAction(ctx, {
             title: "GSD — Project Setup",
@@ -56,6 +57,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         if (gitChoice === "init_git") {
             nativeInit(basePath, prefs.mainBranch);
             didInitGit = true;
+            gitEnabled = true;
         }
     }
     else {
@@ -243,9 +245,12 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — DB creation failure should not block project init
     }
-    // Ensure .gitignore
-    ensureGitignore(basePath);
-    untrackRuntimeFiles(basePath);
+    // Ensure .gitignore only when git is active. A user who selected "Skip"
+    // should not have git initialized or git-related files mutated later.
+    if (gitEnabled) {
+        ensureGitignore(basePath);
+        untrackRuntimeFiles(basePath);
+    }
     // Create initial commit so git log and git worktree work immediately (#4530).
     // Without this, the branch is "unborn" (zero commits) and downstream operations
     // like `git log` and `git worktree add` fail.
@@ -288,7 +293,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         prepareWorkflowMcpForProject(ctx, basePath);
     }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
-    return { completed: true, bootstrapped: true };
+    return { completed: true, bootstrapped: true, gitEnabled };
 }
 // ─── V1 Migration Offer ─────────────────────────────────────────────────────────
 /**
@@ -558,24 +563,12 @@ function buildDetectionSummary(signals) {
     }
     return lines;
 }
-function detectMainBranch(basePath) {
+export function detectMainBranch(basePath) {
     try {
-        // Check HEAD reference for common branch names
-        const headPath = join(basePath, ".git", "HEAD");
-        if (existsSync(headPath)) {
-            const head = readFileSync(headPath, "utf-8").trim();
-            const match = head.match(/^ref: refs\/heads\/(.+)$/);
-            if (match)
-                return match[1];
-        }
-        // Check for common remote branches
-        const refsPath = join(basePath, ".git", "refs", "remotes", "origin");
-        if (existsSync(refsPath)) {
-            if (existsSync(join(refsPath, "main")))
-                return "main";
-            if (existsSync(join(refsPath, "master")))
-                return "master";
-        }
+        // Match runtime branch resolution: origin/HEAD -> main -> master -> current.
+        // Reading .git/HEAD first records whichever feature branch happened to be
+        // checked out during init and can redirect future milestone merges.
+        return nativeDetectMainBranch(basePath);
     }
     catch {
         // Fall through to null