gsd-pi 2.58.0 → 2.59.0-dev.3de3832

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

@@ -8,14 +8,14 @@
  * paths, commit type inference, and the runGit shell helper.
  */
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -348,6 +348,28 @@ export class GitServiceImpl {
         // If .gsd/ IS in .gitignore (the default for external state projects),
         // git add -A already skips it and the exclusions are harmless no-ops.
         const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+        // ── Parallel worker milestone scope (#1991) ──
+        // When GSD_MILESTONE_LOCK is set, this process is a parallel worker that
+        // must only commit files belonging to its own milestone. Exclude all other
+        // milestone directories from staging to prevent cross-milestone pollution
+        // (e.g., an M033 worker fabricating M032 artifacts in the same commit).
+        const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+        if (milestoneLock) {
+            const msDir = join(gsdRoot(this.basePath), "milestones");
+            if (existsSync(msDir)) {
+                try {
+                    const entries = readdirSync(msDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && entry.name !== milestoneLock) {
+                            allExclusions.push(`.gsd/milestones/${entry.name}/`);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort — if we can't read the milestones dir, proceed without scoping
+                }
+            }
+        }
         nativeAddAllWithExclusions(this.basePath, allExclusions);
     }
     /** Tracks whether runtime file cleanup has run this session. */
@@ -390,8 +412,89 @@ export class GitServiceImpl {
             ? buildTaskCommitMessage(taskContext)
             : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
         nativeCommit(this.basePath, message, { allowEmpty: false });
+        // Absorb any preceding gsd snapshot commits into this real commit.
+        // Walk backwards from HEAD~1 counting consecutive snapshot subjects,
+        // then soft-reset to before them and re-commit with the same message.
+        this.absorbSnapshotCommits(message);
         return message;
     }
+    /**
+     * Squash consecutive `gsd snapshot:` commits that sit immediately below
+     * HEAD into the current HEAD commit. This keeps the git history clean
+     * after automated snapshot commits are superseded by real work.
+     *
+     * Guards:
+     * - Opt-in via `absorb_snapshot_commits` preference (default: true).
+     * - Refuses to rewrite commits that have been pushed to the remote
+     *   tracking branch (checks merge-base ancestry).
+     * - Saves HEAD SHA before reset; restores it if the re-commit fails.
+     *
+     * Does nothing if there are no snapshot commits to absorb.
+     */
+    absorbSnapshotCommits(headMessage) {
+        try {
+            // Opt-in guard — users can disable to keep snapshot commits for forensics
+            if (this.prefs.absorb_snapshot_commits === false)
+                return;
+            const GSD_SNAPSHOT_PREFIX = "gsd snapshot:";
+            let count = 0;
+            // Walk back from HEAD~1 counting consecutive snapshot commits (cap at 10)
+            for (let i = 1; i <= 10; i++) {
+                const subject = nativeCommitSubject(this.basePath, `HEAD~${i}`);
+                if (!subject.startsWith(GSD_SNAPSHOT_PREFIX))
+                    break;
+                count = i;
+            }
+            if (count === 0)
+                return;
+            // Guard: don't rewrite history that has been pushed to the remote.
+            // Check whether the newest snapshot commit (HEAD~1) is already
+            // reachable from the remote tracking branch. If it is, the snapshots
+            // have been pushed and must not be squashed via local history rewrite.
+            // (Checking resetTarget instead would false-positive when the remote
+            // is at the pre-snapshot base but the snapshots themselves are local.)
+            const resetTarget = `HEAD~${count + 1}`;
+            try {
+                const branch = nativeGetCurrentBranch(this.basePath);
+                if (branch) {
+                    const remoteBranch = `origin/${branch}`;
+                    // merge-base --is-ancestor exits 0 if HEAD~1 is ancestor of remote
+                    execFileSync("git", ["merge-base", "--is-ancestor", "HEAD~1", remoteBranch], {
+                        cwd: this.basePath,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                    // If we get here, newest snapshot IS reachable from remote — already pushed
+                    return;
+                }
+            }
+            catch {
+                // Not an ancestor or remote doesn't exist — safe to proceed
+            }
+            // Save HEAD SHA so we can restore if the re-commit fails
+            const savedHead = execFileSync("git", ["rev-parse", "HEAD"], {
+                cwd: this.basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            nativeResetSoft(this.basePath, resetTarget);
+            // Re-run smartStage so the same RUNTIME_EXCLUSION_PATHS apply.
+            // Snapshot commits used nativeAddTracked (git add -u) which stages
+            // ALL tracked modifications including .gsd/ state files. Without
+            // re-staging, those .gsd/ changes leak into the absorbed commit.
+            this.smartStage();
+            try {
+                nativeCommit(this.basePath, headMessage, { allowEmpty: false });
+            }
+            catch {
+                // Re-commit failed — restore original HEAD to avoid leaving the
+                // repo in a partially-reset state with no commit
+                nativeResetSoft(this.basePath, savedHead);
+            }
+        }
+        catch {
+            // Non-fatal — if squash fails, the commits remain unsquashed
+        }
+    }
     // ─── Branch Queries ────────────────────────────────────────────────────
     /**
      * Get the integration branch for this repo — the branch that slice

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

@@ -38,6 +38,7 @@ const GSD_RUNTIME_PATTERNS = [
 const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
+    ".gsd-id",
     // ── OS junk ──
     ".DS_Store",
     "Thumbs.db",
@@ -72,6 +73,38 @@ const BASELINE_PATTERNS = [
     ".cache/",
     "tmp/",
 ];
+/**
+ * Check whether `.gsd` is covered by the project's `.gitignore`.
+ *
+ * Uses `git check-ignore` for accurate evaluation — this respects nested
+ * .gitignore files, global gitignore, and negation patterns. Returns true
+ * only when git would actually ignore `.gsd/`.
+ *
+ * Returns false (not ignored) if:
+ *   - No `.gitignore` exists
+ *   - `.gsd` is not listed in any active ignore rule
+ *   - Not a git repo or git is unavailable
+ */
+export function isGsdGitignored(basePath) {
+    // Check both `.gsd` and `.gsd/` because `.gsd/` in .gitignore (trailing
+    // slash = directory-only pattern) only matches the directory form. Using
+    // both paths covers all gitignore pattern variants.
+    for (const path of [".gsd", ".gsd/"]) {
+        try {
+            // git check-ignore exits 0 when the path IS ignored, 1 when it is NOT.
+            execFileSync("git", ["check-ignore", "-q", path], {
+                cwd: basePath,
+                stdio: "pipe",
+                env: GIT_NO_PROMPT_ENV,
+            });
+            return true; // exit 0 → .gsd is ignored
+        }
+        catch {
+            // exit 1 → this form is NOT ignored, try the other
+        }
+    }
+    return false; // neither form is ignored (or git unavailable)
+}
 /**
  * Check whether `.gsd/` contains files tracked by git.
  * If so, the project intentionally keeps `.gsd/` in version control

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

@@ -8,6 +8,7 @@ import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
+import { logError } from "./workflow-logger.js";
 const _require = createRequire(import.meta.url);
 let providerName = null;
 let providerModule = null;
@@ -697,11 +698,29 @@ export function openDatabase(path) {
         initSchema(adapter, fileBacked);
     }
     catch (err) {
-        try {
-            adapter.close();
+        // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
+        // Attempt VACUUM recovery before giving up (see #2519).
+        if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
+            try {
+                adapter.exec("VACUUM");
+                initSchema(adapter, fileBacked);
+                process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
+            }
+            catch (retryErr) {
+                try {
+                    adapter.close();
+                }
+                catch { /* swallow */ }
+                throw retryErr;
+            }
+        }
+        else {
+            try {
+                adapter.close();
+            }
+            catch { /* swallow */ }
+            throw err;
         }
-        catch { /* swallow */ }
-        throw err;
     }
     currentDb = adapter;
     currentPath = path;
@@ -990,10 +1009,11 @@ export function insertMilestone(m) {
         ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
     });
 }
