gsd-pi 2.44.0 → 2.45.0

package/README.md

@@ -24,10 +24,34 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.42.0
+## What's New in v2.44.0
 
 ### New Features
 
+- **Non-API-key provider extensions** — support for provider extensions like Claude Code CLI that don't require traditional API keys. (#2382)
+- **Docker sandbox template** — official Docker template for running GSD auto mode in an isolated container. (#2360)
+- **Per-prompt token cost display** — opt-in `show_token_cost` preference shows per-prompt and cumulative session cost in the footer. (#2357)
+- **"Change project root" in web UI** — switch project directories from the web interface without restarting. (#2355)
+- **DB-backed planning tools** — write-side state transitions now use atomic SQLite tool calls instead of markdown mutation, improving reliability and enabling structured queries. (#2141)
+
+### Key Fixes
+
+- **Post-migration cleanup** — pragmas, rollbacks, tool gaps, and stale code cleaned up after DB migration. (#2410)
+- **Planning data loss prevention** — destructive upsert and post-unit re-import no longer overwrite planning data. (#2370)
+- **Memory and resource leaks** — fixes across TUI, LSP, DB, and automation subsystems. (#2314)
+- **DECISIONS.md preservation** — freeform content in DECISIONS.md is no longer overwritten on decision save. (#2319)
+- **Auto-stash before squash merge** — dirty files are automatically stashed before merge, with filenames surfaced in errors. (#2298)
+- **Extension TypeScript detection** — `.js` extension files containing TypeScript syntax are detected with a suggestion to rename. (#2386)
+
+### v2.43.0 Highlights
+
+- **Forensics dedup** — opt-in duplicate detection before issue creation. (#2105)
+- **Fast service tier outside auto-mode** — `/gsd fast` now applies in interactive sessions too. (#2126)
+- **Startup optimizations** — pre-compiled extensions, compile cache, and batch discovery for faster boot. (#2125)
+- **Stale process cleanup** — web server kills stale process before launch to prevent EADDRINUSE. (#2034)
+
+### v2.42.0 Highlights
+
 - **Declarative workflow engine** — define YAML workflows that execute through auto-loop, enabling repeatable multi-step automations without code. (#2024)
 - **Unified rule registry & event journal** — centralized rule registry, event journal with query tool, and standardized tool naming convention. (#1928)
 - **PR risk checker** — CI classifies changed files by system area and surfaces risk level on pull requests. (#1930)
@@ -35,16 +59,6 @@ One command. Walk away. Come back to a built project with clean git history.
 - **Web mode CLI flags** — `--host`, `--port`, and `--allowed-origins` flags give full control over the web server bind address and CORS policy. (#1873)
 - **ADR attribution** — architecture decision records now distinguish human, agent, and collaborative authorship. (#1830)
 
-### Key Fixes
-
-- **Node v24 web boot** — resolved `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` that prevented `gsd --web` from starting on Node v24. (#1864)
-- **Worktree health check for all ecosystems** — broadened from JS-only to 17+ ecosystems (Rust, Go, Python, Java, etc.). (#1860)
-- **Doctor roadmap atomicity** — roadmap checkbox gating now checks summary on disk, not issue detection, preventing false unchecks. (#1915)
-- **Windows path handling** — 8.3 short path resolution, backslash normalization in bash commands, PowerShell browser launch, and parenthesis escaping. (#1960, #1863, #1870, #1872)
-- **Auth token persistence** — web UI auth token survives page refreshes via sessionStorage. (#1877)
-- **German/non-English locale git errors** — git commands now force `LC_ALL=C` to prevent locale-dependent parse failures.
-- **Orphan web server process** — stale web server processes on port 3000 are now cleaned up automatically.
-
 ---
 
 ## What's New in v2.41.0
@@ -107,12 +121,14 @@ This release includes 7 fixes preventing silent data loss in auto-mode:
 
 See the full [Changelog](./CHANGELOG.md) for all 70+ fixes in this release.
 
-### Previous highlights (v2.39–v2.40)
+### Previous highlights (v2.39–v2.41)
 
+- **Browser-based web interface** — run GSD from the browser with `gsd --web`
 - **GitHub sync extension** — auto-sync milestones to GitHub Issues, PRs, and Milestones
 - **Skill tool resolution** — skills auto-activate in dispatched prompts
 - **Health check phase 2** — real-time doctor issues in dashboard and visualizer
 - **Forensics upgrade** — full-access GSD debugger with anomaly detection
+- **7 data-loss prevention fixes** — hallucination guard, merge anchor verification, dirty tree detection, and more
 - **Pipeline decomposition** — auto-loop rewritten as linear phase pipeline
 - **Sliding-window stuck detection** — pattern-aware, fewer false positives
 - **Data-loss recovery** — automatic detection and recovery from v2.30–v2.38 migration issues
@@ -141,7 +157,9 @@ Full documentation is available in the [`docs/`](./docs/) directory:
 - **[Visualizer](./docs/visualizer.md)** — workflow visualizer with stats and discussion status
 - **[Remote Questions](./docs/remote-questions.md)** — route decisions to Slack or Discord when human input is needed
 - **[Dynamic Model Routing](./docs/dynamic-model-routing.md)** — complexity-based model selection and budget pressure
+- **[Web Interface](./docs/web-interface.md)** — browser-based project management and real-time progress
 - **[Pipeline Simplification (ADR-003)](./docs/ADR-003-pipeline-simplification.md)** — merged research into planning, mechanical completion
+- **[Docker Sandbox](./docker/README.md)** — run GSD auto mode in an isolated Docker container
 - **[Migration from v1](./docs/migration.md)** — `.planning` → `.gsd` migration
 
 ---

package/dist/resources/extensions/gsd/activity-log.js

@@ -134,6 +134,13 @@ export function pruneActivityLogs(activityDir, retentionDays) {
         for (const entry of entries) {
             if (entry.seq === maxSeq)
                 continue; // always preserve highest-seq
+            if (retentionDays === 0) {
+                try {
+                    unlinkSync(entry.filePath);
+                }
+                catch { /* skip */ }
+                continue;
+            }
             try {
                 const mtime = statSync(entry.filePath).mtimeMs;
                 if (Math.floor(mtime) <= cutoff)

package/dist/resources/extensions/gsd/auto/infra-errors.js

@@ -17,6 +17,9 @@ export const INFRA_ERROR_CODES = new Set([
     "EDQUOT", // disk quota exceeded
     "EMFILE", // too many open files (process)
     "ENFILE", // too many open files (system)
+    "ECONNREFUSED", // connection refused (offline / local server down)
+    "ENOTFOUND", // DNS lookup failed (offline / no network)
+    "ENETUNREACH", // network unreachable (offline / no route)
 ]);
 /**
  * Detect whether an error is an unrecoverable infrastructure failure.

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

@@ -14,7 +14,9 @@ import { debugLog } from "../debug-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { PROJECT_FILES } from "../detection.js";
+import { MergeConflictError } from "../git-service.js";
 import { join } from "node:path";
+import { existsSync, cpSync } from "node:fs";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Generate and write an HTML milestone report snapshot.
@@ -145,20 +147,19 @@ export async function runPreDispatch(ic, loopState) {
         loopState.recentUnits.length = 0;
         loopState.stuckRecoveryAttempts = 0;
         // Worktree lifecycle on milestone transition — merge current, enter next
-        deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
-        // Opt-in: create draft PR on milestone completion
-        if (prefs?.git?.auto_pr) {
-            try {
-                const { createDraftPR } = await import("../git-service.js");
-                const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
-                if (prUrl) {
-                    ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
-                }
-            }
-            catch {
-                // Non-fatal — PR creation is best-effort
+        try {
+            deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+        }
+        catch (mergeErr) {
+            if (mergeErr instanceof MergeConflictError) {
+                // Real code conflicts — stop the loop instead of retrying forever (#2330)
+                ctx.ui.notify(`Merge conflict: ${mergeErr.conflictedFiles.join(", ")}. Resolve conflicts manually and run /gsd auto to resume.`, "error");
+                await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
+                return { action: "break", reason: "merge-conflict" };
             }
+            // Non-conflict errors — log and continue
         }
+        // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.basePath);
         mid = state.activeMilestone?.id;
@@ -179,9 +180,14 @@ export async function runPreDispatch(ic, loopState) {
         // Reset completed-units tracking for the new milestone — stale entries
         // from the previous milestone cause the dispatch loop to skip units
         // that haven't actually been completed in the new milestone's context.
+        // Archive the old completed-units.json instead of wiping it (#2313).
         s.completedUnits = [];
         try {
             const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
+            if (existsSync(completedKeysPath) && s.currentMilestoneId) {
+                const archivePath = join(gsdRoot(s.basePath), `completed-units-${s.currentMilestoneId}.json`);
+                cpSync(completedKeysPath, archivePath);
+            }
             atomicWriteSync(completedKeysPath, JSON.stringify([], null, 2));
         }
         catch { /* non-fatal */ }
@@ -209,20 +215,17 @@ export async function runPreDispatch(ic, loopState) {
         if (incomplete.length === 0 && state.registry.length > 0) {
             // All milestones complete — merge milestone branch before stopping
             if (s.currentMilestoneId) {
-                deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
-                // Opt-in: create draft PR on milestone completion
-                if (prefs?.git?.auto_pr) {
-                    try {
-                        const { createDraftPR } = await import("../git-service.js");
-                        const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
-                        if (prUrl) {
-                            ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
-                        }
-                    }
-                    catch {
-                        // Non-fatal — PR creation is best-effort
+                try {
+                    deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                }
+                catch (mergeErr) {
+                    if (mergeErr instanceof MergeConflictError) {
+                        ctx.ui.notify(`Merge conflict: ${mergeErr.conflictedFiles.join(", ")}. Resolve conflicts manually and run /gsd auto to resume.`, "error");
+                        await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
+                        return { action: "break", reason: "merge-conflict" };
                     }
                 }
+                // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
             }
             deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
             deps.logCmuxEvent(prefs, "All milestones complete.", "success");
@@ -277,20 +280,17 @@ export async function runPreDispatch(ic, loopState) {
     if (state.phase === "complete") {
         // Milestone merge on complete (before closeout so branch state is clean)
         if (s.currentMilestoneId) {
-            deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
-            // Opt-in: create draft PR on milestone completion
-            if (prefs?.git?.auto_pr) {
-                try {
-                    const { createDraftPR } = await import("../git-service.js");
-                    const prUrl = createDraftPR(s.basePath, s.currentMilestoneId, `[GSD] ${s.currentMilestoneId} complete`, `Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`);
-                    if (prUrl) {
-                        ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
-                    }
-                }
-                catch {
-                    // Non-fatal — PR creation is best-effort
+            try {
+                deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+            }
+            catch (mergeErr) {
+                if (mergeErr instanceof MergeConflictError) {
+                    ctx.ui.notify(`Merge conflict: ${mergeErr.conflictedFiles.join(", ")}. Resolve conflicts manually and run /gsd auto to resume.`, "error");
+                    await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
+                    return { action: "break", reason: "merge-conflict" };
                 }
             }
+            // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         }
         deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
@@ -591,6 +591,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         lastProgressAt: s.currentUnit.startedAt,
         progressCount: 0,
         lastProgressKind: "dispatch",
+        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
     });
     // Status bar + progress widget
     ctx.ui.setStatus("gsd-auto", "auto");

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

@@ -1156,6 +1156,12 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
         roadmapPath: roadmapRel,
         inlinedContext,
         milestoneSummaryPath,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
@@ -1236,6 +1242,12 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         inlinedContext,
         validationPath: validationOutputPath,
         remediationRound: String(remediationRound),
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
@@ -1332,6 +1344,12 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
         uatResultPath,
         uatType,
         inlinedContext,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            sliceId,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base, level) {
@@ -1378,11 +1396,16 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
         milestoneTitle: midTitle,
         completedSliceId,
         roadmapPath: roadmapRel,
-        completedSliceSummaryPath: summaryRel,
         assessmentPath,
         inlinedContext,
         deferredCaptures,
         commitInstruction: reassessCommitInstruction,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext, deferredCaptures],
+        }),
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────

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

@@ -197,10 +197,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 state = await deriveState(wtPath);
             }
         }
-        // Milestone branch recovery (#601)
+        // Milestone branch recovery (#601, #2358)
+        // Detect survivor milestone branches in both pre-planning and complete phases.
+        // In phase=complete, the milestone artifacts exist but finalization (merge,
+        // worktree cleanup) was never run — the survivor branch must be merged.
         let hasSurvivorBranch = false;
         if (state.activeMilestone &&
-            state.phase === "pre-planning" &&
+            (state.phase === "pre-planning" || state.phase === "complete") &&
             shouldUseWorktreeIsolation() &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
@@ -231,6 +234,22 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 return releaseLockAndReturn();
             }
         }
+        // Survivor branch exists and milestone is complete (#2358):
+        // The milestone artifacts were written but finalization (merge, worktree
+        // cleanup) never ran. Run mergeAndExit to finalize, then re-derive state
+        // so the normal "all milestones complete" or "next milestone" path runs.
+        if (hasSurvivorBranch && state.phase === "complete") {
+            const mid = state.activeMilestone.id;
+            ctx.ui.notify(`Milestone ${mid} is complete but branch/worktree was not finalized. Running merge now.`, "info");
+            const resolver = buildResolver();
+            resolver.mergeAndExit(mid, {
+                notify: ctx.ui.notify.bind(ctx.ui),
+            });
+            invalidateAllCaches();
+            state = await deriveState(base);
+            // Clear survivor flag — finalization is done
+            hasSurvivorBranch = false;
+        }
         if (!hasSurvivorBranch) {
             // No active work — start a new milestone via discuss flow
             if (!state.activeMilestone || state.phase === "complete") {
@@ -402,6 +421,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
             }
         }
+        // Gate: abort bootstrap if the DB file exists but the provider is
+        // still unavailable after both open attempts above. Without this,
+        // auto-mode starts but every gsd_task_complete / gsd_slice_complete
+        // call returns "db_unavailable", triggering artifact-retry which
+        // re-dispatches the same task — producing an infinite loop (#2419).
+        if (existsSync(gsdDbPath) && !isDbAvailable()) {
+            ctx.ui.notify("SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
+                "Check for corrupt gsd.db or missing native SQLite bindings.", "error");
+            return releaseLockAndReturn();
+        }
         // Initialize metrics
         initMetrics(s.basePath);
         // Initialize routing history

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

@@ -6,6 +6,7 @@
  * via startUnitSupervision() and torn down by the caller via clearUnitTimeout().
  */
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
 import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
@@ -21,12 +22,65 @@ import { resolveAgentEndCancelled } from "./auto/resolve.js";
  * 3. Hard timeout (pause + recovery)
  * 4. Context-pressure monitor (continue-here)
  */
+/**
+ * Parse a task estimate string (e.g. "30m", "2h", "1h30m") into minutes.
+ * Returns null if the string cannot be parsed.
+ */
+export function parseEstimateMinutes(estimate) {
+    if (!estimate || typeof estimate !== "string")
+        return null;
+    const trimmed = estimate.trim();
+    if (!trimmed)
+        return null;
+    let totalMinutes = 0;
+    let matched = false;
+    // Match hours component
+    const hoursMatch = trimmed.match(/(\d+)\s*h/i);
+    if (hoursMatch) {
+        totalMinutes += Number(hoursMatch[1]) * 60;
+        matched = true;
+    }
+    // Match minutes component
+    const minutesMatch = trimmed.match(/(\d+)\s*m/i);
+    if (minutesMatch) {
+        totalMinutes += Number(minutesMatch[1]);
+        matched = true;
+    }
+    return matched ? totalMinutes : null;
+}
 export function startUnitSupervision(sctx) {
     const { s, ctx, pi, unitType, unitId, prefs, buildSnapshotOpts, buildRecoveryContext, pauseAuto } = sctx;
     const supervisor = resolveAutoSupervisorConfig();
-    const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000;
-    const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000;
-    const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000;
+    // Scale timeouts based on task estimate annotations (#2243).
+    // If the task has an est: annotation, use it to extend the hard and soft timeouts
+    // so longer tasks don't get prematurely timed out.
+    let taskEstimate = sctx.taskEstimate;
+    if (!taskEstimate && unitType === "task" && isDbAvailable()) {
+        // Look up the task estimate from the DB (#2243).
+        try {
+            if (s.currentMilestoneId) {
+                const slices = getMilestoneSlices(s.currentMilestoneId);
+                for (const slice of slices) {
+                    const tasks = getSliceTasks(s.currentMilestoneId, slice.id);
+                    const task = tasks.find(t => t.id === unitId);
+                    if (task?.estimate) {
+                        taskEstimate = task.estimate;
+                        break;
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-fatal — fall through with no estimate
+        }
+    }
+    const estimateMinutes = taskEstimate ? parseEstimateMinutes(taskEstimate) : null;
+    const timeoutScale = estimateMinutes && estimateMinutes > 0
+        ? Math.max(1, estimateMinutes / 10) // 10min task = 1x, 30min = 3x, 2h = 12x
+        : 1;
+    const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
+    const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000; // idle not scaled — idle is idle
+    const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
     // ── 1. Soft timeout warning ──
     s.wrapupWarningHandle = setTimeout(() => {
         s.wrapupWarningHandle = null;

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

@@ -63,6 +63,10 @@ export function syncStateToProjectRoot(worktreePath, projectRoot, milestoneId) {
     // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
     // Copy the entire milestone .gsd subtree so deriveState reads current checkboxes
     safeCopyRecursive(join(wtGsd, "milestones", milestoneId), join(prGsd, "milestones", milestoneId), { force: true });
+    // 3. metrics.json — session cost/token tracking (#2313).
+    // Without this, metrics accumulated in the worktree are invisible from the
+    // project root and never appear in the dashboard or skill-health reports.
+    safeCopy(join(wtGsd, "metrics.json"), join(prGsd, "metrics.json"), { force: true });
     // 4. Runtime records — unit dispatch state used by selfHealRuntimeRecords().
     // Without this, a crash during a unit leaves the runtime record only in the
     // worktree. If the next session resolves basePath before worktree re-entry,

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

@@ -109,6 +109,7 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(mainGsd, f);
@@ -269,8 +270,9 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
     // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
     // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
     // PROJECT, etc. These must overwrite main's copies so they survive teardown.
-    // Also includes QUEUE.md and completed-units.json which are written during
-    // milestone closeout and lost on teardown without explicit sync (#1787).
+    // Also includes QUEUE.md, completed-units.json, and metrics.json which are
+    // written during milestone closeout and lost on teardown without explicit sync
+    // (#1787, #2313).
     const rootFiles = [
         "DECISIONS.md",
         "REQUIREMENTS.md",
@@ -279,6 +281,7 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(wtGsd, f);
@@ -1133,9 +1136,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // Push failure is non-fatal
         }
     }
-    // 9b. Auto-create PR if enabled (requires push_branches + push succeeded)
+    // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
     let prCreated = false;
-    if (prefs.auto_pr === true && pushed) {
+    if (prefs.auto_pr === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         const prTarget = prefs.pr_target_branch ?? mainBranch;
         try {
@@ -1145,9 +1148,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
             });
-            // Create PR via gh CLI
+            // Create PR via gh CLI with explicit --head and --base (#2302)
             execFileSync("gh", [
-                "pr", "create",
+                "pr", "create", "--draft",
                 "--base", prTarget,
                 "--head", milestoneBranch,
                 "--title", `Milestone ${milestoneId} complete`,

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

@@ -369,14 +369,41 @@ export async function stopAuto(ctx, pi, reason) {
             debugLog("stop-cleanup-sigterm", { error: e instanceof Error ? e.message : String(e) });
         }
         // ── Step 4: Auto-worktree exit ──
+        // When the milestone is complete (has a SUMMARY), merge the worktree branch
+        // back to main so code isn't stranded on the worktree branch (#2317).
+        // For incomplete milestones, preserve the branch for later resumption.
         try {
             if (s.currentMilestoneId) {
                 const notifyCtx = ctx
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
-                buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
-                    preserveBranch: true,
-                });
+                const resolver = buildResolver();
+                // Check if the milestone is complete — SUMMARY file is the authoritative signal.
+                let milestoneComplete = false;
+                try {
+                    const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
+                    if (!summaryPath) {
+                        // Also check in the worktree path (SUMMARY may not be synced yet)
+                        const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
+                        milestoneComplete = wtSummaryPath !== null;
+                    }
+                    else {
+                        milestoneComplete = true;
+                    }
+                }
+                catch {
+                    // Non-fatal — fall through to preserveBranch path
+                }
+                if (milestoneComplete) {
+                    // Milestone is complete — merge worktree branch back to main
+                    resolver.mergeAndExit(s.currentMilestoneId, notifyCtx);
+                }
+                else {
+                    // Milestone still in progress — preserve branch for later resumption
+                    resolver.exitMilestone(s.currentMilestoneId, notifyCtx, {
+                        preserveBranch: true,
+                    });
+                }
             }
         }
         catch (e) {