gsd-pi 2.52.0 → 2.53.0-dev.07ffe51

package/README.md

@@ -27,55 +27,78 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.46.0
+## What's New in v2.52.0
 
-### Single-Writer State Engine
+### VS Code Extension & Web UI
 
-The biggest architectural change since DB-backed planning tools. The single-writer engine enforces disciplined state transitions through three iterations:
+- **VS Code integration** — status bar, file decorations, bash terminal, session tree, conversation history, and code lens. (#2651)
+- **Dark mode contrast** — raised token floor and flattened opacity tier system for better readability. (#2734)
+- **Auth token gate** — synthetic 401 on missing token, unauthenticated boot state, and recovery screen. (#2740)
 
-- **v2 — discipline layer** — adds a write-side discipline layer on top of the DB architecture, ensuring all state mutations flow through controlled tool calls.
-- **v3 — state machine guards, actor identity, reversibility** — introduces formal state machine guards, tracks which actor (human vs agent) initiated each transition, and makes transitions reversible.
-- **Hardened** — closes TOCTOU race conditions, intercepts bypass attempts, and resolves status inconsistencies.
+### Capability Metadata & Model Routing
 
-All prompts are now aligned with the single-writer tool API, and a new **workflow-logger** is wired into the engine, tool, manifest, and reconcile paths for full observability. (#2494)
-
-### v2.45.0 — New Commands and Capabilities
-
-- **`/gsd rethink`** — conversational project reorganization. Rethink your milestone structure, slice decomposition, or overall approach through guided discussion. (#2459)
-- **`/gsd mcp`** — MCP server status and connectivity. Check which MCP servers are configured, connected, and healthy. (#2362)
-- **Complete offline mode** — GSD now works fully offline with local models. (#2429)
-- **Global KNOWLEDGE.md injection** — `~/.gsd/agent/KNOWLEDGE.md` is injected into the system prompt, so cross-project knowledge persists globally. (#2331)
-- **Mobile-responsive web UI** — the browser interface now works on phones and tablets. (#2354)
-- **DB tool previews** — `renderCall`/`renderResult` previews on DB tools show what each tool call does before and after execution. (#2273)
-- **Message timestamps** — user and assistant messages now include timestamps. (#2368)
+- **Capability-based model selection** — replaced model-ID pattern matching with capability metadata, making custom provider integration more reliable. (#2548)
 
 ### Key Changes
 
-- **Default isolation mode changed to `none`** — `git.isolation` now defaults to `none` instead of `worktree`. Projects that rely on worktree isolation should set `git.isolation: worktree` explicitly in preferences. (#2481)
-- **Startup checks** — GSD now validates Node.js version and git availability at startup, with clear error messages. (#2463)
-- **Worktree lifecycle journaling** — worktree create, switch, merge, and remove events are recorded in the event journal. (#2486)
-- **Milestone verification gate** — milestone completion is blocked when verification fails, preventing premature closure. (#2500)
+- **`--bare` mode** — wired across headless, pi-coding-agent, and resource-loader for minimal-output operation.
+- **RPC protocol v2** — new types, init handshake with version detection, and runId generation on prompt/steer/follow_up commands.
+- **PREFERENCES.md rename** — `preferences.md` renamed to `PREFERENCES.md` for consistency. (#2700, #2738)
+- **Comprehensive SQLite audit** — indexes, caching, safety, and reconciliation fixes across gsd-db.
+- **Unified error classifier** — three overlapping error classifiers consolidated into a single classify-decide-act pipeline.
 
 ### Key Fixes
 
-- **Auto-mode stability** — recovery attempts reset on unit re-dispatch (#2424), survivor branch recovery handles `phase=complete` (#2427), and auto mode stops on real merge conflicts (#2428).
-- **Supervision timeouts** — now respect task `est:` annotations, so complex tasks get proportionally longer timeouts. (#2434)
-- **`auto_pr: true` fixed** — three interacting bugs prevented auto-PR creation; all three are resolved. (#2433)
-- **Rich task plan preservation** — plans survive DB roundtrip without losing structured content. (#2453)
-- **Artifact truncation prevention** — `saveArtifactToDb` no longer overwrites larger files with truncated content. (#2447)
-- **Worktree teardown** — submodule state is detected and preserved during teardown (#2425), and worktree merge back to main works after `stopAuto` on milestone completion (#2430).
-- **Windows portability** — `retentionDays=0` handling and CRLF fixes on Windows. (#2460)
-- **Voice on Linux** — misleading portaudio error on PEP 668 systems replaced with actionable guidance. (#2407)
+- **Auto-mode stops on provider errors** — auto loop now halts after provider errors instead of retrying indefinitely. (#2762, #2764)
+- **Transaction safety** — state machine guards moved inside transactions in 5 tool handlers (#2752), and `transaction()` made re-entrant.
+- **Worktree seeding** — `preferences.md` seeded into auto-mode worktrees and included in worktree sync. (#2693)
+- **Idle watchdog** — interactive tools exempted from stall detection (#2676), and filesystem activity no longer overrides stalled-tool detection. (#2697)
+- **Milestone guards** — `allSlicesDone` guarded against vacuous truth on empty slice arrays (#2679), and `complete-milestone` dispatch blocked when validation is `needs-remediation`. (#2682)
+- **Docker overhaul** — fragile setup replaced with proven container patterns. (#2716)
+- **Windows** — EINVAL prevented by disabling detached process groups on Win32. (#2744)
+- **Audit log** — `setLogBasePath` wired into engine init to resurrect audit logging. (#2745)
+
+### v2.51.0 — Skills, RTK, and Verification
+
+- **`/terminal` command** — direct shell execution from the slash command interface. (#2349)
+- **Managed RTK integration** — RTK binary auto-provisioned with opt-in preference and web UI toggle. (#2620)
+- **Verification classes** — compliance checked before milestone completion, with classes injected into validation prompts. (#2621, #2623)
+- **Skills overhaul** — 30+ new skill packs covering major frameworks, databases, and cloud platforms; curated catalog with `~/.agents/skills/` as primary directory.
+
+### v2.50.0 — Quality Gates
+
+- **Quality gates** — 8-question quality gates added to planning and completion templates, with parallel evaluation via `evaluating-gates` phase.
+- **Structured error propagation** — errors wired through `UnitResult` for better diagnostics.
+
+### v2.49.0 — Git Trailers & Yolo Mode
+
+- **`--yolo` flag** — `/gsd auto --yolo` for non-interactive project init.
+- **Git trailers** — GSD metadata moved from commit subject scopes to git trailers.
+
+### v2.48.0 — Forensics & Discussion
+
+- **`/gsd discuss` for queued milestones** — target milestones still in the queue. (#2349)
+- **Enhanced forensics** — journal and activity log awareness added to `/gsd forensics`.
+
+### v2.47.0 — External Providers
+
+- **External tool execution mode** — `externalToolExecution` mode for external providers in agent-core.
+- **Claude Code CLI provider** — new provider extension for Claude Code CLI. (#2382)
 
-### Previous highlights (v2.42–v2.44)
+### Previous highlights (v2.42–v2.46)
 
+- **Single-writer state engine** — disciplined state transitions with machine guards, actor identity, reversibility, and TOCTOU hardening. (#2494)
+- **`/gsd rethink`** — conversational project reorganization. (#2459)
+- **`/gsd mcp`** — MCP server status and connectivity. (#2362)
+- **Complete offline mode** — fully offline with local models. (#2429)
+- **Global KNOWLEDGE.md injection** — cross-project knowledge via `~/.gsd/agent/KNOWLEDGE.md`. (#2331)
+- **Mobile-responsive web UI** — browser interface works on phones and tablets. (#2354)
+- **Default isolation mode changed to `none`** — set `git.isolation: worktree` explicitly if needed. (#2481)
 - **Non-API-key provider extensions** — support for Claude Code CLI and similar providers. (#2382)
 - **Docker sandbox template** — official Docker template for isolated auto mode. (#2360)
 - **DB-backed planning tools** — write-side state transitions use atomic SQLite tool calls. (#2141)
 - **Declarative workflow engine** — YAML workflows through auto-loop. (#2024)
 - **`/gsd fast`** — toggle service tier for prioritized API routing. (#1862)
-- **Forensics dedup** — duplicate detection before issue creation. (#2105)
-- **Startup optimizations** — pre-compiled extensions, compile cache, batch discovery. (#2125)
 
 ---
 

package/dist/headless-query.js

@@ -36,7 +36,7 @@ export async function handleQuery(basePath) {
     const state = await deriveState(basePath);
     // Derive next dispatch action
     let next;
-    if (!state.activeMilestone) {
+    if (!state.activeMilestone?.id) {
         next = {
             action: 'stop',
             reason: state.phase === 'complete' ? 'All milestones complete.' : state.nextAction,

package/dist/resources/extensions/get-secrets-from-user.js

@@ -25,6 +25,11 @@ function maskPreview(value) {
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function hydrateProcessEnv(key, value) {
+    // Make newly collected secrets immediately visible to the current session.
+    // Some extensions read process.env directly and do not reload .env on every call.
+    process.env[key] = value;
+}
 async function writeEnvKey(filePath, key, value) {
     let content = "";
     try {
@@ -246,6 +251,7 @@ async function applySecrets(provided, destination, opts) {
             try {
                 await writeEnvKey(opts.envFilePath, key, value);
                 applied.push(key);
+                hydrateProcessEnv(key, value);
             }
             catch (err) {
                 errors.push(`${key}: ${err.message}`);
@@ -265,6 +271,7 @@ async function applySecrets(provided, destination, opts) {
                 }
                 else {
                     applied.push(key);
+                    hydrateProcessEnv(key, value);
                 }
             }
             catch (err) {

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",
         },