-export function upsertMilestonePlanning(milestoneId, planning) {
+export function upsertMilestonePlanning(milestoneId, planning, title) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE milestones SET
+      title = COALESCE(:title, title),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1007,6 +1027,7 @@ export function upsertMilestonePlanning(milestoneId, planning) {
       boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
      WHERE id = :id`).run({
         ":id": milestoneId,
+        ":title": title ?? null,
         ":vision": planning.vision ?? null,
         ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
         ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1276,6 +1297,12 @@ export function insertVerificationEvidence(e) {
         ":created_at": new Date().toISOString(),
     });
 }
+export function getVerificationEvidence(milestoneId, sliceId, taskId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare("SELECT * FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid ORDER BY id").all({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    return rows;
+}
 function rowToMilestone(row) {
     return {
         id: row["id"],
@@ -1447,7 +1474,7 @@ export function copyWorktreeDb(srcDbPath, destDbPath) {
         return true;
     }
     catch (err) {
-        process.stderr.write(`gsd-db: failed to copy DB to worktree: ${err.message}\n`);
+        logError("db", "failed to copy DB to worktree", { error: err.message });
         return false;
     }
 }
@@ -1466,13 +1493,13 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
     // ATTACH DATABASE doesn't support parameterized paths in all providers,
     // so we use strict allowlist validation instead.
     if (/['";\x00]/.test(worktreeDbPath)) {
-        process.stderr.write("gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n");
+        logError("db", "worktree DB reconciliation failed: path contains unsafe characters");
         return zero;
     }
     if (!currentDb) {
         const opened = openDatabase(mainDbPath);
         if (!opened) {
-            process.stderr.write("gsd-db: worktree DB reconciliation failed: cannot open main DB\n");
+            logError("db", "worktree DB reconciliation failed: cannot open main DB");
             return zero;
         }
     }
@@ -1596,7 +1623,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         }
     }
     catch (err) {
-        process.stderr.write(`gsd-db: worktree DB reconciliation failed: ${err.message}\n`);
+        logError("db", "worktree DB reconciliation failed", { error: err.message });
         return { ...zero, conflicts };
     }
 }

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

@@ -8,6 +8,7 @@
 import { showNextAction } from "../shared/tui.js";
 import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { buildSkillActivationBlock } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
@@ -31,7 +32,7 @@ import { showConfirm } from "../shared/tui.js";
 import { debugLog } from "./debug-logger.js";
 import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
-import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
+import { selectAndApplyModel } from "./auto-model-selection.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,18 +54,61 @@ function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
 function buildDocsCommitInstruction(_message) {
     return "Do not commit planning artifacts — .gsd/ is managed externally.";
 }
-// ─── Auto-start after discuss ─────────────────────────────────────────────────
-/** Stashed context + flag for auto-starting after discuss phase completes */
-let pendingAutoStart = null;
-/** Returns the milestoneId being discussed, or null if no discussion is active */
-export function getDiscussionMilestoneId() {
-    return pendingAutoStart?.milestoneId ?? null;
+const pendingAutoStartMap = new Map();
+/**
+ * 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.
+ */
+function _getPendingAutoStart(basePath) {
+    if (basePath)
+        return pendingAutoStartMap.get(basePath) ?? null;
+    if (pendingAutoStartMap.size === 1)
+        return pendingAutoStartMap.values().next().value;
+    return null;
+}
+/**
+ * Store pending auto-start state for a project.
+ * Exported for testing (#2985).
+ */
+export function setPendingAutoStart(basePath, entry) {
+    pendingAutoStartMap.set(basePath, entry);
+}
+/**
+ * Clear pending auto-start state.
+ * If basePath is given, clears only that project.  Otherwise clears all.
+ * Exported for testing (#2985).
+ */
+export function clearPendingAutoStart(basePath) {
+    if (basePath) {
+        pendingAutoStartMap.delete(basePath);
+    }
+    else {
+        pendingAutoStartMap.clear();
+    }
+}
+/**
+ * Returns the milestoneId being discussed for the given project.
+ * When basePath is omitted and only one session is active, returns that
+ * session's milestoneId for backward compatibility.  Returns null when
+ * multiple sessions exist and basePath is not specified (#2985 Bug 4).
+ */
+export function getDiscussionMilestoneId(basePath) {
+    if (basePath) {
+        return pendingAutoStartMap.get(basePath)?.milestoneId ?? null;
+    }
+    // Backward compat: return the sole entry's milestoneId, or null if ambiguous
+    if (pendingAutoStartMap.size === 1) {
+        return pendingAutoStartMap.values().next().value.milestoneId;
+    }
+    return null;
 }
 /** Called from agent_end to check if auto-mode should start after discuss */
 export function checkAutoStartAfterDiscuss() {
-    if (!pendingAutoStart)
+    const entry = _getPendingAutoStart();
+    if (!entry)
         return false;
-    const { ctx, pi, basePath, milestoneId, step } = pendingAutoStart;
+    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");
@@ -142,7 +186,7 @@ export function checkAutoStartAfterDiscuss() {
         unlinkSync(manifestPath);
     }
     catch { /* may not exist for single-milestone */ }
-    pendingAutoStart = null;
+    pendingAutoStartMap.delete(basePath);
     ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
     startAuto(ctx, pi, basePath, false, { step }).catch((err) => {
         ctx.ui.notify(`Auto-start failed: ${getErrorMessage(err)}`, "error");
@@ -177,23 +221,17 @@ function parseMilestoneSequenceFromProject(content) {
  * per-phase model preferences that auto-mode uses.
  */
 async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType) {
-    // Apply model preference for this unit type (if configured)
+    // Route through the dynamic routing pipeline (complexity classification,
+    // tier downgrade, fallback chains) — same path as auto-mode dispatches (#2958).
     if (ctx && unitType) {
-        const modelConfig = resolveModelWithFallbacksForUnit(unitType);
-        if (modelConfig) {
-            const availableModels = ctx.modelRegistry.getAvailable();
-            const modelsToTry = [modelConfig.primary, ...modelConfig.fallbacks];
-            for (const modelId of modelsToTry) {
-                // Resolve model from available models (same logic as auto-model-selection)
-                const model = resolveAvailableModel(modelId, availableModels, ctx.model?.provider);
-                if (!model)
-                    continue;
-                const ok = await pi.setModel(model, { persist: false });
-                if (ok) {
-                    debugLog("guided-flow-model-applied", { unitType, model: `${model.provider}/${model.id}` });
-                    break;
-                }
-            }
+        const prefs = loadEffectiveGSDPreferences()?.preferences;
+        const result = await selectAndApplyModel(ctx, pi, unitType, /* unitId */ "", /* basePath */ process.cwd(), prefs, /* verbose */ false, /* autoModeStartModel */ null);
+        if (result.appliedModel) {
+            debugLog("guided-flow-model-applied", {
+                unitType,
+                model: `${result.appliedModel.provider}/${result.appliedModel.id}`,
+                routing: result.routing,
+            });
         }
     }
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
@@ -311,7 +349,7 @@ export async function showHeadlessMilestoneCreation(ctx, pi, basePath, seedConte
     // 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)
-    pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId };
+    pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId });
     // Dispatch — headless milestone creation is a planning activity
     await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "plan-milestone");
 }
@@ -460,13 +498,13 @@ export async function showDiscuss(ctx, pi, basePath) {
             const seed = draftContent
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
+            pendingAutoStartMap.set(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 = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
+            pendingAutoStartMap.set(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`),
@@ -476,7 +514,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: false };
+            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false });
             await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
