gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

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

@@ -10,7 +10,7 @@
 import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, statSync, lstatSync as lstatSyncFn, } from "node:fs";
 import { isAbsolute, join, relative, sep as pathSep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
-import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
+import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot, resolveGsdPathContract } from "./paths.js";
@@ -135,6 +135,35 @@ function isSamePath(a, b) {
         return false;
     }
 }
+export function _isSamePathForTest(a, b) {
+    return isSamePath(a, b);
+}
+export function _resolveAutoWorktreeStartPointForTest(integrationBranch, gitMainBranch, branchExists) {
+    if (integrationBranch)
+        return integrationBranch;
+    return gitMainBranch &&
+        typeof gitMainBranch === "string" &&
+        gitMainBranch.length > 0 &&
+        branchExists(gitMainBranch)
+        ? gitMainBranch
+        : undefined;
+}
+export function _shouldReconcileWorktreeDbForTest(worktreeDbPath, mainDbPath, pathExists = existsSync, samePath = isSamePath) {
+    return pathExists(worktreeDbPath) && !samePath(worktreeDbPath, mainDbPath);
+}
+export function _isExpectedWorktreeUnlinkErrorForTest(code) {
+    return code === "ENOENT" || code === "EISDIR";
+}
+function stripGsdDisplayPrefix(value, id) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    const lower = raw.toLowerCase();
+    const idLower = id.toLowerCase();
+    if (lower.startsWith(`${idLower}:`))
+        return raw.slice(id.length + 1).trim() || undefined;
+    return raw;
+}
 // ─── ASSESSMENT Force-Sync Helper (#2821) ─────────────────────────────────
 /** Regex matching YAML frontmatter `verdict:` field. */
 const VERDICT_RE = /verdict:\s*[\w-]+/i;
