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

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, } 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";
@@ -54,6 +54,7 @@ import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
+import { createMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -67,6 +68,7 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
+import { closeWorkflowDatabase } from "./db-workspace.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -109,12 +111,13 @@ void initTokenCounter().catch((err) => {
     logWarning("engine", `token counter warm-up failed: ${err instanceof Error ? err.message : String(err)}`);
 });
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
-import { autoSession as s } from "./auto-runtime-state.js";
+import { autoSession as s, getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { registerAutoWorker, markWorkerStopping, } from "./db/auto-workers.js";
 import { releaseMilestoneLease } from "./db/milestone-leases.js";
 import { normalizeRealPath } from "./paths.js";
+import { formatStopNoticePrefix, isBlockedStopReason, stopNoticeDisplayReason, } from "./stop-notice.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
@@ -135,17 +138,7 @@ export function formatAutoStopNotification(prefix, totals, unitCount) {
         `Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${unitCount} units`,
     ].join("\n");
 }
-function isBlockedStopReason(reason) {
-    return /^Blocked:\s*/i.test(reason ?? "");
-}
-function formatAutoStopDisplayReason(reason) {
-    return (reason ?? "").replace(/^Blocked:\s*/i, "").trim();
-}
-export function formatAutoStopNotificationPrefix(reason) {
-    const displayReason = formatAutoStopDisplayReason(reason);
-    const prefix = isBlockedStopReason(reason) ? "Auto-mode blocked" : "Auto-mode stopped";
-    return displayReason ? `${prefix} — ${displayReason}` : prefix;
-}
+export { formatStopNoticePrefix as formatAutoStopNotificationPrefix } from "./stop-notice.js";
 function clearSessionModelOverrideForCommandSession(ctx) {
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ??
         ctx?.sessionManager?.getSessionId?.();
@@ -344,14 +337,11 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
 export function shouldUseWorktreeIsolation(basePath) {
     return getIsolationMode(basePath) === "worktree";
 }
-function resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded) {
-    return configuredMode === "worktree" && isolationDegraded ? "branch" : configuredMode;
-}
-export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded) {
-    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded);
+export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded, strandedRecoveryIsolationMode = null) {
+    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded, strandedRecoveryIsolationMode);
 }
 function getEffectiveUnitIsolationMode(basePath) {
-    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded);
+    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded, s.strandedRecoveryIsolationMode);
 }
 /** Crash recovery prompt — set by startAuto, consumed by the main loop */
 /** Pending verification retry — set when gate fails with retries remaining, consumed by autoLoop */
