gsd-pi 2.35.0-dev.cd3b7ea → 2.36.0-dev.d612764

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -12,14 +12,16 @@
 import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
-import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
+import { loadFile, extractUatType, loadActiveOverrides, parseRoadmap } from "./files.js";
 import {
   resolveMilestoneFile,
   resolveMilestonePath,
   resolveSliceFile,
+  resolveSlicePath,
   resolveTaskFile,
   relSliceFile,
   buildMilestoneFileName,
+  buildSliceFileName,
 } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -369,6 +371,30 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "validating-milestone → validate-milestone",
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
       if (state.phase !== "validating-milestone") return null;
+
+      // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
+      // allowing milestone validation. If any slice lacks a summary, the milestone
+      // is not genuinely complete — something skipped earlier slices.
+      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+      if (roadmapContent) {
+        const roadmap = parseRoadmap(roadmapContent);
+        const missingSlices: string[] = [];
+        for (const slice of roadmap.slices) {
+          const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+          if (!summaryPath || !existsSync(summaryPath)) {
+            missingSlices.push(slice.id);
+          }
+        }
+        if (missingSlices.length > 0) {
+          return {
+            action: "stop",
+            reason: `Cannot validate milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. These slices may have been skipped.`,
+            level: "error",
+          };
+        }
+      }
+
       // Skip preference: write a minimal pass-through VALIDATION file
       if (prefs?.phases?.skip_milestone_validation) {
         const mDir = resolveMilestonePath(basePath, mid);
@@ -404,6 +430,28 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "completing-milestone → complete-milestone",
     match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "completing-milestone") return null;