@@ -288,7 +317,7 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
                         catch (err) {
                             // ENOENT/EISDIR are expected for already-removed or directory entries (#3597)
                             const code = err.code;
-                            if (code !== "ENOENT" && code !== "EISDIR") {
+                            if (!_isExpectedWorktreeUnlinkErrorForTest(code)) {
                                 logWarning("worktree", `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
                             }
                         }
@@ -317,6 +346,44 @@ export const SAFE_AUTO_RESOLVE_PATTERNS = [
  * Covers `.gsd/` state files and common build artifacts. */
 export const isSafeToAutoResolve = (filePath) => filePath.startsWith(".gsd/") ||
     SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
+function removeMergeStateFiles(basePath, contextLabel) {
+    try {
+        const gitDir_ = resolveGitDir(basePath);
+        for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
+            const p = join(gitDir_, f);
+            if (existsSync(p))
+                unlinkSync(p);
+        }
+    }
+    catch (err) {
+        logError("worktree", `${contextLabel} merge state cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function cleanupSquashConflictState(basePath) {
+    // `git merge --squash` conflicts can leave unmerged index entries without
+    // MERGE_HEAD, so merge-abort alone is not enough. Reset the merge index, then
+    // remove merge message files that native/libgit2 paths may have created.
+    try {
+        nativeMergeAbort(basePath);
+    }
+    catch (err) {
+        // Expected for squash conflicts when MERGE_HEAD was never written.
+        debugLog("squash-conflict-cleanup:merge-abort-skipped", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    try {
+        execFileSync("git", ["reset", "--merge"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch (err) {
+        logError("worktree", `git reset --merge failed after squash conflict: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    removeMergeStateFiles(basePath, "squash conflict");
+}
 // ─── Dispatch-Level Sync (project root ↔ worktree) ──────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -945,17 +1012,7 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
         // Create the milestone branch from the integration branch start-point.
         const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
         const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
-        // Validate main_branch preference exists in the repo before using it —
-        // a stale preference (e.g. "master" when repo uses "main") would cause
-        // nativeBranchForceReset to fail with a bad start-point reference.
-        const validatedPrefBranch = gitPrefs?.main_branch &&
-            typeof gitPrefs.main_branch === "string" &&
-            gitPrefs.main_branch.length > 0 &&
-            nativeBranchExists(basePath, gitPrefs.main_branch)
-            ? gitPrefs.main_branch
-            : undefined;
-        const startPoint = integrationBranch ??
-            validatedPrefBranch ??
+        const startPoint = _resolveAutoWorktreeStartPointForTest(integrationBranch, gitPrefs?.main_branch, (branchName) => nativeBranchExists(basePath, branchName)) ??
             nativeDetectMainBranch(basePath);
         // TOCTOU ancestry guard (Issue #4980 HIGH-3).
         //
@@ -1161,13 +1218,7 @@ export function createAutoWorktree(basePath, milestoneId) {
         // would fork worktrees from the wrong (stale) branch.
         const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
         const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
-        const validatedPrefBranch = gitPrefs?.main_branch &&
-            typeof gitPrefs.main_branch === "string" &&
-            gitPrefs.main_branch.length > 0 &&
-            nativeBranchExists(basePath, gitPrefs.main_branch)
-            ? gitPrefs.main_branch
-            : undefined;
-        const startPoint = integrationBranch ?? validatedPrefBranch ?? undefined;
+        const startPoint = _resolveAutoWorktreeStartPointForTest(integrationBranch, gitPrefs?.main_branch, (branchName) => nativeBranchExists(basePath, branchName));
         info = createWorktree(basePath, milestoneId, {
             branch,
             startPoint,
@@ -1244,7 +1295,7 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
                 const contract = resolveGsdPathContract(previousCwd, originalBasePath);
                 const worktreeDbPath = join(contract.worktreeGsd ?? join(previousCwd, ".gsd"), "gsd.db");
                 const mainDbPath = contract.projectDb;
-                if (existsSync(worktreeDbPath) && !isSamePath(worktreeDbPath, mainDbPath)) {
+                if (_shouldReconcileWorktreeDbForTest(worktreeDbPath, mainDbPath)) {
                     reconcileWorktreeDb(mainDbPath, worktreeDbPath);
                 }
             }
@@ -1494,7 +1545,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             const contract = resolveGsdPathContract(worktreeCwd, originalBasePath_);
             const worktreeDbPath = join(contract.worktreeGsd ?? join(worktreeCwd, ".gsd"), "gsd.db");
             const mainDbPath = contract.projectDb;
-            if (existsSync(worktreeDbPath) && !isSamePath(worktreeDbPath, mainDbPath)) {
+            if (_shouldReconcileWorktreeDbForTest(worktreeDbPath, mainDbPath)) {
                 reconcileWorktreeDb(mainDbPath, worktreeDbPath);
             }
         }
@@ -1508,14 +1559,23 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     if (isDbAvailable()) {
         completedSlices = getMilestoneSlices(milestoneId)
             .filter(s => s.status === "complete")
-            .map(s => ({ id: s.id, title: s.title }));
+            .map(s => ({
+            id: s.id,
+            title: stripGsdDisplayPrefix(s.title, s.id) ?? s.id,
+            tasks: getSliceTasks(milestoneId, s.id)
+                .filter((task) => task.status === "complete")
+                .map((task) => ({
+                id: task.id,
+                title: stripGsdDisplayPrefix(task.title, task.id) ?? task.id,
+            })),
+        }));
     }
     // Fallback: parse roadmap content when DB is unavailable
     if (completedSlices.length === 0 && roadmapContent) {
         const sliceRe = /- \[x\] \*\*(\w+):\s*(.+?)\*\*/gi;
         let m;
         while ((m = sliceRe.exec(roadmapContent)) !== null) {
-            completedSlices.push({ id: m[1], title: m[2] });
+            completedSlices.push({ id: m[1], title: m[2], tasks: [] });
         }
     }
     // 3. chdir to original base
@@ -1572,7 +1632,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     }
     // 6. Build rich commit message
     const dbMilestone = getMilestone(milestoneId);
-    let milestoneTitle = (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim();
+    let milestoneTitle = stripGsdDisplayPrefix(dbMilestone?.title, milestoneId) ?? "";
     // Fallback: parse title from roadmap content header (e.g. "# M020: Backend foundation")
     if (!milestoneTitle && roadmapContent) {
         const titleMatch = roadmapContent.match(new RegExp(`^#\\s+${milestoneId}:\\s*(.+)`, "m"));
@@ -1581,15 +1641,22 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     }
     milestoneTitle = milestoneTitle || milestoneId;
     const subject = `feat: ${milestoneTitle}`;
+    const milestoneContext = milestoneTitle === milestoneId
+        ? `Milestone: ${milestoneId}`
+        : `Milestone: ${milestoneId} - ${milestoneTitle}`;
     let body = "";
     if (completedSlices.length > 0) {
         const sliceLines = completedSlices
             .map((s) => `- ${s.id}: ${s.title}`)
             .join("\n");
-        body = `\n\nCompleted slices:\n${sliceLines}\n\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
+        const taskLines = completedSlices
+            .flatMap((s) => s.tasks.map((task) => `- ${s.id}/${task.id}: ${task.title}`))
+            .join("\n");
+        const taskBlock = taskLines ? `\n\nCompleted tasks:\n${taskLines}` : "";
+        body = `\n\nCompleted slices:\n${sliceLines}${taskBlock}\n\n${milestoneContext}\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
     }
     else {
-        body = `\n\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
+        body = `\n\n${milestoneContext}\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
     }
     const commitMessage = subject + body;
     // 6b. Reconcile worktree HEAD with milestone branch ref (#1846).
@@ -1790,17 +1857,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // or interrupted operation) causes `git merge --squash` to refuse with
     // "fatal: You have not concluded your merge (MERGE_HEAD exists)".
     // Defensively remove merge artifacts before starting.
-    try {
-        const gitDir_ = resolveGitDir(originalBasePath_);
-        for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
-            const p = join(gitDir_, f);
-            if (existsSync(p))
-                unlinkSync(p);
-        }
-    }
-    catch (err) { /* best-effort */
-        logError("worktree", `merge state cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    removeMergeStateFiles(originalBasePath_, "pre-merge");
     // 8. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
     const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
     if (!mergeResult.success) {
@@ -1810,17 +1867,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         if (mergeResult.conflicts.includes("__dirty_working_tree__")) {
             // Defensively clean merge state — the native path may leave MERGE_HEAD
             // even when the merge is rejected (#2912).
-            try {
-                const gitDir_ = resolveGitDir(originalBasePath_);
-                for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
-                    const p = join(gitDir_, f);
-                    if (existsSync(p))
-                        unlinkSync(p);
-                }
-            }
-            catch (err) { /* best-effort */
-                logError("worktree", `merge state cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            removeMergeStateFiles(originalBasePath_, "dirty-tree rejection");
             // Pop stash before throwing so local work is not lost.
             if (stashed) {
                 try {
@@ -1869,26 +1916,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             }
             // If there are still real code conflicts, escalate
             if (codeConflicts.length > 0) {
-                // Abort merge state so MERGE_HEAD is not left on disk (#2912).
-                // libgit2's merge creates MERGE_HEAD even for squash merges; if left
-                // dangling, subsequent merges fail and doctor reports corrupt state.
-                try {
-                    nativeMergeAbort(originalBasePath_);
-                }
-                catch (err) { /* best-effort */
-                    logError("worktree", `git merge-abort failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-                try {
-                    const gitDir_ = resolveGitDir(originalBasePath_);
-                    for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
-                        const p = join(gitDir_, f);
-                        if (existsSync(p))
-                            unlinkSync(p);
-                    }
-                }
-                catch (err) { /* best-effort */
-                    logError("worktree", `merge state file cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
+                cleanupSquashConflictState(originalBasePath_);
                 // Pop stash before throwing so local work is not lost (#2151).
                 if (stashed) {
                     try {
@@ -1919,17 +1947,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // of which trigger git's SQUASH_MSG cleanup.  MERGE_HEAD is created by
     // libgit2's merge even in squash mode and is not removed by nativeCommit.
     // If left on disk, doctor reports `corrupt_merge_state` on every subsequent run.
-    try {
-        const gitDir_ = resolveGitDir(originalBasePath_);
-        for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
-            const p = join(gitDir_, f);
-            if (existsSync(p))
-                unlinkSync(p);
-        }
-    }
-    catch (err) { /* best-effort */
-        logError("worktree", `post-commit merge state cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    removeMergeStateFiles(originalBasePath_, "post-commit");
     // 9a-ii. Restore stashed files now that the merge+commit is complete (#2151).
     // Pop after commit so stashed changes do not interfere with the squash merge
     // or the commit content.  Conflict on pop is non-fatal — the stash entry is

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode orchestration, session lifecycle, and stop handling.
 /**
  * GSD Auto Mode — Fresh Session Per Unit
  *
@@ -162,6 +164,12 @@ function restoreProjectRootEnv() {
     s.hadProjectRootEnv = false;
     s.projectRootEnvCaptured = false;
 }
+export function _captureProjectRootEnvForTest(projectRoot) {
+    captureProjectRootEnv(projectRoot);
+}
+export function _restoreProjectRootEnvForTest() {
+    restoreProjectRootEnv();
+}
 function captureMilestoneLockEnv(milestoneId) {
     if (!s.milestoneLockEnvCaptured) {
         s.hadMilestoneLockEnv = Object.prototype.hasOwnProperty.call(process.env, "GSD_MILESTONE_LOCK");
@@ -239,6 +247,11 @@ function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile
 export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
     return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
 }
+export function _resolvePausedResumeBasePathForTest(basePath, pausedWorktreePath, pathExists = existsSync) {
+    return pausedWorktreePath && pathExists(pausedWorktreePath)
+        ? pausedWorktreePath
+        : basePath;
+}
 const DETACHED_AUTO_KEEPALIVE_INTERVAL_MS = 30_000;
 function withDetachedAutoKeepalive(run) {
     const keepAlive = setInterval(() => { }, DETACHED_AUTO_KEEPALIVE_INTERVAL_MS);
@@ -415,6 +428,20 @@ export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
 export function isAutoPaused() {
     return s.paused;
 }
+export async function refreshResumeResourcesAndDb(basePath, deps = {}) {
+    const env = deps.env ?? process.env;
+    const importModule = deps.importModule ?? ((specifier) => import(specifier));
+    const agentDir = env.GSD_CODING_AGENT_DIR || join(gsdHome(), "agent");
+    const pkgRoot = env.GSD_PKG_ROOT;
+    const resourceLoaderPath = pkgRoot
+        ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
+        : new URL("../../../resource-loader.js", import.meta.url).href;
+    const { initResources } = await importModule(resourceLoaderPath);
+    initResources(agentDir);
+    const { primeCache } = await importModule("./prompt-loader.js");
+    primeCache();
+    await (deps.openProjectDb ?? openProjectDbIfPresent)(basePath);
+}
 export function setActiveEngineId(id) {
     s.activeEngineId = id;
 }
@@ -618,7 +645,21 @@ function handleLostSessionLock(ctx, lockStatus) {
  * the stale unit state, progress widget, status badge, and restores CWD so
  * the dashboard does not show an orphaned timer and the shell is usable.
  */
-function cleanupAfterLoopExit(ctx) {
+export async function rerootCommandSession(cmdCtx, workspaceRoot) {
+    if (!cmdCtx || !workspaceRoot)
+        return { status: "skipped" };
+    try {
+        const result = await cmdCtx.newSession({ workspaceRoot });
+        return result.cancelled ? { status: "cancelled" } : { status: "ok" };
+    }
+    catch (err) {
+        return {
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function cleanupAfterLoopExit(ctx) {
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -657,6 +698,26 @@ function cleanupAfterLoopExit(ctx) {
             logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
+    if (s.originalBasePath && s.cmdCtx) {
+        const result = await rerootCommandSession(s.cmdCtx, s.basePath);
+        if (result.status === "cancelled") {
+            logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
+        }
+        else if (result.status === "failed") {
+            logWarning("engine", `post-loop session re-root failed: ${result.error ?? "unknown"}`, { file: "auto.ts", basePath: s.basePath });
+        }
+    }
+}
+export function _cleanupAfterLoopExitForTest(ctx) {
+    return cleanupAfterLoopExit(ctx);
+}
+export function _resolveAutoWorktreeExitActionForTest(currentMilestoneId, milestoneMergedInPhases, milestoneComplete) {
+    const action = _selectStopAutoWorktreeExit({
+        currentMilestoneId: currentMilestoneId ?? null,
+        milestoneComplete,
+        milestoneMergedInPhases,
+    });
+    return action === "none" ? "skip" : action;
 }
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
@@ -797,11 +858,16 @@ export async function stopAuto(ctx, pi, reason) {
                     // Non-fatal — fall through to preserveBranch path
                     logWarning("engine", `milestone summary check failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
-                if (milestoneComplete) {
+                const exitAction = _selectStopAutoWorktreeExit({
+                    currentMilestoneId: s.currentMilestoneId,
+                    milestoneComplete,
+                    milestoneMergedInPhases: s.milestoneMergedInPhases,
+                });
+                if (exitAction === "merge") {
                     // Milestone is complete — merge worktree branch back to main
                     resolver.mergeAndExit(s.currentMilestoneId, notifyCtx);
                 }
-                else {
+                else if (exitAction === "preserve") {
                     // Milestone still in progress — preserve branch for later resumption
                     resolver.exitMilestone(s.currentMilestoneId, notifyCtx, {
                         preserveBranch: true,
@@ -810,6 +876,7 @@ export async function stopAuto(ctx, pi, reason) {
             }
         }
         catch (e) {
+            ctx?.ui.notify(`Worktree cleanup failed for ${s.currentMilestoneId ?? "current milestone"}: ${e instanceof Error ? e.message : String(e)}. Resolve the preserved branch/worktree and run /gsd auto to resume.`, "warning");
             debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
         }
         // ── Step 5: Rebuild state while DB is still open (#3599) ──
@@ -860,14 +927,12 @@ export async function stopAuto(ctx, pi, reason) {
         // its own cwd for tools and system prompt; refresh it before returning to the
         // user so follow-up commands do not target a removed milestone worktree.
         if (s.originalBasePath && ctx && s.cmdCtx) {
-            try {
-                const result = await s.cmdCtx.newSession({ workspaceRoot: s.basePath });
-                if (result.cancelled) {
-                    logWarning("engine", "post-stop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
-                }
+            const result = await rerootCommandSession(s.cmdCtx, s.basePath);
+            if (result.status === "cancelled") {
+                logWarning("engine", "post-stop session re-root was cancelled", { file: "auto.ts", basePath: s.basePath });
             }
-            catch (err) {
-                logWarning("engine", `post-stop session re-root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath: s.basePath });
+            else if (result.status === "failed") {
+                logWarning("engine", `post-stop session re-root failed: ${result.error ?? "unknown"}`, { file: "auto.ts", basePath: s.basePath });
             }
         }
         // ── Step 8: Ledger notification ──
@@ -995,6 +1060,11 @@ export async function stopAuto(ctx, pi, reason) {
         s.reset();
     }
 }
+export function _selectStopAutoWorktreeExit(args) {
+    if (!args.currentMilestoneId || args.milestoneMergedInPhases)
+        return "none";
+    return args.milestoneComplete ? "merge" : "preserve";
+}
 /**
  * Pause auto-mode without destroying state. Context is preserved.
  * The user can interact with the agent, then `/gsd auto` resumes
@@ -1585,9 +1655,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         if (resumeWorktreePath && !existsSync(resumeWorktreePath)) {
             logWarning("session", `Worktree was expected at ${resumeWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: s.currentMilestoneId ?? "" });
         }
-        if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
-            s.basePath = resumeWorktreePath;
-        }
+        s.basePath = _resolvePausedResumeBasePathForTest(base, resumeWorktreePath);
         // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
         rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root
@@ -1632,20 +1700,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // tree; deployed extensions live at ~/.gsd/agent/extensions/gsd/ where the
         // relative path resolves to ~/.gsd/agent/resource-loader.js which doesn't exist.
         // Using GSD_PKG_ROOT constructs a correct absolute path in both contexts (#3949).
-        const agentDir = process.env.GSD_CODING_AGENT_DIR || join(gsdHome(), "agent");
-        const pkgRoot = process.env.GSD_PKG_ROOT;
-        const resourceLoaderPath = pkgRoot
-            ? pathToFileURL(join(pkgRoot, "dist", "resource-loader.js")).href
-            : new URL("../../../resource-loader.js", import.meta.url).href;
-        const { initResources } = await import(resourceLoaderPath);
-        initResources(agentDir);
-        // initResources() uses synchronous fs APIs, so the prompt-template cache
-        // can be primed immediately — no need for the legacy 1s setTimeout deferral.
-        const { primeCache } = await import("./prompt-loader.js");
-        primeCache();
-        // Open the project DB before rebuild/derive so resume uses DB-backed
-        // state instead of falling back to stale markdown parsing (#2940).
-        await openProjectDbIfPresent(s.basePath);
+        await refreshResumeResourcesAndDb(s.basePath);
         try {
             await rebuildState(s.basePath);
             pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
@@ -1698,7 +1753,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             runKernelLoop: runUokKernelLoop,
             runLegacyLoop: runLegacyAutoLoop,
         });
-        cleanupAfterLoopExit(ctx);
+        await cleanupAfterLoopExit(ctx);
         return;
     }
     // ── Fresh start path — delegated to auto-start.ts ──
@@ -1745,7 +1800,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         runKernelLoop: runUokKernelLoop,
         runLegacyLoop: runLegacyAutoLoop,
     });
-    cleanupAfterLoopExit(ctx);
+    await cleanupAfterLoopExit(ctx);
 }
 // describeNextUnit is imported from auto-dashboard.ts and re-exported
 export { describeNextUnit } from "./auto-dashboard.js";

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

@@ -5,7 +5,7 @@ import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
-import { isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled } from "../auto/resolve.js";
+import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
@@ -53,6 +53,41 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+function isBareClaudeCodeSessionSwitchAbortMarker(message) {
+    if (!message)
+        return false;
+    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalized === "claude code process aborted by user"
+        || normalized === "request aborted by user"
+        || normalized === "process aborted by user"
+        || normalized === "claude code stream aborted by caller";
+}
+function readAssistantTextContent(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((block) => {
+        if (!block || typeof block !== "object")
+            return "";
+        const text = block.text;
+        return typeof text === "string" ? text : "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+export function isClaudeCodeSessionSwitchAbortMessage(lastMsg) {
+    if (!lastMsg || typeof lastMsg !== "object")
+        return false;
+    const m = lastMsg;
+    const carriers = [
+        m.errorMessage ? String(m.errorMessage) : "",
+        readAssistantTextContent(m.content),
+    ].filter((value) => value.trim().length > 0);
+    if ((m.stopReason === "error" || m.stopReason === "aborted") && carriers.length > 0) {
+        return carriers.every(isBareClaudeCodeSessionSwitchAbortMarker);
+    }
+    return false;
+}
 /**
  * Resolve an agent_end event observed while a session switch is in flight.
  *
@@ -65,18 +100,23 @@ export function isUserInitiatedAbortMessage(message) {
  * "Auto-mode stopped — Unit aborted: Claude Code process aborted by user"
  * even though no user input occurred.
  *
- * The user-abort branch is intentionally ignored when the abort fires while
- * the session-switch is in flight: the abort is the expected side-effect of
- * the transition, not a user signal. Other branches (genuine `stopReason ===
- * "aborted"` with content/errorMessage) preserve the prior behavior.
+ * Claude Code abort markers are intentionally ignored when the abort fires
+ * while the session-switch is in flight: the abort is the expected side-effect
+ * of the transition, not a user signal. Other branches (genuine `stopReason
+ * === "aborted"` with diagnostic content/errorMessage) preserve the prior
+ * behavior.
  */
 export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
     if (!lastMsg || typeof lastMsg !== "object")
         return;
     const m = lastMsg;
+    if (isClaudeCodeSessionSwitchAbortMessage(m)) {
+        // Internal abort from in-flight session transition — drop on the floor.
+        return;
+    }
     if (m.stopReason === "error") {
         const rawErrorMsg = m.errorMessage ? String(m.errorMessage) : "";
-        if (isUserInitiatedAbortMessage(rawErrorMsg)) {
+        if (isBareClaudeCodeSessionSwitchAbortMarker(rawErrorMsg)) {
             // Internal abort from in-flight session transition — drop on the floor.
             return;
         }
@@ -91,6 +131,15 @@ export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
         }
     }
 }
+export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
+    const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+    if (isUseless && Array.isArray(content)) {
+        const textBlock = content.find((b) => b.type === "text" && b.text);
+        if (textBlock)
+            return textBlock.text.slice(0, 300);
+    }
+    return rawErrorMsg;
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -161,6 +210,12 @@ export async function handleAgentEnd(pi, event, ctx) {
         _handleSessionSwitchAgentEnd(lastMsg, resolveAgentEndCancelled);
         return;
     }
+    if (isSessionSwitchAbortGraceActive() && isClaudeCodeSessionSwitchAbortMessage(lastMsg)) {
+        // Claude Code can report the abort from `newSession()` a few hundred ms
+        // after the guard drops. That event belongs to the old turn; do not let it
+        // cancel the freshly-dispatched unit.
+        return;
+    }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
         // Empty content with aborted stopReason is a non-fatal agent stop (the LLM
         // chose to end without producing output). Only pause on genuine fatal aborts
@@ -204,16 +259,10 @@ export async function handleAgentEnd(pi, event, ctx) {
             });
             return;
         }
-        const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
         // #3588: When errorMessage is uninformative, extract the real error from
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
-        let displayMsg = rawErrorMsg;
-        if (isUseless && "content" in lastMsg && Array.isArray(lastMsg.content)) {
-            const textBlock = lastMsg.content.find((b) => b.type === "text" && b.text);
-            if (textBlock)
-                displayMsg = textBlock.text.slice(0, 300);
-        }
+        const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────