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

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

@@ -161,6 +161,15 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     const unitPromise = new Promise((resolve) => {
         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 });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
@@ -249,6 +258,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
             // 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", {
@@ -261,6 +271,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
                 ctx.ui.notify(`Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}: ${midTitle}.`, "info");
                 deps.sendDesktopNotification("GSD", `Milestone ${s.currentMilestoneId} complete!`, "success", "milestone");
+                deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
                 const vizPrefs = deps.loadEffectiveGSDPreferences()?.preferences;
                 if (vizPrefs?.auto_visualize) {
                     ctx.ui.notify("Run /gsd visualize to see progress overview.", "info");
@@ -354,6 +365,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                         deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                     }
                     deps.sendDesktopNotification("GSD", "All milestones complete!", "success", "milestone");
+                    deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, "All milestones complete.", "success");
                     await deps.stopAuto(ctx, pi, "All milestones complete");
                 }
                 else if (state.phase === "blocked") {
@@ -361,6 +373,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     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) => m.id).join(", ");
@@ -406,6 +419,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
                 }
                 deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "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;
@@ -419,6 +433,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 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;
             }
@@ -449,30 +464,35 @@ export async function autoLoop(ctx, pi, s, deps) {
                     if (budgetEnforcementAction === "pause") {
                         ctx.ui.notify(`${msg} Pausing auto-mode — /gsd auto to override and continue.`, "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;
                     ctx.ui.notify(`Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
                     deps.sendDesktopNotification("GSD", `Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning", "budget");
+                    deps.logCmuxEvent(prefs, `Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
                 }
                 else if (newBudgetAlertLevel === 80) {
                     s.lastBudgetAlertLevel =
                         newBudgetAlertLevel;
                     ctx.ui.notify(`Approaching budget ceiling — 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
                     deps.sendDesktopNotification("GSD", `Approaching budget ceiling — 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning", "budget");
+                    deps.logCmuxEvent(prefs, `Budget 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
                 }
                 else if (newBudgetAlertLevel === 75) {
                     s.lastBudgetAlertLevel =
                         newBudgetAlertLevel;
                     ctx.ui.notify(`Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "info");
                     deps.sendDesktopNotification("GSD", `Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "info", "budget");
+                    deps.logCmuxEvent(prefs, `Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "progress");
                 }
                 else if (budgetAlertLevel === 0) {
                     s.lastBudgetAlertLevel = 0;
@@ -498,7 +518,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
             // 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, mid, ctx);
                     if (result &&
@@ -623,6 +643,11 @@ export async function autoLoop(ctx, pi, s, deps) {
                 unitType,
                 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(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
@@ -728,8 +753,8 @@ export async function autoLoop(ctx, pi, s, deps) {
                 const msg = reorderErr instanceof Error ? reorderErr.message : String(reorderErr);
                 process.stderr.write(`[gsd] prompt reorder failed (non-fatal): ${msg}\n`);
             }
-            // Select and apply model
-            const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel);
+            // Select and apply model (with tier escalation on retry)
+            const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, { isRetry, previousTier });
             s.currentUnitRouting =
                 modelResult.routing;
             // Start unit supervision

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -5,7 +5,7 @@
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.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";
 /**
@@ -15,7 +15,7 @@ import { unitPhaseLabel } from "./auto-dashboard.js";
  *
  * Returns routing metadata for metrics tracking.
  */
-export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel) {
+export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext) {
     const modelConfig = resolveModelWithFallbacksForUnit(unitType);
     let routing = null;
     if (modelConfig) {
@@ -37,8 +37,20 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
             const isHook = unitType.startsWith("hook/");
             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);
+                    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) {
                     effectiveModelConfig = {

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

@@ -6,11 +6,13 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
+import { parseUnitId } from "./unit-id.js";
 import { clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import { isValidationTerminal } from "./state.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { dirname, join } from "node:path";
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
@@ -432,6 +434,39 @@ export async function selfHealRuntimeRecords(base, ctx) {
         const now = Date.now();
         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/dist/resources/extensions/gsd/auto-start.js

@@ -11,6 +11,8 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, 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 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -42,6 +44,12 @@ import { sep as pathSep } from "node:path";
  * 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, ctx, pi, base, verboseMode, requestedStepMode, deps) {
     const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildResolver, } = deps;
     const lockResult = acquireSessionLock(base);
@@ -60,7 +68,19 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
             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;
@@ -186,6 +206,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         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 });
                 invalidateAllCaches();
@@ -193,6 +223,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 if (postState.activeMilestone &&
                     postState.phase !== "complete" &&
                     postState.phase !== "pre-planning") {
+                    _consecutiveCompleteBootstraps = 0; // Successfully advanced past "complete"
                     state = postState;
                 }
                 else if (postState.activeMilestone &&
@@ -237,6 +268,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
             return releaseLockAndReturn();
         }
+        // Successfully resolved an active milestone — reset the re-entry guard
+        _consecutiveCompleteBootstraps = 0;
         // ── Initialize session state ──
         s.active = true;
         s.stepMode = requestedStepMode;
@@ -345,7 +378,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // 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 (result &&

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

@@ -36,7 +36,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, 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, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
@@ -50,6 +50,7 @@ import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } 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";
 import { runPostUnitVerification } from "./auto-verification.js";
@@ -248,6 +249,7 @@ function handleLostSessionLock(ctx) {
     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");
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
@@ -256,6 +258,7 @@ function handleLostSessionLock(ctx) {
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
         return;
+    const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
     clearUnitTimeout();
     if (lockBase())
@@ -314,6 +317,8 @@ export async function stopAuto(ctx, pi, reason) {
             });
         }
     }
+    clearCmuxSidebar(loadedPreferences);
+    logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
     if (isDebugEnabled()) {
         const logPath = writeDebugSummary();
         if (logPath) {
@@ -325,6 +330,13 @@ export async function stopAuto(ctx, pi, reason) {
     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;
@@ -369,10 +381,28 @@ export async function pauseAuto(ctx, _pi) {
         return;
     clearUnitTimeout();
     s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
-    if (lockBase())
-        clearLock(lockBase());
-    if (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();
     s.active = false;
     s.paused = true;
@@ -430,6 +460,8 @@ function buildLoopDeps() {
         pauseAuto,
         clearUnitTimeout,
         updateProgressWidget,
+        syncCmuxSidebar,
+        logCmuxEvent,
         // State and cache
         invalidateAllCaches,
         deriveState,
@@ -520,6 +552,30 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // Escape stale worktree cwd from a previous milestone (#608).
     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) {
@@ -556,6 +612,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         restoreHookState(s.basePath);
         try {
             await rebuildState(s.basePath);
+            syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
         }
         catch (e) {
             debugLog("resume-rebuild-state-failed", {
@@ -585,6 +642,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown", s.completedUnits.length);
         writeLock(lockBase(), "resuming", 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;
     }
@@ -598,6 +656,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps);
     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());
 }
@@ -754,6 +819,12 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     }, hookHardTimeoutMs);
     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,

package/dist/resources/extensions/gsd/commands-cmux.js

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync } from "node:fs";
+import { clearCmuxSidebar, CmuxClient, detectCmuxEnvironment, resolveCmuxConfig } from "../cmux/index.js";
+import { saveFile } from "./files.js";
+import { getProjectGSDPreferencesPath, loadEffectiveGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+function extractBodyAfterFrontmatter(content) {
+    const start = content.startsWith("---\n") ? 4 : content.startsWith("---\r\n") ? 5 : -1;
+    if (start === -1)
+        return null;
+    const closingIdx = content.indexOf("\n---", start);
+    if (closingIdx === -1)
+        return null;
+    const after = content.slice(closingIdx + 4);
+    return after.trim() ? after : null;
+}
+async function writeProjectCmuxPreferences(ctx, updater) {
+    const path = getProjectGSDPreferencesPath();
+    await ensurePreferencesFile(path, ctx, "project");
+    const existing = loadProjectGSDPreferences();
+    const prefs = existing?.preferences ? { ...existing.preferences } : { version: 1 };
+    updater(prefs);
+    prefs.version = prefs.version || 1;
+    const frontmatter = serializePreferencesToFrontmatter(prefs);
+    let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+    if (existsSync(path)) {
+        const preserved = extractBodyAfterFrontmatter(readFileSync(path, "utf-8"));
+        if (preserved)
+            body = preserved;
+    }
+    await saveFile(path, `---\n${frontmatter}---${body}`);
+    await ctx.waitForIdle();
+    await ctx.reload();
+}
+function formatCmuxStatus() {
+    const loaded = loadEffectiveGSDPreferences();
+    const detected = detectCmuxEnvironment();
+    const resolved = resolveCmuxConfig(loaded?.preferences);
+    const capabilities = new CmuxClient(resolved).getCapabilities();
+    const accessMode = typeof capabilities?.mode === "string"
+        ? capabilities.mode
+        : typeof capabilities?.access_mode === "string"
+            ? capabilities.access_mode
+            : "unknown";
+    const methods = Array.isArray(capabilities?.methods) ? capabilities.methods.length : 0;
+    return [
+        "cmux status",
+        "",
+        `Detected: ${detected.available ? "yes" : "no"}`,
+        `Enabled: ${resolved.enabled ? "yes" : "no"}`,
+        `CLI available: ${detected.cliAvailable ? "yes" : "no"}`,
+        `Socket: ${detected.socketPath}`,
+        `Workspace: ${detected.workspaceId ?? "(none)"}`,
+        `Surface: ${detected.surfaceId ?? "(none)"}`,
+        `Features: notifications=${resolved.notifications ? "on" : "off"}, sidebar=${resolved.sidebar ? "on" : "off"}, splits=${resolved.splits ? "on" : "off"}, browser=${resolved.browser ? "on" : "off"}`,
+        `Capabilities: access=${accessMode}, methods=${methods}`,
+    ].join("\n");
+}
+function ensureCmuxAvailableForEnable(ctx) {
+    const detected = detectCmuxEnvironment();
+    if (detected.available)
+        return true;
+    ctx.ui.notify("cmux not detected. Install it from https://cmux.com and run gsd inside a cmux terminal.", "warning");
+    return false;
+}
+export async function handleCmux(args, ctx) {
+    const trimmed = args.trim();
+    if (!trimmed || trimmed === "status") {
+        ctx.ui.notify(formatCmuxStatus(), "info");
+        return;
+    }
+    if (trimmed === "on") {
+        if (!ensureCmuxAvailableForEnable(ctx))
+            return;
+        await writeProjectCmuxPreferences(ctx, (prefs) => {
+            prefs.cmux = {
+                enabled: true,
+                notifications: true,
+                sidebar: true,
+                splits: false,
+                browser: false,
+                ...(prefs.cmux ?? {}),
+            };
+            prefs.cmux.enabled = true;
+        });
+        ctx.ui.notify("cmux integration enabled in project preferences.", "info");
+        return;
+    }
+    if (trimmed === "off") {
+        const effective = loadEffectiveGSDPreferences()?.preferences;
+        await writeProjectCmuxPreferences(ctx, (prefs) => {
+            prefs.cmux = { ...(prefs.cmux ?? {}), enabled: false };
+        });
+        clearCmuxSidebar(effective);
+        ctx.ui.notify("cmux integration disabled in project preferences.", "info");
+        return;
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts.length === 2 && ["notifications", "sidebar", "splits", "browser"].includes(parts[0]) && ["on", "off"].includes(parts[1])) {
+        const feature = parts[0];
+        const enabled = parts[1] === "on";
+        if (enabled && !ensureCmuxAvailableForEnable(ctx))
+            return;
+        await writeProjectCmuxPreferences(ctx, (prefs) => {
+            const next = { ...(prefs.cmux ?? {}) };
+            next[feature] = enabled;
+            if (enabled)
+                next.enabled = true;
+            prefs.cmux = next;
+        });
+        if (!enabled && feature === "sidebar") {
+            clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
+        }
+        const note = feature === "browser" && enabled
+            ? " Browser surfaces are still a follow-up path."
+            : "";
+        ctx.ui.notify(`cmux ${feature} ${enabled ? "enabled" : "disabled"}.${note}`, "info");
+        return;
+    }
+    ctx.ui.notify("Usage: /gsd cmux <status|on|off|notifications on|notifications off|sidebar on|sidebar off|splits on|splits off|browser on|browser off>", "info");
+}

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -15,7 +15,7 @@ import { isAutoActive } from "./auto.js";
 import { projectRoot } from "./commands.js";
 import { loadPrompt } from "./prompt-loader.js";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     const prompt = loadPrompt("doctor-heal", {
         doctorSummary: reportText,
@@ -144,7 +144,7 @@ export async function handleTriage(ctx, pi, basePath) {
         currentPlan: currentPlan || "(no active slice plan)",
         roadmapContext: roadmapContext || "(no active roadmap)",
     });
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType: "gsd-triage",

package/dist/resources/extensions/gsd/commands-inspect.js

@@ -3,6 +3,9 @@
  *
  * Contains: InspectData type, formatInspectOutput, handleInspect
  */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
 import { getErrorMessage } from "./error-utils.js";
 export function formatInspectOutput(data) {
     const lines = [];
@@ -30,10 +33,14 @@ export function formatInspectOutput(data) {
 }
 export async function handleInspect(ctx) {
     try {
-        const { isDbAvailable, _getAdapter } = await import("./gsd-db.js");
+        const { isDbAvailable, _getAdapter, openDatabase } = await import("./gsd-db.js");
         if (!isDbAvailable()) {
-            ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
-            return;
+            const gsdDir = gsdRoot(process.cwd());
+            const dbPath = join(gsdDir, "gsd.db");
+            if (!existsSync(gsdDir) || !existsSync(dbPath) || !openDatabase(dbPath)) {
+                ctx.ui.notify("No GSD database available. Run /gsd auto to create one.", "info");
+                return;
+            }
         }
         const adapter = _getAdapter();
         if (!adapter) {

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -626,7 +626,7 @@ export function serializePreferencesToFrontmatter(prefs) {
         "skill_rules", "custom_instructions", "models", "skill_discovery",
         "skill_staleness_days", "auto_supervisor", "uat_dispatch", "unique_milestone_ids",
         "budget_ceiling", "budget_enforcement", "context_pause_threshold",
-        "notifications", "remote_questions", "git",
+        "notifications", "cmux", "remote_questions", "git",
         "post_unit_hooks", "pre_dispatch_hooks",
         "dynamic_routing", "token_profile", "phases", "parallel",
         "auto_visualize", "auto_report",