@@ -502,8 +540,20 @@ export async function showDiscuss(ctx, pi, basePath) {
     else {
         normSlices = [];
     }
+    // DB is open but returned zero slices despite a roadmap existing —
+    // the DB may be empty due to WAL loss or truncation (see #2815, #2892).
+    // Fall back to roadmap parsing to prevent false "all complete" exit.
+    if (normSlices.length === 0 && roadmapContent) {
+        normSlices = parseRoadmapSlices(roadmapContent).map(s => ({ id: s.id, done: s.done, title: s.title }));
+    }
     const pendingSlices = normSlices.filter(s => !s.done);
     if (pendingSlices.length === 0) {
+        // All slices complete — but queued milestones may still need discussion (#3150)
+        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        if (pendingMilestones.length > 0) {
+            await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
+            return;
+        }
         ctx.ui.notify("All slices are complete — nothing to discuss.", "info");
         return;
     }
@@ -517,9 +567,14 @@ export async function showDiscuss(ctx, pi, basePath) {
             const contextFile = resolveSliceFile(basePath, mid, s.id, "CONTEXT");
             discussedMap.set(s.id, !!contextFile);
         }
-        // If all pending slices are discussed, notify and exit instead of looping
+        // If all pending slices are discussed, check for queued milestones before exiting (#3150)
         const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
         if (allDiscussed) {
+            const pendingMilestones = state.registry.filter(m => m.status === "pending");
+            if (pendingMilestones.length > 0) {
+                await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
+                return;
+            }
             const lockData = readSessionLockData(basePath);
             const remoteAutoRunning = lockData && lockData.pid !== process.pid && isSessionLockProcessAlive(lockData);
             const nextStep = remoteAutoRunning
@@ -774,7 +829,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const milestoneIds = findMilestoneIds(basePath);
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-        pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+        pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
         await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
     }
@@ -804,7 +859,14 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             return;
     }
     // ── Detection preamble — run before any bootstrap ────────────────────
