@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -8,12 +8,12 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, lstatSync as lstatSyncFn, } from "node:fs";
-import { dirname, isAbsolute, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, } from "./gsd-db.js";
 import { closeWorkflowDatabase, getWorkflowDatabasePath, openWorkflowDatabasePath, } from "./db-workspace.js";
 import { execFileSync } from "node:child_process";
-import { gsdRoot, resolveGsdPathContract } from "./paths.js";
+import { canonicalPhaseDirName, gsdRoot, milestonesDir, resolveGsdPathContract, resolveMilestonePath, } from "./paths.js";
 import { createWorktree, removeWorktree, worktreePath, isInsideWorktreesDir, } from "./worktree-manager.js";
 import { worktreePathFor } from "./worktree-placement.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
@@ -141,6 +141,16 @@ function stripGsdDisplayPrefix(value, id) {
 // ─── Module State ──────────────────────────────────────────────────────────
 /** Active workspace registry — replaces the legacy `originalBase` singleton. */
 let activeWorkspace = null;
+/**
+ * Optional override for the shelter restore copy step (milestone merge #2505).
+ * Production leaves this null so restoreShelter uses the real cpSync; tests
+ * inject a throwing function to deterministically exercise the best-effort
+ * failure path (auto-worktree.ts:1809) and the shelter-retention guarantee,
+ * which is otherwise unreachable because shelter and restore run synchronously
+ * in one mergeMilestoneToMain call (the filesystem cannot change between them).
+ * @internal
+ */
+let _restoreEntryFn = null;
 function setActiveWorkspace(ws) {
     activeWorkspace = ws;
 }
@@ -300,9 +310,24 @@ export const SAFE_AUTO_RESOLVE_PATTERNS = [
     /\/__pycache__\//,
     /\.DS_Store$/,
     /\.map$/,
+    // Regenerable dependency lockfiles. These are fully derivable from their
+    // manifests by the package manager, so accepting the merge side during
+    // auto-resolve clears the conflict markers without losing meaningful edits —
+    // and stops auto-mode from hard-pausing on a lockfile conflict (issue #828).
+    /(?:^|\/)pnpm-lock\.yaml$/,
+    /(?:^|\/)package-lock\.json$/,
+    /(?:^|\/)npm-shrinkwrap\.json$/,
+    /(?:^|\/)yarn\.lock$/,
+    /(?:^|\/)bun\.lockb?$/,
+    /(?:^|\/)Cargo\.lock$/,
+    /(?:^|\/)composer\.lock$/,
+    /(?:^|\/)Gemfile\.lock$/,
+    /(?:^|\/)Pipfile\.lock$/,
+    /(?:^|\/)poetry\.lock$/,
 ];
 /** Returns true if the file path is safe to auto-resolve during merge.
- * Covers `.gsd/` state files and common build artifacts. */
+ * Covers `.gsd/` state files, common build artifacts, and regenerable
+ * dependency lockfiles. */
 export const isSafeToAutoResolve = (filePath) => filePath.startsWith(".gsd/") ||
     SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
 // ─── Dispatch-Level Sync (project root ↔ worktree) ──────────────────────────
@@ -549,99 +574,102 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
-    // Sync milestones: copy entire milestone directories that are missing
-    const mainMilestonesDir = join(mainGsd, "milestones");
-    const wtMilestonesDir = join(wtGsd, "milestones");
-    if (existsSync(mainMilestonesDir)) {
-        try {
-            mkdirSync(wtMilestonesDir, { recursive: true });
-            const mainMilestones = readdirSync(mainMilestonesDir, {
-                withFileTypes: true,
-            })
-                .filter((d) => d.isDirectory())
-                .map((d) => d.name);
-            for (const mid of mainMilestones) {
-                const srcDir = join(mainMilestonesDir, mid);
-                const dstDir = join(wtMilestonesDir, mid);
-                if (!existsSync(dstDir)) {
-                    // Entire milestone missing from worktree — copy it
-                    try {
-                        cpSync(srcDir, dstDir, { recursive: true });
-                        synced.push(`milestones/${mid}/`);
-                    }
-                    catch (err) {
-                        /* non-fatal */
-                        logWarning("worktree", `milestone copy failed (${mid}): ${err instanceof Error ? err.message : String(err)}`);
+    // Sync milestone/phase trees: copy entire directories that are missing.
+    // Support both flat-phase (phases/) and legacy (milestones/) layouts.
+    for (const layoutSegment of ["phases", "milestones"]) {
+        const mainMilestonesDir = join(mainGsd, layoutSegment);
+        const wtMilestonesDir = join(wtGsd, layoutSegment);
+        if (existsSync(mainMilestonesDir)) {
+            try {
+                mkdirSync(wtMilestonesDir, { recursive: true });
+                const mainMilestones = readdirSync(mainMilestonesDir, {
+                    withFileTypes: true,
+                })
+                    .filter((d) => d.isDirectory())
+                    .map((d) => d.name);
+                for (const mid of mainMilestones) {
+                    const srcDir = join(mainMilestonesDir, mid);
+                    const dstDir = join(wtMilestonesDir, mid);
+                    if (!existsSync(dstDir)) {
+                        // Entire milestone missing from worktree — copy it
+                        try {
+                            cpSync(srcDir, dstDir, { recursive: true });
+                            synced.push(`milestones/${mid}/`);
+                        }
+                        catch (err) {
+                            /* non-fatal */
+                            logWarning("worktree", `milestone copy failed (${mid}): ${err instanceof Error ? err.message : String(err)}`);
+                        }
                     }
-                }
-                else {
-                    // Milestone directory exists but may be missing files (stale snapshot).
-                    // Sync individual top-level milestone files (CONTEXT, ROADMAP, RESEARCH, etc.)
-                    try {
-                        const srcFiles = readdirSync(srcDir).filter((f) => f.endsWith(".md") || f.endsWith(".json"));
-                        for (const f of srcFiles) {
-                            const srcFile = join(srcDir, f);
-                            const dstFile = join(dstDir, f);
-                            if (!existsSync(dstFile)) {
-                                try {
-                                    const srcStat = lstatSyncFn(srcFile);
-                                    if (srcStat.isFile()) {
-                                        cpSync(srcFile, dstFile);
-                                        synced.push(`milestones/${mid}/${f}`);
+                    else {
+                        // Milestone directory exists but may be missing files (stale snapshot).
+                        // Sync individual top-level milestone files (CONTEXT, ROADMAP, RESEARCH, etc.)
+                        try {
+                            const srcFiles = readdirSync(srcDir).filter((f) => f.endsWith(".md") || f.endsWith(".json"));
+                            for (const f of srcFiles) {
+                                const srcFile = join(srcDir, f);
+                                const dstFile = join(dstDir, f);
+                                if (!existsSync(dstFile)) {
+                                    try {
+                                        const srcStat = lstatSyncFn(srcFile);
+                                        if (srcStat.isFile()) {
+                                            cpSync(srcFile, dstFile);
+                                            synced.push(`milestones/${mid}/${f}`);
+                                        }
                                     }
+                                    catch (err) {
+                                        /* non-fatal */
+                                        logWarning("worktree", `milestone file copy failed (${mid}/${f}): ${err instanceof Error ? err.message : String(err)}`);
+                                    }
+                                }
+                            }
+                            // Sync slices directory if it exists in main but not in worktree
+                            const srcSlicesDir = join(srcDir, "slices");
+                            const dstSlicesDir = join(dstDir, "slices");
+                            if (existsSync(srcSlicesDir) && !existsSync(dstSlicesDir)) {
+                                try {
+                                    cpSync(srcSlicesDir, dstSlicesDir, { recursive: true });
+                                    synced.push(`milestones/${mid}/slices/`);
                                 }
                                 catch (err) {
                                     /* non-fatal */
-                                    logWarning("worktree", `milestone file copy failed (${mid}/${f}): ${err instanceof Error ? err.message : String(err)}`);
+                                    logWarning("worktree", `slices copy failed (${mid}): ${err instanceof Error ? err.message : String(err)}`);
                                 }
                             }
-                        }
-                        // Sync slices directory if it exists in main but not in worktree
-                        const srcSlicesDir = join(srcDir, "slices");
-                        const dstSlicesDir = join(dstDir, "slices");
-                        if (existsSync(srcSlicesDir) && !existsSync(dstSlicesDir)) {
-                            try {
-                                cpSync(srcSlicesDir, dstSlicesDir, { recursive: true });
-                                synced.push(`milestones/${mid}/slices/`);
-                            }
-                            catch (err) {
-                                /* non-fatal */
-                                logWarning("worktree", `slices copy failed (${mid}): ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                        }
-                        else if (existsSync(srcSlicesDir) && existsSync(dstSlicesDir)) {
-                            // Both exist — sync missing slice directories
-                            const srcSlices = readdirSync(srcSlicesDir, {
-                                withFileTypes: true,
-                            })
-                                .filter((d) => d.isDirectory())
-                                .map((d) => d.name);
-                            for (const sid of srcSlices) {
-                                const srcSlice = join(srcSlicesDir, sid);
-                                const dstSlice = join(dstSlicesDir, sid);
-                                if (!existsSync(dstSlice)) {
-                                    try {
-                                        cpSync(srcSlice, dstSlice, { recursive: true });
-                                        synced.push(`milestones/${mid}/slices/${sid}/`);
-                                    }
-                                    catch (err) {
-                                        /* non-fatal */
-                                        logWarning("worktree", `slice copy failed (${mid}/${sid}): ${err instanceof Error ? err.message : String(err)}`);
+                            else if (existsSync(srcSlicesDir) && existsSync(dstSlicesDir)) {
+                                // Both exist — sync missing slice directories
+                                const srcSlices = readdirSync(srcSlicesDir, {
+                                    withFileTypes: true,
+                                })
+                                    .filter((d) => d.isDirectory())
+                                    .map((d) => d.name);
+                                for (const sid of srcSlices) {
+                                    const srcSlice = join(srcSlicesDir, sid);
+                                    const dstSlice = join(dstSlicesDir, sid);
+                                    if (!existsSync(dstSlice)) {
+                                        try {
+                                            cpSync(srcSlice, dstSlice, { recursive: true });
+                                            synced.push(`milestones/${mid}/slices/${sid}/`);
+                                        }
+                                        catch (err) {
+                                            /* non-fatal */
+                                            logWarning("worktree", `slice copy failed (${mid}/${sid}): ${err instanceof Error ? err.message : String(err)}`);
+                                        }
                                     }
                                 }
                             }
                         }
-                    }
-                    catch (err) {
-                        /* non-fatal */
-                        logWarning("worktree", `milestone file sync failed: ${err instanceof Error ? err.message : String(err)}`);
+                        catch (err) {
+                            /* non-fatal */
+                            logWarning("worktree", `milestone file sync failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }
                     }
                 }
             }
-        }
-        catch (err) {
-            /* non-fatal */
-            logWarning("worktree", `milestone directory sync failed: ${err instanceof Error ? err.message : String(err)}`);
+            catch (err) {
+                /* non-fatal */
+                logWarning("worktree", `milestone directory sync failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     return { synced };
@@ -1148,6 +1176,19 @@ export function getAutoWorktreeOriginalBase() {
 export function _resetAutoWorktreeOriginalBaseForTests() {
     setActiveWorkspace(null);
 }
+/**
+ * Inject an override for the shelter restore copy step, returning a function
+ * that restores the default (real cpSync) behavior. Used by tests to
+ * deterministically exercise the best-effort restore-failure path
+ * (auto-worktree.ts:1809) and the #2505 shelter-retention guarantee — which is
+ * otherwise unreachable because shelter + restore run synchronously in one
+ * mergeMilestoneToMain call. No production caller.
+ * @internal
+ */
+export function _setRestoreEntryFnForTests(fn) {
+    _restoreEntryFn = fn;
+    return () => { _restoreEntryFn = null; };
+}
 export function getActiveAutoWorktreeContext() {
     const ws = getActiveWorkspace();
     if (!ws)
@@ -1484,10 +1525,18 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // MUST run BEFORE the pre-merge stash (step 7a) so `--include-untracked`
     // does not sweep queued CONTEXT files into the stash. If stash pop later
     // fails, files trapped inside the stash are permanently lost (#2505).
-    const milestonesDir = join(gsdRoot(originalBasePath_), "milestones");
+    const planningDir = milestonesDir(originalBasePath_);
     const shelterDir = join(gsdRoot(originalBasePath_), ".milestone-shelter");
     const shelteredDirs = [];
     let shelterRestored = false;
+    const mergeDirNames = new Set([milestoneId]);
+    const resolvedMergeDir = resolveMilestonePath(originalBasePath_, milestoneId);
+    if (resolvedMergeDir) {
+        mergeDirNames.add(basename(resolvedMergeDir));
+    }
+    else {
+        mergeDirNames.add(canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+    }
     // Helper: restore sheltered milestone directories (#2505).
     // Called on both success and error paths to ensure queued CONTEXT files
     // are never permanently lost. Idempotent — the error path may fire after
@@ -1512,8 +1561,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 continue;
             }
             try {
-                mkdirSync(milestonesDir, { recursive: true });
-                cpSync(src, join(milestonesDir, dirName), { recursive: true, force: true });
+                mkdirSync(planningDir, { recursive: true });
+                // Test seam: when _restoreEntryFn is injected, route the copy through it
+                // so the best-effort failure path (and shelter-retention guarantee) can
+                // be exercised deterministically. Production leaves it null → real cpSync.
+                const dest = join(planningDir, dirName);
+                if (_restoreEntryFn) {
+                    _restoreEntryFn(src, dest);
+                }
+                else {
+                    cpSync(src, dest, { recursive: true, force: true });
+                }
             }
             catch (err) { /* best-effort */
                 restoreFailed = true;
@@ -1537,15 +1595,15 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         }
     };
     try {
-        if (existsSync(milestonesDir)) {
-            const entries = readdirSync(milestonesDir, { withFileTypes: true });
+        if (existsSync(planningDir)) {
+            const entries = readdirSync(planningDir, { withFileTypes: true });
             for (const entry of entries) {
                 if (!entry.isDirectory())
                     continue;
                 // Only shelter directories that do NOT belong to the milestone being merged
-                if (entry.name === milestoneId)
+                if (mergeDirNames.has(entry.name))
                     continue;
-                const srcDir = join(milestonesDir, entry.name);
+                const srcDir = join(planningDir, entry.name);
                 const dstDir = join(shelterDir, entry.name);
                 try {
                     mkdirSync(shelterDir, { recursive: true });
@@ -1570,8 +1628,8 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //     branch. Passing NO pathspec lets git skip gitignored paths silently;
     //     adding an explicit pathspec trips a `git add`-style fatal on ignored
     //     entries (e.g. a gitignored `.gsd` symlink under ADR-002) (#4573).
-    //     Queued CONTEXT files under `.gsd/milestones/*` are already sheltered
-    //     in step 7 above, so they won't be swept into the stash.
+    //     Queued CONTEXT files under `.gsd/phases/*` (or legacy milestones/*)
+    //     are already sheltered in step 7 above, so they won't be swept into the stash.
     // On Windows, SQLite holds mandatory file locks on the gsd.db WAL/SHM
     // sidecars while the connection is open. `git stash --include-untracked`
     // walks those files and fails with EBUSY (#4704). Close the DB before

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

@@ -19,13 +19,13 @@ import { setRuntimeKv, deleteRuntimeKv, } from "./db/runtime-kv.js";
 import { extractSection, getManifestStatus, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
-import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milestonesDir, } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milestonesDir, legacyMilestonesDir, isLegacyMilestonesLayout, canonicalPhaseDirName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
 import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
-import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
+import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, loadEffectiveGSDPreferencesWithRegistry, resolveProfileAnchorProvider, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
 import { playNotificationBell, sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
@@ -507,20 +507,26 @@ export function _setAutoActiveForTest(active) {
  */
 export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
     if (worktreePath && !existsSync(worktreePath)) {
-        logWarning("session", `Worktree was expected at ${worktreePath} 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 });
+        logWarning("session", `Worktree was expected at ${worktreePath} but is missing. Resuming from project root; /gsd next will recreate the worktree when isolation is enabled.`, { file: "auto.ts", milestoneId });
         return true;
     }
     return false;
 }
-export function anchorProcessCwdForAutoResume(basePath) {
-    try {
-        process.chdir(basePath);
-        return true;
-    }
-    catch (err) {
-        logWarning("session", `resume cwd anchor failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath });
-        return false;
+export function anchorProcessCwdForAutoResume(basePath, fallbackPaths = []) {
+    const candidates = [basePath, ...fallbackPaths].filter((candidate, index, all) => Boolean(candidate) && all.indexOf(candidate) === index);
+    for (const candidate of candidates) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            process.chdir(candidate);
+            return true;
+        }
+        catch (err) {
+            logWarning("session", `resume cwd anchor failed for ${candidate}: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath: candidate });
+        }
     }
+    logWarning("session", `resume cwd anchor failed: no usable directory among ${candidates.join(", ")}`, { file: "auto.ts" });
+    return false;
 }
 export function isAutoPaused() {
     return s.paused;
@@ -764,6 +770,39 @@ function pauseAutoUnitIdentityMatches(expected) {
 function shouldPreserveCoordinationForPause(errorContext) {
     return errorContext?.category === "provider" && errorContext.isTransient === true;
 }
+function resolvePauseLifecyclePresentation(errorContext) {
+    const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
+    const modeLabel = s.stepMode ? "Step" : "Auto";
+    const defaultPresentation = {
+        status: "paused",
+        title: `${modeLabel}-mode paused`,
+        detail: errorContext?.message ?? "Paused by user request.",
+        nextAction: `Type to steer, or run ${resumeCmd} to resume.`,
+        commands: [resumeCmd, "/gsd status for overview", "/gsd notifications for history"],
+        notifyLevel: "info",
+        notifyPrefix: `${modeLabel}-mode paused`,
+    };
+    const message = errorContext?.message ?? "";
+    if (message.includes("completed closeout dispatch history") ||
+        message.includes("completed complete-milestone dispatch history")) {
+        const milestoneMatch = message.match(/Milestone (M\d+[A-Z0-9-]*)/);
+        const milestoneId = milestoneMatch?.[1] ?? "this milestone";
+        return {
+            status: "blocked",
+            title: `${modeLabel}-mode blocked`,
+            detail: message,
+            nextAction: `Run \`/gsd dispatch complete-milestone ${milestoneId}\` to finish closeout, then ${resumeCmd}.`,
+            commands: [
+                `/gsd dispatch complete-milestone ${milestoneId}`,
+                `/gsd status ${milestoneId}`,
+                resumeCmd,
+            ],
+            notifyLevel: "warning",
+            notifyPrefix: `${modeLabel}-mode blocked`,
+        };
+    }
+    return defaultPresentation;
+}
 function setLifecycleOutcome(ctx, input) {
     if (!ctx?.hasUI)
         return;
@@ -796,11 +835,15 @@ function setTerminalCloseoutOutcome(ctx, input) {
         invalidate() { },
     }));
     ctx.ui.setStatus?.("gsd-step", undefined);
+    ctx.ui?.setGsdProgress?.(undefined);
     ctx.ui.setWidget?.("gsd-progress", undefined);
+    const detail = input.allMilestonesComplete && input.milestoneTitle
+        ? `${input.milestoneTitle}. All milestones complete`
+        : `${titleLine}${input.reason ?? "Milestone closeout finished."}`;
     setLifecycleOutcome(ctx, {
         status: "complete",
         title,
-        detail: `${titleLine}${input.reason ?? "Milestone closeout finished."}`,
+        detail,
         nextAction,
         commands: TERMINAL_CLOSEOUT_COMMANDS,
         unitLabel: input.milestoneId ? `complete-milestone ${input.milestoneId}` : null,
@@ -1515,6 +1558,10 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
         });
         return;
     }
+    anchorProcessCwdForAutoResume(s.basePath || s.originalBasePath || "", [
+        s.originalBasePath,
+        lockBase(),
+    ].filter((path) => Boolean(path)));
     s.active = false;
     s.paused = true;
     clearUnitTimeout();
@@ -1624,21 +1671,21 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
     s.pendingVerificationRetry = null;
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
-    const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
+    const lifecycle = resolvePauseLifecyclePresentation(_errorContext);
     setLifecycleOutcome(ctx, {
-        status: "paused",
-        title: `${s.stepMode ? "Step" : "Auto"}-mode paused`,
-        detail: _errorContext?.message ?? "Paused by user request.",
-        nextAction: `Type to steer, or run ${resumeCmd} to resume.`,
-        commands: [resumeCmd, "/gsd status for overview", "/gsd notifications for history"],
+        status: lifecycle.status,
+        title: lifecycle.title,
+        detail: lifecycle.detail,
+        nextAction: lifecycle.nextAction,
+        commands: lifecycle.commands,
         unitLabel: pausedUnitLabel,
     });
     if (ctx)
         initHealthWidget(ctx);
     const pauseMessage = _errorContext?.message
-        ? `${s.stepMode ? "Step" : "Auto"}-mode paused: ${_errorContext.message}`
-        : `${s.stepMode ? "Step" : "Auto"}-mode paused (Escape). Type to interact, or ${resumeCmd} to resume.`;
-    ctx?.ui.notify(pauseMessage, "info");
+        ? `${lifecycle.notifyPrefix}: ${_errorContext.message}`
+        : `${lifecycle.notifyPrefix} (Escape). Type to interact, or ${lifecycle.commands[0] ?? (s.stepMode ? "/gsd next" : "/gsd auto")} to resume.`;
+    ctx?.ui.notify(pauseMessage, lifecycle.notifyLevel);
 }
 /**
  * Build a WorktreeLifecycle Module wrapping the current session.
@@ -1701,7 +1748,7 @@ function ensureOrchestrationModule(ctx, pi, basePath) {
  * Build the LoopDeps object from auto.ts private scope.
  * This bundles all private functions that autoLoop needs without exporting them.
  */
-function buildLoopDeps(pi) {
+function buildLoopDeps(pi, ctx) {
     // Initialize the unified rule registry with converted dispatch rules.
     // Must happen before LoopDeps is assembled so facade functions
     // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
@@ -1724,7 +1771,7 @@ function buildLoopDeps(pi) {
         invalidateAllCaches,
         deriveState,
         rebuildState,
-        loadEffectiveGSDPreferences,
+        loadEffectiveGSDPreferences: () => loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, s.basePath || undefined, resolveProfileAnchorProvider(ctx.model?.provider, s.autoModeStartModel?.provider), s.autoModeStartModel ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}` : undefined),
         // Pre-dispatch health gate
         preDispatchHealthGate,
         // Worktree state projection (ADR-016 — single Module Interface)
@@ -1852,7 +1899,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // resume paths (#4416). The matching call in auto-start.ts covers the
     // bootstrap-only path; this call ensures the resume path is also protected.
     if (recoverFailedMigration(base)) {
-        ctx.ui.notify("Recovered unfinished migration (.gsd.migrating → .gsd).", "info");
+        ctx.ui.notify("Recovered unfinished external state migration.", "info");
     }
     const unmergedStartMessage = await getUnmergedMilestoneBlockMessageForBase(base, "auto");
     if (unmergedStartMessage) {
@@ -1957,7 +2004,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         {
                             const persistedWorktreePath = meta.worktreePath ?? null;
                             if (persistedWorktreePath && !existsSync(persistedWorktreePath)) {
-                                logWarning("session", `Worktree was expected at ${persistedWorktreePath} 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: meta.milestoneId ?? "" });
+                                logWarning("session", `Worktree was expected at ${persistedWorktreePath} but is missing. Resuming from project root; /gsd next will recreate the worktree when isolation is enabled.`, { file: "auto.ts", milestoneId: meta.milestoneId ?? "" });
                             }
                             const rawForScope = (persistedWorktreePath && existsSync(persistedWorktreePath))
                                 ? persistedWorktreePath
@@ -2039,11 +2086,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // worktree directory safely falls back to the project root.
         const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath ?? null;
         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 ?? "" });
+            logWarning("session", `Worktree was expected at ${resumeWorktreePath} but is missing. Resuming from project root; /gsd next will recreate the worktree when isolation is enabled.`, { file: "auto.ts", milestoneId: s.currentMilestoneId ?? "" });
         }
         // ADR-016 phase 2 / B3 (#5621): paused-resume worktree-path adoption.
         buildLifecycle().resumeFromPausedSession(base, resumeWorktreePath);
-        anchorProcessCwdForAutoResume(s.basePath || base);
+        anchorProcessCwdForAutoResume(s.basePath || base, [
+            base,
+            s.originalBasePath || base,
+        ]);
         // 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
@@ -2083,7 +2133,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             // s.basePath may have been updated to a worktree path by enterMilestone.
             rebuildScope(s.basePath, s.currentMilestoneId);
         }
-        const loopDeps = buildLoopDeps(pi);
+        const loopDeps = buildLoopDeps(pi, ctx);
         ensureOrchestrationModule(ctx, pi, s.basePath || base);
         registerSigtermHandler(lockBase());
         setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
@@ -2172,7 +2222,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // Build scope after bootstrap has populated s.basePath / s.originalBasePath /
     // s.currentMilestoneId (including worktree setup inside bootstrapAutoSession).
     rebuildScope(s.basePath, s.currentMilestoneId);
-    const loopDeps = buildLoopDeps(pi);
+    const loopDeps = buildLoopDeps(pi, ctx);
     ensureOrchestrationModule(ctx, pi, s.basePath || base);
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     registerAutoWorkerForSession(s);
@@ -2242,10 +2292,26 @@ export function ensurePreconditions(unitType, unitId, base, state) {
                 return;
             }
         }
-        const newDir = join(milestonesDir(base), mid);
-        mkdirSync(join(newDir, "slices"), { recursive: true });
+        // Layout-aware: if the legacy milestones/ dir exists, place the new milestone dir
+        // there (preserves the existing project layout). Otherwise use flat-phase phases/.
+        const legacyBase = legacyMilestonesDir(base);
+        const isLegacyLayout = isLegacyMilestonesLayout(base);
+        const targetBase = isLegacyLayout ? legacyBase : milestonesDir(base);
+        // Flat-phase: look up the milestone title to build the canonical NN-slug dir name
+        // (e.g. "01-foundation") that resolveMilestonePath will later find by prefix.
+        // Legacy layout keeps the raw milestone id (e.g. "M001").
+        const dirName = isLegacyLayout
+            ? mid
+            : canonicalPhaseDirName(mid, getMilestone(mid)?.title);
+        const newDir = join(targetBase, dirName);
+        // Legacy projects use a slices/ subdir; flat-phase uses top-level plan files (no slices/).
+        mkdirSync(isLegacyLayout ? join(newDir, "slices") : newDir, { recursive: true });
     }
     if (sid !== undefined) {
+        const isLegacyLayout = isLegacyMilestonesLayout(base);
+        // Flat-phase: tasks are checkboxes in NN-MM-PLAN.md — no slices/ subdir needed.
+        if (!isLegacyLayout)
+            return;
         const mDirResolved = resolveMilestonePath(base, mid);
         if (mDirResolved) {
             const slicesDir = join(mDirResolved, "slices");