gsd-pi 2.52.0 → 2.53.0-dev.a67436f

package/dist/resources/extensions/gsd/auto/phases.js

@@ -15,12 +15,20 @@ import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { join } from "node:path";
 import { existsSync, cpSync } from "node:fs";
-import { logWarning } from "../workflow-logger.js";
+import { logWarning, logError } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
+/**
+ * Resolve the base path for milestone reports.
+ * Prefers originalBasePath (project root) over basePath (which may be a worktree).
+ * Exported for testing as _resolveReportBasePath.
+ */
+export function _resolveReportBasePath(s) {
+    return s.originalBasePath || s.basePath;
+}
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -30,18 +38,19 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
     const { generateHtmlReport } = await importExtensionModule(import.meta.url, "../export-html.js");
     const { writeReportSnapshot } = await importExtensionModule(import.meta.url, "../reports.js");
     const { basename } = await import("node:path");
-    const snapData = await loadVisualizerData(s.basePath);
+    const reportBasePath = _resolveReportBasePath(s);
+    const snapData = await loadVisualizerData(reportBasePath);
     const completedMs = snapData.milestones.find((m) => m.id === milestoneId);
     const msTitle = completedMs?.title ?? milestoneId;
     const gsdVersion = process.env.GSD_VERSION ?? "0.0.0";