-    if (!existsSync(gsdRoot(basePath))) {
+    // Check bootstrap completeness, not just .gsd/ directory existence.
+    // A zombie .gsd/ state (symlink exists but missing PREFERENCES.md and
+    // milestones/) must trigger the init wizard, not skip it (#2942).
+    const gsdPath = gsdRoot(basePath);
+    const hasBootstrapArtifacts = existsSync(gsdPath)
+        && (existsSync(join(gsdPath, "PREFERENCES.md"))
+            || existsSync(join(gsdPath, "milestones")));
+    if (!hasBootstrapArtifacts) {
         const detection = detectProjectState(basePath);
         // v1 .planning/ detected — offer migration before anything else
         if (detection.state === "v1-planning" && detection.v1) {
@@ -818,7 +880,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }
             // "fresh" — fall through to init wizard
         }
-        // No .gsd/ — run the project init wizard
+        // No .gsd/ or zombie .gsd/ — run the project init wizard
         const result = await showProjectInit(ctx, pi, basePath, detection);
         if (!result.completed)
             return; // User cancelled
@@ -869,9 +931,9 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     if (!state.activeMilestone?.id) {
         // Guard: if a discuss session is already in flight, don't re-inject the prompt.
         // Both /gsd and /gsd auto reach this branch when no milestone exists yet.
-        // Without this guard, every subsequent /gsd call overwrites pendingAutoStart
+        // Without this guard, every subsequent /gsd call overwrites the pending auto-start
         // and fires another dispatchWorkflow, resetting the conversation mid-interview.
-        if (pendingAutoStart) {
+        if (pendingAutoStartMap.has(basePath)) {
             ctx.ui.notify("Discussion already in progress — answer the question above to continue.", "info");
             return;
         }
@@ -898,7 +960,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         const isFirst = milestoneIds.length === 0;
         if (isFirst) {
             // First ever — skip wizard, just ask directly
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else {
@@ -916,7 +978,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "new_milestone") {
-                pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
                 await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
         }
@@ -948,7 +1010,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else if (choice === "status") {
@@ -994,13 +1056,13 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const seed = draftContent
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
-            pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
+            pendingAutoStartMap.set(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 = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
-            pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
+            pendingAutoStartMap.set(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`),
@@ -1010,7 +1072,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-            pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+            pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
             await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
@@ -1055,7 +1117,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "plan") {
-                pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
+                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
                 const planMilestoneTemplates = [
                     inlineTemplate("roadmap", "Roadmap"),
                     inlineTemplate("plan", "Slice Plan"),
@@ -1088,7 +1150,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
-                pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+                pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
                 await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "discard_milestone") {

package/dist/resources/extensions/gsd/health-widget-core.js

@@ -16,6 +16,31 @@ export function detectHealthWidgetProjectState(basePath) {
 function formatCost(n) {
     return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
 }
+/**
+ * Format a Unix epoch (seconds) as a human-readable relative time string.
+ * Returns "just now" for <1m, "Xm ago" for <1h, "Xh ago" for <24h, "Xd ago" otherwise.
+ */
+export function formatRelativeTime(epochSeconds) {
+    const diffSeconds = Math.floor(Date.now() / 1000) - epochSeconds;
+    if (diffSeconds < 60)
+        return "just now";
+    const minutes = Math.floor(diffSeconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+/**
+ * Truncate a commit message to fit the widget, appending "…" if needed.
+ */
+function truncateMessage(msg, maxLen) {
+    if (msg.length <= maxLen)
+        return msg;
+    return msg.slice(0, maxLen - 1) + "…";
+}
 /**
  * Build compact health lines for the widget.
  * Returns a string array suitable for setWidget().
@@ -54,5 +79,11 @@ export function buildHealthLines(data) {
     else if (data.environmentWarningCount > 0) {
         parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
     }
+    // Always-on last commit display — shows relative time + truncated message
+    if (data.lastCommitEpoch !== null && data.lastCommitEpoch > 0) {
+        const relTime = formatRelativeTime(data.lastCommitEpoch);
+        const msg = data.lastCommitMessage ? ` — ${truncateMessage(data.lastCommitMessage, 50)}` : "";
+        parts.push(`Last commit: ${relTime}${msg}`);
+    }
     return [`  ${parts.join("  │  ")}`];
 }