@@ -463,6 +453,7 @@ function stopAutoCommandPolling() {
 }
 export function getAutoDashboardData() {
     const ledger = getLedger();
+    const runtimeSnapshot = getAutoRuntimeSnapshot();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
     const rtkSavings = sessionId && s.basePath
@@ -495,6 +486,7 @@ export function getAutoDashboardData() {
         pendingCaptureCount,
         rtkSavings,
         rtkEnabled,
+        toolSurface: runtimeSnapshot.toolSurface,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -515,11 +507,27 @@ 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, 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;
 }
@@ -565,6 +573,13 @@ export function getAutoModeStartModel() {
 export function setCurrentDispatchedModelId(model) {
     s.currentDispatchedModelId = model ? `${model.provider}/${model.id}` : null;
 }
+/**
+ * Update the active unit model after runtime recovery switches models mid-unit.
+ * The next session restore path reads this field before dispatching again.
+ */
+export function setCurrentUnitModelForRecovery(model) {
+    s.currentUnitModel = model;
+}
 // Tool tracking — delegates to auto-tool-tracking.ts
 export function markToolStart(toolCallId, toolName) {
     _markToolStart(toolCallId, s.active, toolName);
@@ -631,6 +646,35 @@ export function stopAutoRemote(projectRoot) {
         return { found: false, error: err.message };
     }
 }
+/**
+ * Force-stop a remote auto-mode session before stealing its lock.
+ * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
+ * this path is only for the explicit "Force start" action.
+ */
+export function forceStopAutoRemote(projectRoot) {
+    const lock = readCrashLock(projectRoot);
+    if (!lock)
+        return { found: false };
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    if (!isLockProcessAlive(lock)) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    try {
+        process.kill(lock.pid, "SIGTERM");
+        if (isLockProcessAlive(lock)) {
+            process.kill(lock.pid, "SIGKILL");
+        }
+        clearLock(projectRoot);
+        return { found: true, pid: lock.pid };
+    }
+    catch (err) {
+        return { found: false, error: err.message };
+    }
+}
 /**
  * Check if a remote auto-mode session is running (from a different process).
  * Reads the crash lock, checks PID liveness, and returns session details.
@@ -723,6 +767,42 @@ function pauseAutoUnitIdentityMatches(expected) {
         s.currentUnit.id === expected.id &&
         s.currentUnit.startedAt === expected.startedAt;
 }
+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;
@@ -755,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,
@@ -989,8 +1073,8 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     if (!s.active && !s.paused)
         return;
     const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
-    const stopNotificationPrefix = formatAutoStopNotificationPrefix(reason);
-    const displayReason = formatAutoStopDisplayReason(reason);
+    const stopNotificationPrefix = formatStopNoticePrefix(reason);
+    const displayReason = stopNoticeDisplayReason(reason);
     const isHeadlessStop = process.env.GSD_HEADLESS === "1";
     const completionStopRequested = Boolean(options.completionWidget);
     const preserveCloseoutTranscript = !isHeadlessStop && (options.preserveCloseoutTranscript ?? completionStopRequested);
@@ -1003,12 +1087,13 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     // worktree was active, and whether the current milestone was merged before
     // stopAuto. The unmerged-work warning is only meaningful for real worktrees.
     try {
-        const { emitAutoExit, normalizeAutoExitReason } = await import("./worktree-telemetry.js");
+        const { autoExitReasonForTerminalOutcome, emitAutoExit, normalizeAutoExitReason, } = await import("./worktree-telemetry.js");
         // Normalize the free-form reason to a closed set so the telemetry
         // aggregator buckets stably. Raw detail is preserved in the phases.ts
         // notification and the notify'd error string.
         const rawReason = reason ?? "stop";
-        const normalizedReason = normalizeAutoExitReason(rawReason);
+        const normalizedReason = autoExitReasonForTerminalOutcome(options.terminalOutcome)
+            ?? normalizeAutoExitReason(rawReason);
         const telemetryBase = s.originalBasePath || s.basePath;
         emitAutoExit(telemetryBase, {
             reason: normalizedReason,
@@ -1184,8 +1269,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
         // ── Step 6: DB cleanup ──
         if (isDbAvailable()) {
             try {
-                const { closeDatabase } = await import("./gsd-db.js");
-                closeDatabase();
+                closeWorkflowDatabase();
             }
             catch (e) {
                 debugLog("db-close-failed", {
@@ -1474,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();
@@ -1557,7 +1645,7 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
         releaseSessionLock(lockBase());
         clearLock(lockBase());
     }
-    if (s.workerId) {
+    if (s.workerId && !shouldPreserveCoordinationForPause(_errorContext)) {
         try {
             if (s.currentMilestoneId && s.milestoneLeaseToken) {
                 releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
@@ -1583,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.
@@ -1622,7 +1710,7 @@ export function buildWorktreeLifecycleDeps() {
     //   C4 (#5627) — GitServiceImpl constructor → gitServiceFactory
     //
     // Final WorktreeLifecycleDeps shape: 3 fields (gitServiceFactory,
-    // worktreeProjection, mergeMilestoneToMain). Down from 18 at slice-7
+    // worktreeProjection, mergeMilestoneToMain transaction runner). Down from 18 at slice-7
     // closure.
     return {
         gitServiceFactory: (basePath) => {
@@ -1630,7 +1718,7 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestoneToMain,
+        mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
     };
 }
 function buildLifecycle() {
@@ -1660,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.
@@ -1683,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)
@@ -1811,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) {
@@ -1832,7 +1920,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (freshStartAssessment.classification === "running") {
         const pid = freshStartAssessment.lock?.pid;
         ctx.ui.notify(pid
-            ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+            ? `Another auto-mode session (PID ${pid}) appears to be running.\nRun \`/gsd stop\` for graceful shutdown, or choose "Force start" from \`/gsd auto\` to terminate it.`
             : "Another auto-mode session appears to be running.", "error");
         return;
     }
@@ -1916,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
@@ -1998,10 +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, [
+            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
@@ -2041,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");
@@ -2130,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);
@@ -2200,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");

package/dist/resources/extensions/gsd/blocked-models.js

@@ -9,12 +9,16 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { withFileLockSync } from "./file-lock.js";
+const temporaryBlockedModels = new Map();
 function blockedModelsPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "blocked-models.json");
 }
 function modelKey(provider, id) {
     return `${provider.toLowerCase()}/${id.toLowerCase()}`;
 }
+function temporaryModelKey(basePath, provider, id) {
+    return `${basePath}:${modelKey(provider, id)}`;
+}
 function readFileSafe(path) {
     if (!existsSync(path))
         return { version: 1, blocked: [] };
@@ -41,6 +45,30 @@ export function isModelBlocked(basePath, provider, id) {
     const target = modelKey(provider, id);
     return loadBlockedModels(basePath).some((e) => modelKey(e.provider, e.id) === target);
 }
+export function blockModelUntil(basePath, provider, id, blockedUntil, reason) {
+    const key = temporaryModelKey(basePath, provider, id);
+    if (blockedUntil <= Date.now()) {
+        temporaryBlockedModels.delete(key);
+        return;
+    }
+    temporaryBlockedModels.set(key, { provider, id, reason, blockedUntil });
+}
+export function isModelTemporarilyUnavailable(basePath, provider, id, now = Date.now()) {
+    if (!provider || !id)
+        return false;
+    const key = temporaryModelKey(basePath, provider, id);
+    const entry = temporaryBlockedModels.get(key);
+    if (!entry)
+        return false;
+    if (entry.blockedUntil <= now) {
+        temporaryBlockedModels.delete(key);
+        return false;
+    }
+    return true;
+}
+export function clearTemporaryModelBlocksForTest() {
+    temporaryBlockedModels.clear();
+}
 export function blockModel(basePath, provider, id, reason) {
     const path = blockedModelsPath(basePath);
     mkdirSync(dirname(path), { recursive: true });