-    const projName = basename(s.basePath);
+    const projName = basename(reportBasePath);
     const doneSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.filter((sl) => sl.done).length, 0);
     const totalSlices = snapData.milestones.reduce((acc, m) => acc + m.slices.length, 0);
     const outPath = writeReportSnapshot({
-        basePath: s.basePath,
+        basePath: reportBasePath,
         html: generateHtmlReport(snapData, {
             projectName: projName,
-            projectPath: s.basePath,
+            projectPath: reportBasePath,
             gsdVersion,
             milestoneId,
             indexRelPath: "index.html",
@@ -50,7 +59,7 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
         milestoneTitle: msTitle,
         kind: "milestone",
         projectName: projName,
-        projectPath: s.basePath,
+        projectPath: reportBasePath,
         gsdVersion,
         totalCost: snapData.totals?.cost ?? 0,
         totalTokens: snapData.totals?.tokens.total ?? 0,
@@ -160,8 +169,11 @@ export async function runPreDispatch(ic, loopState) {
                 await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                 return { action: "break", reason: "merge-conflict" };
             }
-            // Non-conflict merge errors — log and continue
-            logWarning("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+            // Non-conflict merge errors — stop auto to avoid advancing with unmerged work
+            logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+            ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+            await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+            return { action: "break", reason: "merge-failed" };
         }
         // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
@@ -228,6 +240,10 @@ export async function runPreDispatch(ic, loopState) {
                         await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                         return { action: "break", reason: "merge-conflict" };
                     }
+                    logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+                    ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+                    await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+                    return { action: "break", reason: "merge-failed" };
                 }
                 // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
             }
@@ -295,6 +311,10 @@ export async function runPreDispatch(ic, loopState) {
                     await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                     return { action: "break", reason: "merge-conflict" };
                 }
+                logError("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
+                ctx.ui.notify(`Merge failed: ${mergeErr instanceof Error ? mergeErr.message : String(mergeErr)}. Resolve and run /gsd auto to resume.`, "error");
+                await deps.stopAuto(ctx, pi, `Merge error on milestone ${s.currentMilestoneId}: ${String(mergeErr)}`);
+                return { action: "break", reason: "merge-failed" };
             }
             // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         }

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

@@ -531,8 +531,12 @@ export const DISPATCH_RULES = [
                         if (validationPath) {
                             const validationContent = await loadFile(validationPath);
                             if (validationContent) {
-                                const hasOperationalCheck = validationContent.includes("Operational") &&
+                                // Accept either the structured template format (table with MET/N/A)
+                                // or prose evidence patterns the validation agent may emit.
+                                const structuredMatch = validationContent.includes("Operational") &&
                                     (validationContent.includes("MET") || validationContent.includes("N/A"));
+                                const proseMatch = /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(validationContent);
+                                const hasOperationalCheck = structuredMatch || proseMatch;
                                 if (!hasOperationalCheck) {
                                     return {
                                         action: "stop",

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

@@ -104,6 +104,21 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
         }
     }
 }
+// ─── Build Artifact Auto-Resolve ─────────────────────────────────────────────
+/** Patterns for machine-generated build artifacts that can be safely
+ * auto-resolved by accepting --theirs during merge. These files are
+ * regenerable and never contain meaningful manual edits. */
+export const SAFE_AUTO_RESOLVE_PATTERNS = [
+    /\.tsbuildinfo$/,
+    /\.pyc$/,
+    /\/__pycache__\//,
+    /\.DS_Store$/,
+    /\.map$/,
+];
+/** Returns true if the file path is safe to auto-resolve during merge.
+ * Covers `.gsd/` state files and common build artifacts. */
+export const isSafeToAutoResolve = (filePath) => filePath.startsWith(".gsd/") ||
+    SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
 // ─── Dispatch-Level Sync (project root ↔ worktree) ──────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -1191,27 +1206,27 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             ? mergeResult.conflicts
             : nativeConflictFiles(originalBasePath_);
         if (conflictedFiles.length > 0) {
-            // Separate .gsd/ state file conflicts from real code conflicts.
-            // GSD state files (STATE.md, auto.lock, etc.)
-            // diverge between branches during normal operation — always prefer the
-            // milestone branch version since it has the latest execution state.
-            const gsdConflicts = conflictedFiles.filter((f) => f.startsWith(".gsd/"));
-            const codeConflicts = conflictedFiles.filter((f) => !f.startsWith(".gsd/"));
-            // Auto-resolve .gsd/ conflicts by accepting the milestone branch version
-            if (gsdConflicts.length > 0) {
-                for (const gsdFile of gsdConflicts) {
+            // Separate auto-resolvable conflicts (GSD state files + build artifacts)
+            // from real code conflicts. GSD state files diverge between branches
+            // during normal operation. Build artifacts are machine-generated and
+            // regenerable. Both are safe to accept from the milestone branch.
+            const autoResolvable = conflictedFiles.filter(isSafeToAutoResolve);
+            const codeConflicts = conflictedFiles.filter((f) => !isSafeToAutoResolve(f));
+            // Auto-resolve safe conflicts by accepting the milestone branch version
+            if (autoResolvable.length > 0) {
+                for (const safeFile of autoResolvable) {
                     try {
-                        nativeCheckoutTheirs(originalBasePath_, [gsdFile]);
-                        nativeAddPaths(originalBasePath_, [gsdFile]);
+                        nativeCheckoutTheirs(originalBasePath_, [safeFile]);
+                        nativeAddPaths(originalBasePath_, [safeFile]);
                     }
                     catch {
                         // If checkout --theirs fails, try removing the file from the merge
                         // (it's a runtime file that shouldn't be committed anyway)
-                        nativeRmForce(originalBasePath_, [gsdFile]);
+                        nativeRmForce(originalBasePath_, [safeFile]);
                     }
                 }
             }
-            // If there are still non-.gsd conflicts, escalate
+            // If there are still real code conflicts, escalate
             if (codeConflicts.length > 0) {
                 // Pop stash before throwing so local work is not lost (#2151).
                 if (stashed) {
@@ -1256,7 +1271,48 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             });
         }
         catch {
-            // Stash pop conflict is non-fatal — stash entry persists for manual resolution.
+            // Stash pop after squash merge can conflict on .gsd/ state files that
+            // diverged between branches.  Left unresolved, these UU entries block
+            // every subsequent merge.  Auto-resolve them the same way we handle
+            // .gsd/ conflicts during the merge itself: accept HEAD (the just-committed
+            // version) and drop the now-applied stash.
+            const uu = nativeConflictFiles(originalBasePath_);
+            const gsdUU = uu.filter((f) => f.startsWith(".gsd/"));
+            const nonGsdUU = uu.filter((f) => !f.startsWith(".gsd/"));
+            if (gsdUU.length > 0) {
+                for (const f of gsdUU) {
+                    try {
+                        // Accept the committed (HEAD) version of the state file
+                        execFileSync("git", ["checkout", "HEAD", "--", f], {
+                            cwd: originalBasePath_,
+                            stdio: ["ignore", "pipe", "pipe"],
+                            encoding: "utf-8",
+                        });
+                        nativeAddPaths(originalBasePath_, [f]);
+                    }
+                    catch {
+                        // Last resort: remove the conflicted state file
+                        nativeRmForce(originalBasePath_, [f]);
+                    }
+                }
+            }
+            if (nonGsdUU.length === 0) {
+                // All conflicts were .gsd/ files — safe to drop the stash
+                try {
+                    execFileSync("git", ["stash", "drop"], {
+                        cwd: originalBasePath_,
+                        stdio: ["ignore", "pipe", "pipe"],
+                        encoding: "utf-8",
+                    });
+                }
+                catch { /* stash may already be consumed */ }
+            }
+            else {
+                // Non-.gsd conflicts remain — leave stash for manual resolution
+                logWarning("reconcile", "Stash pop conflict on non-.gsd files after merge", {
+                    files: nonGsdUU.join(", "),
+                });
+            }
         }
     }
     // 9b. Safety check (#1792): if nothing was committed, verify the milestone

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

@@ -215,6 +215,12 @@ export function stopAutoRemote(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
         return { found: false };
+    // Never SIGTERM ourselves — a stale lock with our own PID is not a remote
+    // session, it is leftover from a prior loop exit in this process. (#2730)
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
     if (!isLockProcessAlive(lock)) {
         // Stale lock — clean it up
         clearLock(projectRoot);
@@ -239,6 +245,10 @@ export function checkRemoteAutoSession(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
         return { running: false };
+    // Our own PID is not a "remote" session — it is a stale lock left by this
+    // process (e.g. after step-mode exit without full cleanup). (#2730)
+    if (lock.pid === process.pid)
+        return { running: false };
     if (!isLockProcessAlive(lock)) {
         // Stale lock from a dead process — not a live remote session
         return { running: false };
@@ -321,6 +331,18 @@ function cleanupAfterLoopExit(ctx) {
     s.currentUnit = null;
     s.active = false;
     clearUnitTimeout();
+    // Clear crash lock and release session lock so the next `/gsd next` does
+    // not see a stale lock with the current PID and treat it as a "remote"
+    // session (which would cause it to SIGTERM itself). (#2730)
+    try {
+        if (lockBase())
+            clearLock(lockBase());
+        if (lockBase())
+            releaseSessionLock(lockBase());
+    }
+    catch {
+        /* best-effort — mirror stopAuto cleanup */
+    }
     ctx.ui.setStatus("gsd-auto", undefined);
     ctx.ui.setWidget("gsd-progress", undefined);
     ctx.ui.setFooter(undefined);

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -77,15 +77,9 @@ export async function handleAgentEnd(pi, event, ctx) {
             retryState.currentRetryModelId = undefined;
             ctx.ui.notify(`Network retries exhausted for ${currentModelId}. Attempting model fallback.`, "warning");
         }
-        // --- Rate limit: skip model fallback, go straight to pause ---
-        // Rate-limiting is a provider issue, not a model issue.
-        // Switching models won't help if the provider is throttling you.
-        if (cls.kind === "rate-limit") {
-            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, true);
-            return;
-        }
-        // --- Server/connection/stream errors: try model fallback first ---
-        if (cls.kind === "network" || cls.kind === "server" || cls.kind === "connection" || cls.kind === "stream") {
+        // --- Transient errors: try model fallback first, then pause ---
+        // Rate limits are often per-model, so switching models can bypass them.
+        if (cls.kind === "rate-limit" || cls.kind === "network" || cls.kind === "server" || cls.kind === "connection" || cls.kind === "stream") {
             // Try model fallback
             const dash = getAutoDashboardData();
             if (dash.currentUnit) {
@@ -128,7 +122,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         }
         // --- Transient fallback: pause with auto-resume ---
         if (isTransient(cls)) {
-            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, false);
+            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, cls.kind === "rate-limit");
             return;
         }
         // --- Permanent / unknown: pause indefinitely ---

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -337,7 +337,7 @@ async function configureGit(ctx, prefs) {
     const gitBooleanFields = [
         { key: "auto_push", label: "Auto-push commits after committing", defaultVal: false },
         { key: "push_branches", label: "Push milestone branches to remote", defaultVal: false },
-        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: false },
+        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: true },
     ];
     for (const field of gitBooleanFields) {
         const current = git[field.key];
@@ -361,7 +361,7 @@ async function configureGit(ctx, prefs) {
     }
     // pre_merge_check
     const currentPreMerge = git.pre_merge_check !== undefined ? String(git.pre_merge_check) : "";
-    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: false)"}:`, ["true", "false", "auto", "(keep current)"]);
+    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: auto)"}:`, ["true", "false", "auto", "(keep current)"]);
     if (preMergeChoice && preMergeChoice !== "(keep current)") {
         if (preMergeChoice === "auto") {
             git.pre_merge_check = "auto";
@@ -487,7 +487,7 @@ export async function configureMode(ctx, prefs) {
     if (modeStr && modeStr !== "(keep current)") {
         if (modeStr.startsWith("solo")) {
             prefs.mode = "solo";
-            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=false, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
+            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=auto, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
         }
         else if (modeStr.startsWith("team")) {
             prefs.mode = "team";

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -126,8 +126,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `auto_push`: boolean — automatically push commits to the remote after committing. Default: `false`.
   - `push_branches`: boolean — push the milestone branch to the remote after commits. Default: `false`.
   - `remote`: string — git remote name to push to. Default: `"origin"`.
-  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `false`.
-  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `false`.
+  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `true`.
+  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `"auto"`.
   - `commit_type`: string — override the conventional commit type prefix. Must be one of: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`, `perf`, `ci`, `build`, `style`. Default: inferred from diff content.
   - `main_branch`: string — the primary branch name for new git repos (e.g., `"main"`, `"master"`, `"trunk"`). Also used by `getMainBranch()` as the preferred branch when auto-detection is ambiguous. Default: `"main"`.
   - `merge_strategy`: `"squash"` or `"merge"` — controls how worktree branches are merged back. `"squash"` combines all commits into one; `"merge"` preserves individual commits. Default: `"squash"`.

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

@@ -446,11 +446,12 @@ export class GitServiceImpl {
     }
     /**
      * Create a snapshot ref for the given label (typically a slice branch name).
-     * Gated on prefs.snapshots === true. Ref path: refs/gsd/snapshots/<label>/<timestamp>
+     * Enabled by default; opt out with prefs.snapshots === false.
+     * Ref path: refs/gsd/snapshots/<label>/<timestamp>
      * The ref points at HEAD, capturing the current commit before destructive operations.
      */
     createSnapshot(label) {
-        if (this.prefs.snapshots !== true)
+        if (this.prefs.snapshots === false)
             return;
         const now = new Date();
         const ts = now.getFullYear().toString()
@@ -470,7 +471,7 @@ export class GitServiceImpl {
      * Stub: to be implemented in T03.
      */
     runPreMergeCheck() {
-        if (this.prefs.pre_merge_check === false || this.prefs.pre_merge_check === undefined) {
+        if (this.prefs.pre_merge_check === false) {
             return { passed: true, skipped: true };
         }
         // Determine command: explicit string or auto-detect from package.json

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

@@ -408,8 +408,9 @@ export async function showDiscuss(ctx, pi, basePath) {
     // Invalidate caches to pick up artifacts written by a just-completed discuss/plan
     invalidateAllCaches();
     const state = await deriveState(basePath);
-    // No active milestone — check for pending milestones to discuss instead
-    if (!state.activeMilestone) {
+    // No active milestone (or corrupted milestone with undefined id) —
+    // check for pending milestones to discuss instead
+    if (!state.activeMilestone?.id) {
         const pendingMilestones = state.registry.filter(m => m.status === "pending");
         if (pendingMilestones.length === 0) {
             ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
@@ -864,7 +865,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         }
     }
     const state = await deriveState(basePath);
-    if (!state.activeMilestone) {
+    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

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -8,6 +8,7 @@
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
@@ -262,7 +263,7 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     lines.push("## Tasks");
     lines.push("");
     for (const task of tasks) {
-        const done = task.status === "done" || task.status === "complete" ? "x" : " ";
+        const done = isClosedStatus(task.status) ? "x" : " ";
         const estimate = task.estimate.trim() ? ` \`est:${task.estimate.trim()}\`` : "";
         lines.push(`- [${done}] **${task.id}: ${task.title || task.id}**${estimate}`);
         if (task.description.trim()) {
@@ -435,7 +436,7 @@ export async function renderPlanCheckboxes(basePath, milestoneId, sliceId) {
     // Apply checkbox patches for each task
     let updated = content;
     for (const task of tasks) {
-        const isDone = task.status === "done" || task.status === "complete";
+        const isDone = isClosedStatus(task.status);
         const tid = task.id;
         if (isDone) {
             // Set [x]
@@ -660,7 +661,7 @@ export function detectStaleRenders(basePath) {
                     const content = readFileSync(planPath, "utf-8");
                     const parsed = parsePlan(content);
                     for (const task of tasks) {
-                        const isDoneInDb = task.status === "done" || task.status === "complete";
+                        const isDoneInDb = isClosedStatus(task.status);
                         const planTask = parsed.tasks.find((t) => t.id === task.id);
                         if (!planTask)
                             continue;
@@ -684,7 +685,7 @@ export function detectStaleRenders(basePath) {
             }
             // Check missing task summary files
             for (const task of tasks) {
-                if ((task.status === "done" || task.status === "complete") && task.full_summary_md) {
+                if (isClosedStatus(task.status) && task.full_summary_md) {
                     const slicePath = resolveSlicePath(basePath, milestone.id, slice.id);
                     if (slicePath) {
                         const tasksDir = join(slicePath, "tasks");

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -131,8 +131,15 @@ function appendWorkerLog(basePath, milestoneId, chunk) {
     }
 }
 function restoreRuntimeState(basePath) {
-    if (state?.active)
-        return true;
+    if (state?.active) {
+        // Verify at least one worker is alive — if all are in terminal states,
+        // the cached state is stale and we should fall through to cleanup.
+        const hasLiveWorker = [...state.workers.values()].some((w) => w.state !== "error" && w.state !== "stopped");
+        if (hasLiveWorker)
+            return true;
+        // All workers dead — clear stale state so restoreState() can clean up.
+        state = null;
+    }
     const restored = restoreState(basePath);
     if (restored && restored.workers.length > 0) {
         const config = resolveParallelConfig(undefined);
@@ -778,6 +785,15 @@ export function refreshWorkerStatuses(basePath, options = {}) {
     for (const worker of state.workers.values()) {
         state.totalCost += worker.cost;
     }
+    // If all workers are in a terminal state (error/stopped), the orchestration
+    // is finished — deactivate and clean up so zombie workers don't persist.
+    const allDead = [...state.workers.values()].every((w) => w.state === "error" || w.state === "stopped");
+    if (allDead) {
+        state.active = false;
+        removeStateFile(basePath);
+        state = null;
+        return;
+    }
     // Persist updated state for crash recovery
     persistState(basePath);
 }

package/dist/resources/extensions/gsd/preferences-types.js

@@ -11,7 +11,7 @@ export const MODE_DEFAULTS = {
         git: {
             auto_push: true,
             push_branches: false,
-            pre_merge_check: false,
+            pre_merge_check: "auto",
             merge_strategy: "squash",
             isolation: "none",
         },

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

@@ -6,6 +6,7 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
@@ -39,19 +40,13 @@ export function isMilestoneComplete(roadmap) {
     return roadmap.slices.length > 0 && roadmap.slices.every(s => s.done);
 }
 /**
- * Check whether a VALIDATION file's verdict is terminal (pass or needs-attention).
- * A non-terminal verdict (needs-remediation) means validation must re-run
- * after remediation slices are executed.
+ * Check whether a VALIDATION file's verdict is terminal.
+ * Any successfully extracted verdict (pass, needs-attention, needs-remediation,
+ * fail, etc.) means validation completed. Only return false when no verdict
+ * could be parsed — i.e. extractVerdict() returns undefined (#2769).
  */
 export function isValidationTerminal(validationContent) {
-    const v = extractVerdict(validationContent);
-    if (!v)
-        return false;
-    // 'pass' and 'needs-attention' are always terminal.
-    // 'needs-remediation' is treated as terminal to prevent infinite loops
-    // when no remediation slices exist in the roadmap (#832). The validation
-    // report is preserved on disk for manual review.
-    return v === 'pass' || v === 'needs-attention' || v === 'needs-remediation';
+    return extractVerdict(validationContent) != null;
 }
 const CACHE_TTL_MS = 100;
 let _stateCache = null;
@@ -203,12 +198,6 @@ function extractContextTitle(content, fallback) {
     return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
 }
 // ─── DB-backed State Derivation ────────────────────────────────────────────
-/**
- * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
- */
-function isStatusDone(status) {
-    return status === 'complete' || status === 'done';
-}
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -292,7 +281,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isStatusDone(m.status)) {
+        if (isClosedStatus(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -304,7 +293,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Check roadmap: all slices done means milestone is complete
         const slices = getMilestoneSlices(m.id);
-        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
+        if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
             // All slices done but no summary — still counts as complete for dep resolution
             // if a summary file exists
             // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -323,7 +312,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Ghost milestone check: no slices in DB AND no substantive files on disk
         const slices = getMilestoneSlices(m.id);
-        if (slices.length === 0 && !isStatusDone(m.status)) {
+        if (slices.length === 0 && !isClosedStatus(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -344,7 +333,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -484,7 +473,7 @@ export async function deriveStateFromDb(basePath) {
     // Guard: [].every() === true (vacuous truth). Without the length check,
     // an empty slice array causes a premature phase transition to
     // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
-    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isStatusDone(s.status));
+    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -514,14 +503,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
+        if (isClosedStatus(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -561,7 +550,7 @@ export async function deriveStateFromDb(basePath) {
     // causing the dispatcher to re-dispatch the same completed task forever.
     let reconciled = false;
     for (const t of tasks) {
-        if (isStatusDone(t.status))
+        if (isClosedStatus(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
@@ -581,10 +570,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isStatusDone(t.status)).length,
+        done: tasks.filter(t => isClosedStatus(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -639,7 +628,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isStatusDone(t.status));
+    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {

package/dist/resources/extensions/gsd/status-guards.js

@@ -0,0 +1,12 @@
+/**
+ * Status predicates for GSD state-machine guards.
+ *
+ * The DB stores status as free-form strings. Two values indicate
+ * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * Every inline `status === "complete" || status === "done"` should
+ * use isClosedStatus() instead.
+ */
+/** Returns true when a milestone, slice, or task status indicates closure. */
+export function isClosedStatus(status) {
+    return status === "complete" || status === "done";
+}