+
+      // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
+      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+      if (roadmapContent) {
+        const roadmap = parseRoadmap(roadmapContent);
+        const missingSlices: string[] = [];
+        for (const slice of roadmap.slices) {
+          const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+          if (!summaryPath || !existsSync(summaryPath)) {
+            missingSlices.push(slice.id);
+          }
+        }
+        if (missingSlices.length > 0) {
+          return {
+            action: "stop",
+            reason: `Cannot complete milestone ${mid}: slices ${missingSlices.join(", ")} are missing SUMMARY files. Run /gsd doctor to diagnose.`,
+            level: "error",
+          };
+        }
+      }
+
       return {
         action: "dispatch",
         unitType: "complete-milestone",

package/src/resources/extensions/gsd/auto-loop.ts

@@ -25,6 +25,7 @@ import type {
 import type { DispatchAction } from "./auto-dispatch.js";
 import type { WorktreeResolver } from "./worktree-resolver.js";
 import { debugLog } from "./debug-logger.js";
+import type { CmuxLogLevel } from "../cmux/index.js";
 
 /**
  * Maximum total loop iterations before forced stop. Prevents runaway loops
@@ -221,6 +222,15 @@ export async function runUnit(
     s.pendingResolve = resolve;
   });
 
+  // Ensure cwd matches basePath before dispatch (#1389).
+  // async_bash and background jobs can drift cwd away from the worktree.
+  // Realigning here prevents commits from landing on the wrong branch.
+  try {
+    if (process.cwd() !== s.basePath) {
+      process.chdir(s.basePath);
+    }
+  } catch { /* non-fatal — chdir may fail if dir was removed */ }
+
   // ── Send the prompt ──
   debugLog("runUnit", { phase: "send-message", unitType, unitId });
 
@@ -267,6 +277,12 @@ export interface LoopDeps {
     unitId: string,
     state: GSDState,
   ) => void;
+  syncCmuxSidebar: (preferences: GSDPreferences | undefined, state: GSDState) => void;
+  logCmuxEvent: (
+    preferences: GSDPreferences | undefined,
+    message: string,
+    level?: CmuxLogLevel,
+  ) => void;
 
   // State and cache functions
   invalidateAllCaches: () => void;
@@ -344,6 +360,7 @@ export interface LoopDeps {
   getManifestStatus: (
     basePath: string,
     mid: string | undefined,
+    projectRoot?: string,
   ) => Promise<{ pending: unknown[] } | null>;
   collectSecretsFromManifest: (
     basePath: string,
@@ -446,6 +463,7 @@ export interface LoopDeps {
     prefs: GSDPreferences | undefined,
     verbose: boolean,
     startModel: { provider: string; id: string } | null,
+    retryContext?: { isRetry: boolean; previousTier?: string },
   ) => Promise<{ routing: { tier: string; modelDowngraded: boolean } | null }>;
   startUnitSupervision: (sctx: {
     s: AutoSession;
@@ -598,6 +616,7 @@ export async function autoLoop(
 
       // Derive state
       let state = await deps.deriveState(s.basePath);
+      deps.syncCmuxSidebar(deps.loadEffectiveGSDPreferences()?.preferences, state);
       let mid = state.activeMilestone?.id;
       let midTitle = state.activeMilestone?.title;
       debugLog("autoLoop", {
@@ -619,6 +638,11 @@ export async function autoLoop(
           "success",
           "milestone",
         );
+        deps.logCmuxEvent(
+          deps.loadEffectiveGSDPreferences()?.preferences,
+          `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`,
+          "success",
+        );
 
         const vizPrefs = deps.loadEffectiveGSDPreferences()?.preferences;
         if (vizPrefs?.auto_visualize) {
@@ -756,12 +780,18 @@ export async function autoLoop(
             "success",
             "milestone",
           );
+          deps.logCmuxEvent(
+            deps.loadEffectiveGSDPreferences()?.preferences,
+            "All milestones complete.",
+            "success",
+          );
           await deps.stopAuto(ctx, pi, "All milestones complete");
         } else if (state.phase === "blocked") {
           const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
           await deps.stopAuto(ctx, pi, blockerMsg);
           ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
           deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
+          deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, blockerMsg, "error");
         } else {
           const ids = incomplete.map((m: { id: string }) => m.id).join(", ");
           const diag = `basePath=${s.basePath}, milestones=[${state.registry.map((m: { id: string; status: string }) => `${m.id}:${m.status}`).join(", ")}], phase=${state.phase}`;
@@ -839,6 +869,11 @@ export async function autoLoop(
           "success",
           "milestone",
         );
+        deps.logCmuxEvent(
+          deps.loadEffectiveGSDPreferences()?.preferences,
+          `Milestone ${mid} complete.`,
+          "success",
+        );
         await deps.stopAuto(ctx, pi, `Milestone ${mid} complete`);
         debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
         break;
@@ -860,6 +895,7 @@ export async function autoLoop(
         await deps.stopAuto(ctx, pi, blockerMsg);
         ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
         deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
+        deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, blockerMsg, "error");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
         break;
       }
@@ -903,12 +939,14 @@ export async function autoLoop(
               "warning",
             );
             deps.sendDesktopNotification("GSD", msg, "warning", "budget");
+            deps.logCmuxEvent(prefs, msg, "warning");
             await deps.pauseAuto(ctx, pi);
             debugLog("autoLoop", { phase: "exit", reason: "budget-pause" });
             break;
           }
           ctx.ui.notify(`${msg} Continuing (enforcement: warn).`, "warning");
           deps.sendDesktopNotification("GSD", msg, "warning", "budget");
+          deps.logCmuxEvent(prefs, msg, "warning");
         } else if (newBudgetAlertLevel === 90) {
           s.lastBudgetAlertLevel =
             newBudgetAlertLevel as AutoSession["lastBudgetAlertLevel"];
@@ -922,6 +960,11 @@ export async function autoLoop(
             "warning",
             "budget",
           );
+          deps.logCmuxEvent(
+            prefs,
+            `Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`,
+            "warning",
+          );
         } else if (newBudgetAlertLevel === 80) {
           s.lastBudgetAlertLevel =
             newBudgetAlertLevel as AutoSession["lastBudgetAlertLevel"];
@@ -935,6 +978,11 @@ export async function autoLoop(
             "warning",
             "budget",
           );
+          deps.logCmuxEvent(
+            prefs,
+            `Budget 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`,
+            "warning",
+          );
         } else if (newBudgetAlertLevel === 75) {
           s.lastBudgetAlertLevel =
             newBudgetAlertLevel as AutoSession["lastBudgetAlertLevel"];
@@ -948,6 +996,11 @@ export async function autoLoop(
             "info",
             "budget",
           );
+          deps.logCmuxEvent(
+            prefs,
+            `Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`,
+            "progress",
+          );
         } else if (budgetAlertLevel === 0) {
           s.lastBudgetAlertLevel = 0;
         }
@@ -983,7 +1036,7 @@ export async function autoLoop(
 
       // Secrets re-check gate
       try {
-        const manifestStatus = await deps.getManifestStatus(s.basePath, mid);
+        const manifestStatus = await deps.getManifestStatus(s.basePath, mid, s.originalBasePath);
         if (manifestStatus && manifestStatus.pending.length > 0) {
           const result = await deps.collectSecretsFromManifest(
             s.basePath,
@@ -1172,6 +1225,14 @@ export async function autoLoop(
         unitId,
       });
 
+      // Detect retry and capture previous tier for escalation
+      const isRetry = !!(
+        s.currentUnit &&
+        s.currentUnit.type === unitType &&
+        s.currentUnit.id === unitId
+      );
+      const previousTier = s.currentUnitRouting?.tier;
+
       // Closeout previous unit
       if (s.currentUnit) {
         await deps.closeoutUnit(
@@ -1325,7 +1386,7 @@ export async function autoLoop(
         );
       }
 
-      // Select and apply model
+      // Select and apply model (with tier escalation on retry)
       const modelResult = await deps.selectAndApplyModel(
         ctx,
         pi,
@@ -1335,6 +1396,7 @@ export async function autoLoop(
         prefs,
         s.verbose,
         s.autoModeStartModel,
+        { isRetry, previousTier },
       );
       s.currentUnitRouting =
         modelResult.routing as AutoSession["currentUnitRouting"];

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -7,8 +7,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import type { GSDPreferences } from "./preferences.js";
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
+import type { ComplexityTier } from "./complexity-classifier.js";
 import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
-import { resolveModelForComplexity } from "./model-router.js";
+import { resolveModelForComplexity, escalateTier } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 
@@ -33,6 +34,7 @@ export async function selectAndApplyModel(
   prefs: GSDPreferences | undefined,
   verbose: boolean,
   autoModeStartModel: { provider: string; id: string } | null,
+  retryContext?: { isRetry: boolean; previousTier?: string },
 ): Promise<ModelSelectionResult> {
   const modelConfig = resolveModelWithFallbacksForUnit(unitType);
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
@@ -60,8 +62,27 @@ export async function selectAndApplyModel(
       const shouldClassify = !isHook || routingConfig.hooks !== false;
 
       if (shouldClassify) {
-        const classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
+        let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
         const availableModelIds = availableModels.map(m => m.id);
+
+        // Escalate tier on retry when escalate_on_failure is enabled (default: true)
+        if (
+          retryContext?.isRetry &&
+          retryContext.previousTier &&
+          routingConfig.escalate_on_failure !== false
+        ) {
+          const escalated = escalateTier(retryContext.previousTier as ComplexityTier);
+          if (escalated) {
+            classification = { ...classification, tier: escalated, reason: "escalated after failure" };
+            if (verbose) {
+              ctx.ui.notify(
+                `Tier escalation: ${retryContext.previousTier} → ${escalated} (retry after failure)`,
+                "info",
+              );
+            }
+          }
+        }
+
         const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
 
         if (routingResult.wasDowngraded) {

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -8,6 +8,8 @@
  */
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import { parseUnitId } from "./unit-id.js";
+import { atomicWriteSync } from "./atomic-write.js";
 import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import { isValidationTerminal } from "./state.js";
@@ -35,6 +37,7 @@ import {
   clearPathCache,
   resolveGsdRootFile,
 } from "./paths.js";
+import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import {
   existsSync,
   mkdirSync,
@@ -499,6 +502,42 @@ export async function selfHealRuntimeRecords(
     for (const record of records) {
       const { unitType, unitId } = record;
 
+      // Case 0: complete-slice with SUMMARY + UAT but unchecked roadmap (#1350).
+      // If a complete-slice was interrupted after writing artifacts but before
+      // flipping the roadmap checkbox, the verification fails and the dispatch
+      // loop relaunches the same unit forever. Auto-fix the checkbox.
+      if (unitType === "complete-slice") {
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
+        if (mid && sid) {
+          const dir = resolveSlicePath(base, mid, sid);
+          if (dir) {
+            const summaryPath = join(dir, buildSliceFileName(sid, "SUMMARY"));
+            const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
+            if (existsSync(summaryPath) && existsSync(uatPath)) {
+              const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+              if (roadmapFile && existsSync(roadmapFile)) {
+                try {
+                  const roadmapContent = readFileSync(roadmapFile, "utf-8");
+                  const roadmap = parseRoadmap(roadmapContent);
+                  const slice = (roadmap.slices ?? []).find(s => s.id === sid);
+                  if (slice && !slice.done) {
+                    // Auto-fix: flip the checkbox using shared utility
+                    if (markSliceDoneInRoadmap(base, mid, sid)) {
+                      ctx.ui.notify(
+                        `Self-heal: marked ${sid} done in roadmap (SUMMARY + UAT exist but checkbox was stale).`,
+                        "info",
+                      );
+                    }
+                  }
+                } catch {
+                  // Roadmap parse failure — don't block self-heal
+                }
+              }
+            }
+          }
+        }
+      }
+
       // Clear stale dispatched records (dispatched > 1h ago, process crashed)
       const age = now - (record.startedAt ?? 0);
       if (record.phase === "dispatched" && age > STALE_THRESHOLD_MS) {

package/src/resources/extensions/gsd/auto-start.ts

@@ -20,6 +20,8 @@ import {
   resolveSkillDiscoveryMode,
   getIsolationMode,
 } from "./preferences.js";
+import { ensureGsdSymlink } from "./repo-identity.js";
+import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile, milestonesDir } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -92,6 +94,13 @@ export interface BootstrapDeps {
  * Returns false if the bootstrap aborted (e.g., guided flow returned,
  * concurrent session detected). Returns true when ready to dispatch.
  */
+
+/** Guard: tracks consecutive bootstrap attempts that found phase === "complete".
+ *  Prevents the recursive dialog loop described in #1348 where
+ *  bootstrapAutoSession → showSmartEntry → checkAutoStartAfterDiscuss → startAuto
+ *  cycles indefinitely when the discuss workflow doesn't produce a milestone. */
+let _consecutiveCompleteBootstraps = 0;
+const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export async function bootstrapAutoSession(
   s: AutoSession,
   ctx: ExtensionCommandContext,
@@ -128,7 +137,20 @@ export async function bootstrapAutoSession(
       nativeInit(base, mainBranch);
     }
 
-    // Ensure .gitignore has baseline patterns
+    // Migrate legacy in-project .gsd/ to external state directory.
+    // Migration MUST run before ensureGitignore to avoid adding ".gsd" to
+    // .gitignore when .gsd/ is git-tracked (data-loss bug #1364).
+    recoverFailedMigration(base);
+    const migration = migrateToExternalState(base);
+    if (migration.error) {
+      ctx.ui.notify(`External state migration warning: ${migration.error}`, "warning");
+    }
+    // Ensure symlink exists (handles fresh projects and post-migration)
+    ensureGsdSymlink(base);
+
+    // Ensure .gitignore has baseline patterns.
+    // ensureGitignore checks for git-tracked .gsd/ files and skips the
+    // ".gsd" pattern if the project intentionally tracks .gsd/ in git.
     const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
     const commitDocs = gitPrefs?.commit_docs;
     const manageGitignore = gitPrefs?.manage_gitignore;
@@ -286,6 +308,20 @@ export async function bootstrapAutoSession(
     if (!hasSurvivorBranch) {
       // No active work — start a new milestone via discuss flow
       if (!state.activeMilestone || state.phase === "complete") {
+        // Guard against recursive dialog loop (#1348):
+        // If we've entered this branch multiple times in quick succession,
+        // the discuss workflow isn't producing a milestone. Break the cycle.
+        _consecutiveCompleteBootstraps++;
+        if (_consecutiveCompleteBootstraps > MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS) {
+          _consecutiveCompleteBootstraps = 0;
+          ctx.ui.notify(
+            "All milestones are complete and the discussion didn't produce a new one. " +
+            "Run /gsd to start a new milestone manually.",
+            "warning",
+          );
+          return releaseLockAndReturn();
+        }
+
         const { showSmartEntry } = await import("./guided-flow.js");
         await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
 
@@ -296,6 +332,7 @@ export async function bootstrapAutoSession(
           postState.phase !== "complete" &&
           postState.phase !== "pre-planning"
         ) {
+          _consecutiveCompleteBootstraps = 0; // Successfully advanced past "complete"
           state = postState;
         } else if (
           postState.activeMilestone &&
@@ -352,6 +389,9 @@ export async function bootstrapAutoSession(
       return releaseLockAndReturn();
     }
 
+    // Successfully resolved an active milestone — reset the re-entry guard
+    _consecutiveCompleteBootstraps = 0;
+
     // ── Initialize session state ──
     s.active = true;
     s.stepMode = requestedStepMode;
@@ -484,7 +524,7 @@ export async function bootstrapAutoSession(
     // Secrets collection gate
     const mid = state.activeMilestone!.id;
     try {
-      const manifestStatus = await getManifestStatus(base, mid);
+      const manifestStatus = await getManifestStatus(base, mid, s.originalBasePath || base);
       if (manifestStatus && manifestStatus.pending.length > 0) {
         const result = await collectSecretsFromManifest(base, mid, ctx);
         if (

package/src/resources/extensions/gsd/auto.ts

@@ -127,7 +127,7 @@ import {
   formatTokenCount,
 } from "./metrics.js";
 import { join } from "node:path";
-import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import {
   autoCommitCurrentBranch,
@@ -184,6 +184,7 @@ import {
 } from "./auto-supervisor.js";
 import { isDbAvailable } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
+import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.js";
 
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
@@ -466,6 +467,7 @@ function handleLostSessionLock(ctx?: ExtensionContext): void {
   s.paused = false;
   clearUnitTimeout();
   deregisterSigtermHandler();
+  clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
   ctx?.ui.notify(
     "Session lock lost — another GSD process appears to have taken over. Stopping gracefully.",
     "error",
@@ -481,6 +483,7 @@ export async function stopAuto(
   reason?: string,
 ): Promise<void> {
   if (!s.active && !s.paused) return;
+  const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
   const reasonSuffix = reason ? ` — ${reason}` : "";
   clearUnitTimeout();
   if (lockBase()) clearLock(lockBase());
@@ -543,6 +546,13 @@ export async function stopAuto(
     }
   }
 
+  clearCmuxSidebar(loadedPreferences);
+  logCmuxEvent(
+    loadedPreferences,
+    `Auto-mode stopped${reasonSuffix || ""}.`,
+    reason?.startsWith("Blocked:") ? "warning" : "info",
+  );
+
   if (isDebugEnabled()) {
     const logPath = writeDebugSummary();
     if (logPath) {
@@ -554,6 +564,13 @@ export async function stopAuto(
   resetRoutingHistory();
   resetHookState();
   if (s.basePath) clearPersistedHookState(s.basePath);
+
+  // Remove paused-session metadata if present (#1383)
+  try {
+    const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
+    if (existsSync(pausedPath)) unlinkSync(pausedPath);
+  } catch { /* non-fatal */ }
+
   s.active = false;
   s.paused = false;
   s.stepMode = false;
@@ -607,8 +624,32 @@ export async function pauseAuto(
 
   s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
 
-  if (lockBase()) clearLock(lockBase());
-  if (lockBase()) releaseSessionLock(lockBase());
+  // Persist paused-session metadata so resume survives /exit (#1383).
+  // The fresh-start bootstrap checks for this file and restores worktree context.
+  try {
+    const pausedMeta = {
+      milestoneId: s.currentMilestoneId,
+      worktreePath: isInAutoWorktree(s.basePath) ? s.basePath : null,
+      originalBasePath: s.originalBasePath,
+      stepMode: s.stepMode,
+      pausedAt: new Date().toISOString(),
+      sessionFile: s.pausedSessionFile,
+    };
+    const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(
+      join(runtimeDir, "paused-session.json"),
+      JSON.stringify(pausedMeta, null, 2),
+      "utf-8",
+    );
+  } catch {
+    // Non-fatal — resume will still work via full bootstrap, just without worktree context
+  }
+
+  if (lockBase()) {
+    releaseSessionLock(lockBase());
+    clearLock(lockBase());
+  }
 
   deregisterSigtermHandler();
 
@@ -677,6 +718,8 @@ function buildLoopDeps(): LoopDeps {
     pauseAuto,
     clearUnitTimeout,
     updateProgressWidget,
+    syncCmuxSidebar,
+    logCmuxEvent,
 
     // State and cache
     invalidateAllCaches,
@@ -792,6 +835,30 @@ export async function startAuto(
   base = escapeStaleWorktree(base);
 
   // If resuming from paused state, just re-activate and dispatch next unit.
+  // Check persisted paused-session first (#1383) — survives /exit.
+  if (!s.paused) {
+    try {
+      const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
+      if (existsSync(pausedPath)) {
+        const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
+        if (meta.milestoneId) {
+          s.currentMilestoneId = meta.milestoneId;
+          s.originalBasePath = meta.originalBasePath || base;
+          s.stepMode = meta.stepMode ?? requestedStepMode;
+          s.paused = true;
+          // Clean up the persisted file — we're consuming it
+          try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
+          ctx.ui.notify(
+            `Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`,
+            "info",
+          );
+        }
+      }
+    } catch {
+      // Malformed or missing — proceed with fresh bootstrap
+    }
+  }
+
   if (s.paused) {
     const resumeLock = acquireSessionLock(base);
     if (!resumeLock.acquired) {
@@ -835,6 +902,7 @@ export async function startAuto(
     restoreHookState(s.basePath);
     try {
       await rebuildState(s.basePath);
+      syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
     } catch (e) {
       debugLog("resume-rebuild-state-failed", {
         error: e instanceof Error ? e.message : String(e),
@@ -886,6 +954,7 @@ export async function startAuto(
       s.currentMilestoneId ?? "unknown",
       s.completedUnits.length,
     );
+    logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
 
     await autoLoop(ctx, pi, s, buildLoopDeps());
     return;
@@ -910,6 +979,13 @@ export async function startAuto(
   );
   if (!ready) return;
 
+  try {
+    syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
+  } catch {
+    // Best-effort only — sidebar sync must never block auto-mode startup
+  }
+  logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
+
   // Dispatch the first unit
   await autoLoop(ctx, pi, s, buildLoopDeps());
 }
@@ -1145,6 +1221,9 @@ export async function dispatchHookUnit(
   ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
   ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
 
+  // Ensure cwd matches basePath before hook dispatch (#1389)
+  try { if (process.cwd() !== s.basePath) process.chdir(s.basePath); } catch {}
+
   debugLog("dispatchHookUnit", {
     phase: "send-message",
     promptLength: hookPrompt.length,