gsd-pi 2.52.0-dev.585e355 → 2.52.0-dev.655ad8a

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/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/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/state.js

@@ -40,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;

package/dist/resources/extensions/shared/rtk.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
 const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
+const GSD_RTK_REWRITE_TIMEOUT_MS_ENV = "GSD_RTK_REWRITE_TIMEOUT_MS";
 const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
 const RTK_REWRITE_TIMEOUT_MS = 5_000;
 function isTruthy(value) {
@@ -12,6 +13,13 @@ function isTruthy(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "1" || normalized === "true" || normalized === "yes";
 }
+function getRewriteTimeoutMs(env = process.env) {
+    const configured = Number.parseInt(env[GSD_RTK_REWRITE_TIMEOUT_MS_ENV] ?? "", 10);
+    if (Number.isFinite(configured) && configured > 0) {
+        return configured;
+    }
+    return RTK_REWRITE_TIMEOUT_MS;
+}
 export function isRtkEnabled(env = process.env) {
     return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
 }
@@ -89,7 +97,7 @@ export function rewriteCommandWithRtk(command, options = {}) {
         encoding: "utf-8",
         env: buildRtkEnv(env),
         stdio: ["ignore", "pipe", "ignore"],
-        timeout: RTK_REWRITE_TIMEOUT_MS,
+        timeout: getRewriteTimeoutMs(env),
         // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
         shell: /\.(cmd|bat)$/i.test(binaryPath),
     });

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-KTe1kB5nPLQFIIFz2OcmI
+zpvUPKoW5jRAMB_fWHlPi

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -2,45 +2,45 @@
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
-  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/boot/route": "/api/boot",
+  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/cleanup/route": "/api/cleanup",
+  "/api/dev-mode/route": "/api/dev-mode",
   "/api/doctor/route": "/api/doctor",
   "/api/browse-directories/route": "/api/browse-directories",
-  "/api/export-data/route": "/api/export-data",
-  "/api/cleanup/route": "/api/cleanup",
   "/api/captures/route": "/api/captures",
-  "/api/dev-mode/route": "/api/dev-mode",
-  "/api/git/route": "/api/git",
+  "/api/export-data/route": "/api/export-data",
   "/api/forensics/route": "/api/forensics",
+  "/api/git/route": "/api/git",
   "/api/history/route": "/api/history",
   "/api/hooks/route": "/api/hooks",
+  "/api/knowledge/route": "/api/knowledge",
   "/api/inspect/route": "/api/inspect",
   "/api/experimental/route": "/api/experimental",
-  "/api/knowledge/route": "/api/knowledge",
   "/api/live-state/route": "/api/live-state",
-  "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
+  "/api/preferences/route": "/api/preferences",
+  "/api/onboarding/route": "/api/onboarding",
   "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
-  "/api/onboarding/route": "/api/onboarding",
   "/api/session/command/route": "/api/session/command",
-  "/api/session/manage/route": "/api/session/manage",
   "/api/session/events/route": "/api/session/events",
   "/api/settings-data/route": "/api/settings-data",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/shutdown/route": "/api/shutdown",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
   "/api/terminal/input/route": "/api/terminal/input",
   "/api/switch-root/route": "/api/switch-root",
+  "/api/files/route": "/api/files",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
-  "/api/remote-questions/route": "/api/remote-questions",
-  "/api/terminal/upload/route": "/api/terminal/upload",
-  "/api/files/route": "/api/files",
-  "/api/visualizer/route": "/api/visualizer",
   "/api/update/route": "/api/update",
+  "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/undo/route": "/api/undo",
+  "/api/remote-questions/route": "/api/remote-questions",
+  "/api/visualizer/route": "/api/visualizer",
   "/page": "/"
 }