gsd-pi 2.78.0 → 2.78.1-dev.42ef05fbe

package/dist/resources/extensions/gsd/forensics.js

@@ -10,7 +10,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, dirname, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
+import { gsdHome } from "./gsd-home.js";
 import { extractTrace } from "./session-forensics.js";
 import { nativeParseJsonlTail } from "./native-parser-bridge.js";
 import { MAX_JSONL_BYTES, parseJSONL } from "./jsonl-utils.js";
@@ -30,6 +30,7 @@ import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPref
 import { showNextAction } from "../shared/tui.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 import { summarizeWorktreeTelemetry, percentile } from "./worktree-telemetry.js";
+import { homedir } from "node:os";
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
 ## Pre-Investigation: Duplicate Check (REQUIRED)
@@ -135,8 +136,7 @@ export async function handleForensics(args, ctx, pi) {
     // when import.meta.url resolves to the npm-global install path (Windows).
     let gsdSourceDir = dirname(fileURLToPath(import.meta.url));
     if (!existsSync(join(gsdSourceDir, "prompts"))) {
-        const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-        const fallback = join(gsdHome, "agent", "extensions", "gsd");
+        const fallback = join(gsdHome(), "agent", "extensions", "gsd");
         if (existsSync(join(fallback, "prompts")))
             gsdSourceDir = fallback;
     }
@@ -649,7 +649,7 @@ function detectMissingArtifacts(completedKeys, basePath, activeMilestone, anomal
  * the forensics memory-bloat guard in forensics-journal.test.ts — per-event
  * detail stays in the journal itself where the LLM can query it on demand.
  */
-function detectWorktreeOrphans(summary, anomalies) {
+export function detectWorktreeOrphans(summary, anomalies) {
     // 1. Orphan aggregate — severity depends on reason. In-progress orphans are
     // the #4761 consumer-side signal (live work sitting on an unmerged branch).
     for (const [reason, count] of Object.entries(summary.orphansByReason)) {
@@ -663,7 +663,7 @@ function detectWorktreeOrphans(summary, anomalies) {
             details: reason === "in-progress-unmerged"
                 ? "Auto-mode exited without completing a milestone; live work sits on an unmerged milestone branch. Run `/gsd auto` to resume, or merge manually."
                 : reason === "complete-unmerged"
-                    ? "A completed milestone's branch was never merged back to main. Run `/gsd health --fix` to resolve."
+                    ? "A completed milestone's branch was never merged back to main. Run `/gsd doctor fix` to resolve."
                     : `Reason: ${reason}.`,
         });
     }
@@ -1109,11 +1109,19 @@ function formatReportForPrompt(report) {
 // ─── Redaction ────────────────────────────────────────────────────────────────
 function redactForGitHub(text, basePath) {
     let result = text;
+    // Build regex that matches both / and \ separator variants (Windows)
+    // Normalize to / first, escape for regex, then replace each / with [/\\]
+    const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pathRe = (p) => new RegExp(esc(p.replace(/\\/g, "/")).replace(/\//g, "[/\\\\]"), "gi");
     // Replace absolute paths
-    result = result.replaceAll(basePath, ".");
-    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    if (home)
-        result = result.replaceAll(home, "~");
+    result = result.replace(pathRe(basePath), ".");
+    // Redact GSD_HOME first (when it's outside ~), then OS home.
+    // Order matters: longer path must be replaced before the shorter prefix.
+    const gsdHomePath = gsdHome();
+    if (!gsdHomePath.startsWith(homedir())) {
+        result = result.replace(pathRe(gsdHomePath), "~/.gsd");
+    }
+    result = result.replace(pathRe(homedir()), "~");
     // Strip API key patterns
     result = result.replace(/sk-[a-zA-Z0-9]{20,}/g, "sk-***");
     result = result.replace(/Bearer\s+\S+/g, "Bearer ***");

package/dist/resources/extensions/gsd/git-service.js

@@ -18,6 +18,7 @@ import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-p
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
+import { isInfrastructureError } from "./auto/infra-errors.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
 /**
  * Build a meaningful conventional commit message from task execution context.
@@ -775,6 +776,16 @@ function buildTurnSnapshotLabel(unitType, unitId) {
         .replace(/-{2,}/g, "-")
         .replace(/^[-/]+|[-/]+$/g, "") || "turn";
 }
+export function handleTurnGitActionError(action, err) {
+    if (isInfrastructureError(err)) {
+        throw err;
+    }
+    return {
+        action,
+        status: "failed",
+        error: getErrorMessage(err),
+    };
+}
 export function runTurnGitAction(args) {
     try {
         // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
@@ -806,11 +817,7 @@ export function runTurnGitAction(args) {
         };
     }
     catch (err) {
-        return {
-            action: args.action,
-            status: "failed",
-            error: getErrorMessage(err),
-        };
+        return handleTurnGitActionError(args.action, err);
     }
 }
 // ─── Commit Type Inference ─────────────────────────────────────────────────

package/dist/resources/extensions/gsd/gsd-db.js

@@ -26,6 +26,7 @@ import { GSDError, GSD_STALE_STATE } from "./errors.js";
 import { getGateIdsForTurn } from "./gate-registry.js";
 import { logError, logWarning } from "./workflow-logger.js";
 const _require = createRequire(import.meta.url);
+const BETTER_SQLITE3_PACKAGE = ["better", "sqlite3"].join("-");
 let providerName = null;
 let providerModule = null;
 let loadAttempted = false;
@@ -63,7 +64,7 @@ function loadProvider() {
         // unavailable
     }
     try {
-        const mod = _require("better-sqlite3");
+        const mod = _require(BETTER_SQLITE3_PACKAGE);
         if (typeof mod === "function" || (mod && mod.default)) {
             providerModule = mod.default || mod;
             providerName = "better-sqlite3";
@@ -1191,7 +1192,7 @@ export function openDatabase(path) {
         // node:sqlite loaded but failed to open this file — try better-sqlite3 as fallback.
         if (providerName === "node:sqlite") {
             try {
-                const mod = _require("better-sqlite3");
+                const mod = _require(BETTER_SQLITE3_PACKAGE);
                 const Db = (mod && mod.default) ? mod.default : mod;
                 if (typeof Db === "function") {
                     rawDb = new Db(path);
@@ -1321,6 +1322,15 @@ export function checkpointDatabase() {
     }
 }
 let _txDepth = 0;
+/**
+ * Whether the current call is running inside an active SQLite transaction.
+ * Statement-time recovery paths (e.g. VACUUM retry on a malformed memory
+ * store) MUST gate on this — SQLite refuses VACUUM inside a transaction
+ * and would mask the original error with a secondary "cannot VACUUM" throw.
+ */
+export function isInTransaction() {
+    return _txDepth > 0;
+}
 export function transaction(fn) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -1335,8 +1345,8 @@ export function transaction(fn) {
             _txDepth--;
         }
     }
-    _txDepth++;
     currentDb.exec("BEGIN");
+    _txDepth++;
     try {
         const result = fn();
         currentDb.exec("COMMIT");
@@ -1369,8 +1379,8 @@ export function readTransaction(fn) {
             _txDepth--;
         }
     }
-    _txDepth++;
     currentDb.exec("BEGIN DEFERRED");
+    _txDepth++;
     try {
         const result = fn();
         currentDb.exec("COMMIT");

package/dist/resources/extensions/gsd/gsd-home.js

@@ -0,0 +1,29 @@
+/**
+ * GSD home directory resolution.
+ *
+ * Exports gsdHome() which returns the GSD configuration directory,
+ * defaulting to ~/.gsd with a GSD_HOME env var override.
+ *
+ * For the user's home directory, use os.homedir() directly — it handles
+ * platform-specific env lookup (USERPROFILE on Windows, HOME on POSIX)
+ * with appropriate fallbacks.
+ *
+ * @see https://github.com/gsd-build/gsd-2/issues/5015
+ */
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/**
+ * Resolve the GSD home directory (typically ~/.gsd).
+ *
+ * `GSD_HOME` env var overrides the default location.
+ * Falls back to `homedir()/.gsd`.
+ *
+ * Always returns an absolute, normalized path — `resolve()` canonicalizes
+ * any relative or non-canonical `GSD_HOME` value so downstream comparison
+ * and redaction sites don't have to.
+ */
+export function gsdHome() {
+    return process.env.GSD_HOME
+        ? resolve(process.env.GSD_HOME)
+        : join(homedir(), ".gsd");
+}

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

@@ -18,11 +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 { gsdHome } from "./gsd-home.js";
 import { gsdRoot, milestonesDir, resolveMilestoneFile, 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";
@@ -33,28 +34,19 @@ 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";
 // ─── 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 ─────────────────────────────────────────
-/**
- * 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.
- */
-function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
-    const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
-    const id = nextMilestoneId(allIds, uniqueEnabled);
-    reserveMilestoneId(id);
-    return id;
-}
 function needsPlanV2Gate(state) {
     return state.phase === "executing"
         || state.phase === "summarizing"
@@ -62,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";
@@ -90,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.
@@ -102,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).
@@ -122,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
@@ -138,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();
@@ -366,7 +540,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 +573,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."
+    // Skip if the LLM is clearly handing back to the user. Last-line `?` is
+    // the strongest signal, but discuss flows often end with a freeform
+    // question followed by a closing remark ("…what should we build? I'll
+    // pick one if you don't care."). Treat ANY non-empty line ending in `?`
+    // as a question-asked signal — false negatives here auto-reply to the
+    // user, which is a much worse failure mode than a missed nudge.
     const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-    const lastLine = lines[lines.length - 1] ?? "";
-    if (lastLine.endsWith("?"))
+    if (lines.some((l) => l.endsWith("?")))
         return false;
     // Must contain a commit-intent phrase — this is the stall we care about.
     if (!COMMIT_INTENT_RE.test(text))
@@ -505,7 +686,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,13 +856,17 @@ 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)
@@ -865,9 +1050,11 @@ 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);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1223,7 +1410,7 @@ 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);
+        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
         pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
         await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
@@ -1291,6 +1478,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     // ── Ensure .gitignore has baseline patterns ──────────────────────────
     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 (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 +1546,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;
@@ -1375,7 +1595,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,7 +1608,7 @@ 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
@@ -1446,7 +1666,7 @@ 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);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1510,7 +1730,7 @@ 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);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1600,7 +1820,7 @@ 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);
+                const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
                 await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }