gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.d0517ff

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

@@ -20,7 +20,7 @@ import { synthesizeCrashRecovery } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, formatCrashInfo, isLockProcessAlive, } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeInit, nativeAddAll, nativeCommit, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
@@ -48,11 +48,8 @@ import { resolveDefaultSessionModel } from "./preferences-models.js";
  * 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;
+// Guard constant for consecutive bootstrap attempts that found phase === "complete".
+// Counter moved to AutoSession.consecutiveCompleteBootstraps so s.reset() clears it.
 const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export async function openProjectDbIfPresent(basePath) {
     const gsdDbPath = resolveProjectRootDbPath(basePath);
@@ -263,9 +260,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 // 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;
+                s.consecutiveCompleteBootstraps++;
+                if (s.consecutiveCompleteBootstraps > MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS) {
+                    s.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();
@@ -277,7 +274,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"
+                    s.consecutiveCompleteBootstraps = 0; // Successfully advanced past "complete"
                     state = postState;
                 }
                 else if (postState.activeMilestone &&
@@ -338,7 +335,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             return releaseLockAndReturn();
         }
         // Successfully resolved an active milestone — reset the re-entry guard
-        _consecutiveCompleteBootstraps = 0;
+        s.consecutiveCompleteBootstraps = 0;
         // ── Initialize session state ──
         s.active = true;
         s.stepMode = requestedStepMode;
@@ -373,6 +370,22 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
             setActiveMilestoneId(base, s.currentMilestoneId);
         }
+        // Guard against stale milestone branch when isolation:none (#3613).
+        // A prior session with isolation:branch/worktree may have left HEAD on
+        // milestone/<MID>. Auto-checkout back to the integration branch.
+        if (getIsolationMode() === "none" && nativeIsRepo(base)) {
+            try {
+                const currentBranch = nativeGetCurrentBranch(base);
+                if (currentBranch.startsWith("milestone/")) {
+                    const integrationBranch = nativeDetectMainBranch(base);
+                    nativeCheckoutBranch(base, integrationBranch);
+                    logWarning("bootstrap", `Returned to "${integrationBranch}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
+                }
+            }
+            catch (err) {
+                logWarning("bootstrap", `Could not auto-checkout from stale milestone branch: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         // ── Auto-worktree setup ──
         s.originalBasePath = base;
         const isUnderGsdWorktrees = (p) => {
@@ -448,6 +461,24 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 id: startModelSnapshot.id,
             };
         }
+        // Apply worker model override from parallel orchestrator (#worker-model).
+        // GSD_WORKER_MODEL is injected by the coordinator when parallel.worker_model
+        // is configured, so parallel milestone workers use a cheaper model than the
+        // coordinator session (e.g. Haiku for execution, Sonnet for planning).
+        const workerModelOverride = process.env.GSD_WORKER_MODEL;
+        if (workerModelOverride && process.env.GSD_PARALLEL_WORKER === "1") {
+            const availableModels = ctx.modelRegistry.getAvailable();
+            const { resolveModelId } = await import("./auto-model-selection.js");
+            const overrideModel = resolveModelId(workerModelOverride, availableModels, ctx.model?.provider);
+            if (overrideModel) {
+                const ok = await pi.setModel(overrideModel, { persist: false });
+                if (ok) {
+                    // Update start model so all subsequent units use this as the baseline
+                    s.autoModeStartModel = { provider: overrideModel.provider, id: overrideModel.id };
+                    ctx.ui.notify(`Worker model override: ${overrideModel.provider}/${overrideModel.id}`, "info");
+                }
+            }
+        }
         // Snapshot installed skills
         if (resolveSkillDiscoveryMode() !== "off") {
             snapshotSkills();

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -92,3 +92,13 @@ export function isToolInvocationError(errorMsg) {
         return false;
     return TOOL_INVOCATION_ERROR_RE.test(errorMsg);
 }
+/**
+ * Returns true if the error message indicates the tool was skipped because
+ * a queued user message interrupted the turn (#3595).  Retrying will produce
+ * the same skip, so the unit should be paused rather than retried.
+ */
+export function isQueuedUserMessageSkip(errorMsg) {
+    if (!errorMsg)
+        return false;
+    return /^Skipped due to queued user message\.?$/i.test(errorMsg.trim());
+}

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

@@ -135,8 +135,10 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
             unlinkSync(file);
         }
         catch (err) {
-            /* non-fatal — file may not exist */
-            logWarning("worktree", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+            // ENOENT is expected — file may not exist (#3597)
+            if (err.code !== "ENOENT") {
+                logWarning("worktree", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // Clean up entire synced milestone directory and runtime/units.
@@ -160,8 +162,11 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
                             unlinkSync(join(basePath, f));
                         }
                         catch (err) {
-                            /* non-fatal */
-                            logWarning("worktree", `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+                            // ENOENT/EISDIR are expected for already-removed or directory entries (#3597)
+                            const code = err.code;
+                            if (code !== "ENOENT" && code !== "EISDIR") {
+                                logWarning("worktree", `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
                         }
                     }
                 }
@@ -656,6 +661,10 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
             .filter((d) => d.isDirectory())
             .map((d) => d.name);
         for (const mid of wtMilestones) {
+            // Skip the current milestone being merged — its files are already in the
+            // milestone branch and would conflict with the squash merge (#3641).
+            if (mid === milestoneId)
+                continue;
             syncMilestoneDir(wtGsd, mainGsd, mid, synced);
         }
     }
@@ -901,11 +910,19 @@ export function createAutoWorktree(basePath, milestoneId) {
         });
     }
     else {
-        // Fresh start — create branch from integration branch
+        // Fresh start — create branch from integration branch.
+        // Use the same 3-tier fallback as mergeMilestoneToMain (#3461):
+        //   1. META.json integration branch (explicit per-milestone override)
+        //   2. git.main_branch preference (user's configured working branch)
+        //   3. nativeDetectMainBranch (origin/HEAD auto-detection)
+        // Without tier 2, projects with main_branch=dev but origin/HEAD→master
+        // would fork worktrees from the wrong (stale) branch.
         const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
+        const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+        const startPoint = integrationBranch ?? gitPrefs?.main_branch ?? undefined;
         info = createWorktree(basePath, milestoneId, {
             branch,
-            startPoint: integrationBranch,
+            startPoint,
         });
     }
     // Copy .gsd/ planning artifacts from the source repo into the new worktree.
@@ -1235,7 +1252,12 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //    checkout and leave the user with a broken merge state (#1668).
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
     const integrationBranch = readIntegrationBranch(originalBasePath_, milestoneId);
-    const mainBranch = integrationBranch ?? prefs.main_branch ?? nativeDetectMainBranch(originalBasePath_);
+    // Validate prefs.main_branch exists before using it — a stale preference
+    // (e.g. "master" when repo uses "main") causes merge failure (#3589).
+    const validatedPrefBranch = prefs.main_branch && nativeBranchExists(originalBasePath_, prefs.main_branch)
+        ? prefs.main_branch
+        : undefined;
+    const mainBranch = integrationBranch ?? validatedPrefBranch ?? nativeDetectMainBranch(originalBasePath_);
     // Remove transient project-root state files before any branch or merge
     // operation. Untracked milestone metadata can otherwise block squash merges.
     clearProjectRootStateFiles(originalBasePath_, milestoneId);

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

@@ -23,7 +23,7 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -201,7 +201,7 @@ export function markToolEnd(toolCallId) {
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!s.active)
         return;
-    if (isToolInvocationError(errorMsg)) {
+    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg)) {
         s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }
@@ -845,12 +845,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     s.stepMode = meta.stepMode ?? requestedStepMode;
                     s.autoStartTime = meta.autoStartTime || Date.now();
                     s.paused = true;
-                    try {
-                        unlinkSync(pausedPath);
-                    }
-                    catch (err) { /* non-fatal */
-                        logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                    }
+                    // Don't delete pause file yet — defer until lock is acquired.
+                    // If lock fails, the file must survive for retry.
+                    s.pausedSessionFile = pausedPath;
                     ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
                 }
                 else if (meta.milestoneId) {
@@ -873,13 +870,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.stepMode = meta.stepMode ?? requestedStepMode;
                         s.autoStartTime = meta.autoStartTime || Date.now();
                         s.paused = true;
-                        // Clean up the persisted file — we're consuming it
-                        try {
-                            unlinkSync(pausedPath);
-                        }
-                        catch (err) { /* non-fatal */
-                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                        }
+                        // Don't delete pause file yet — defer until lock is acquired.
+                        // If lock fails, the file must survive for retry.
+                        s.pausedSessionFile = pausedPath;
                         ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
                     }
                 }
@@ -893,9 +886,22 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (s.paused) {
         const resumeLock = acquireSessionLock(base);
         if (!resumeLock.acquired) {
+            // Reset paused state so isAutoPaused() doesn't stick true after lock failure.
+            // Pause file is preserved on disk for retry — not deleted.
+            s.paused = false;
             ctx.ui.notify(`Cannot resume: ${resumeLock.reason}`, "error");
             return;
         }
+        // Lock acquired — now safe to delete the pause file
+        if (s.pausedSessionFile) {
+            try {
+                unlinkSync(s.pausedSessionFile);
+            }
+            catch (err) {
+                logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+            }
+            s.pausedSessionFile = null;
+        }
         s.paused = false;
         s.active = true;
         s.verbose = verboseMode;

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

@@ -79,11 +79,24 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
-        const errorDetail = "errorMessage" in lastMsg && lastMsg.errorMessage ? `: ${lastMsg.errorMessage}` : "";
-        const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        // #3588: errorMessage can be useless (e.g. "success") while the real error
+        // is in the assistant message text content. Fall back to content when
+        // errorMessage looks uninformative.
+        const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+        // #3588: When errorMessage is uninformative, extract the real error from
+        // the assistant message text content for display purposes only.
+        // Classification still uses rawErrorMsg to avoid false positives from prose.
+        let displayMsg = rawErrorMsg;
+        if (isUseless && "content" in lastMsg && Array.isArray(lastMsg.content)) {
+            const textBlock = lastMsg.content.find((b) => b.type === "text" && b.text);
+            if (textBlock)
+                displayMsg = textBlock.text.slice(0, 300);
+        }
+        const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-        // ── 1. Classify ──────────────────────────────────────────────────────
-        const cls = classifyError(errorMsg, explicitRetryAfterMs);
+        // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
+        const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)
         // which use per-user quotas with shorter windows (#2922).
         if (cls.kind === "rate-limit") {

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -943,6 +943,16 @@ export function registerDbTools(pi) {
             }
             updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
             invalidateStateCache();
+            // Rebuild STATE.md so it reflects the skip immediately (#3477).
+            // Without this, /gsd auto reads stale STATE.md and resumes the skipped slice.
+            try {
+                const basePath = process.cwd();
+                const { rebuildState } = await import("../doctor.js");
+                await rebuildState(basePath);
+            }
+            catch (err) {
+                logError("tool", `skip_slice rebuildState failed: ${err.message}`, { tool: "gsd_skip_slice" });
+            }
             return {
                 content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
                 details: {

package/dist/resources/extensions/gsd/bootstrap/query-tools.js

@@ -17,10 +17,12 @@ export function registerQueryTools(pi) {
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             try {
-                // Strictly read-only: only use an already-open DB connection.
-                // Do NOT call ensureDbOpen() — it can create/migrate the DB as a side effect.
-                const { isDbAvailable, getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
-                if (!isDbAvailable()) {
+                // Open the DB if not already open — safe for read-only use since
+                // ensureDbOpen() only creates/migrates when .gsd/ has content (#3644).
+                const { ensureDbOpen } = await import("./dynamic-tools.js");
+                const dbAvailable = await ensureDbOpen();
+                const { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
+                if (!dbAvailable) {
                     return {
                         content: [{ type: "text", text: "Error: GSD database is not available." }],
                         details: { operation: "milestone_status", error: "db_unavailable" },

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -31,7 +31,11 @@ function installEpipeGuard() {
             if (handleRecoverableExtensionProcessError(err)) {
                 return;
             }
-            throw err;
+            // Log unhandled errors instead of re-throwing — throwing inside an
+            // uncaughtException handler is a fatal double-fault in Node.js (#3163).
+            process.stderr.write(`[gsd] uncaught extension error (non-fatal): ${err.message}\n`);
+            if (err.stack)
+                process.stderr.write(`${err.stack}\n`);
         };
         process.on("uncaughtException", _gsdEpipeGuard);
     }

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -3,7 +3,7 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
-import { clearDiscussionFlowState, isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution } from "./write-gate.js";
+import { clearDiscussionFlowState, isDepthVerified, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution } from "./write-gate.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { cleanupQuickBranch } from "../quick.js";
 import { getDiscussionMilestoneId } from "../guided-flow.js";
@@ -98,7 +98,10 @@ export function registerHooks(pi) {
         }
     });
     pi.on("session_before_compact", async () => {
-        if (isAutoActive() || isAutoPaused()) {
+        // Only cancel compaction while auto-mode is actively running.
+        // Paused auto-mode should allow compaction — the user may be doing
+        // interactive work (#3165).
+        if (isAutoActive()) {
             return { cancel: true };
         }
         const basePath = process.cwd();
@@ -227,7 +230,12 @@ export function registerHooks(pi) {
         const questions = event.input?.questions ?? [];
         for (const question of questions) {
             if (typeof question.id === "string" && question.id.includes("depth_verification")) {
-                markDepthVerified();
+                // Only unlock the gate if the user selected the first option (confirmation).
+                // Cross-references against the question's defined options to reject free-form "Other" text.
+                const answer = details.response?.answers?.[question.id];
+                if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
+                    markDepthVerified();
+                }
                 break;
             }
         }

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -43,6 +43,30 @@ export function clearDiscussionFlowState() {
 export function markDepthVerified() {
     depthVerificationDone = true;
 }
+/**
+ * Check whether a depth_verification answer confirms the discussion is complete.
+ * Uses structural validation: the selected answer must exactly match the first
+ * option label from the question definition (the confirmation option by convention).
+ * This rejects free-form "Other" text, decline options, and garbage input without
+ * coupling to any specific label substring.
+ *
+ * @param selected  The answer's selected value from details.response.answers[id].selected
+ * @param options   The question's options array from event.input.questions[n].options
+ */
+export function isDepthConfirmationAnswer(selected, options) {
+    const value = Array.isArray(selected) ? selected[0] : selected;
+    if (typeof value !== "string" || !value)
+        return false;
+    // If options are available, structurally validate: selected must exactly match
+    // the first option (confirmation) label. Rejects free-form "Other" and decline options.
+    if (Array.isArray(options) && options.length > 0) {
+        const confirmLabel = options[0]?.label;
+        return typeof confirmLabel === "string" && value === confirmLabel;
+    }
+    // Fallback when options aren't available (e.g., older call sites):
+    // accept only if it contains "(Recommended)" — the prompt convention suffix.
+    return value.includes("(Recommended)");
+}
 export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthVerified, queuePhaseActive) {
     if (toolName !== "write")
         return { block: false };
@@ -56,7 +80,13 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthV
         return { block: false };
     return {
         block: true,
-        reason: `Blocked: Cannot write to milestone CONTEXT.md during discussion phase without depth verification. Call ask_user_questions with question id "depth_verification" first to confirm discussion depth before writing context.`,
+        reason: [
+            `HARD BLOCK: Cannot write to milestone CONTEXT.md without depth verification.`,
+            `This is a mechanical gate — you MUST NOT proceed, retry, or rationalize past this block.`,
+            `Required action: call ask_user_questions with question id containing "depth_verification".`,
+            `The user MUST select the "(Recommended)" confirmation option to unlock this gate.`,
+            `If the user declines, cancels, or the tool fails, you must re-ask — not bypass.`,
+        ].join(" "),
     };
 }
 /**

package/dist/resources/extensions/gsd/commands/context.js

@@ -4,7 +4,14 @@ import { resolveProjectRoot } from "../worktree.js";
 import { showNextAction } from "../../shared/tui.js";
 import { handleStatus } from "./handlers/core.js";
 export function projectRoot() {
-    const cwd = process.cwd();
+    let cwd;
+    try {
+        cwd = process.cwd();
+    }
+    catch {
+        // cwd directory was deleted (e.g. worktree teardown) — fall back to HOME (#3598)
+        cwd = process.env.HOME ?? "/";
+    }
     const root = resolveProjectRoot(cwd);
     if (root !== cwd) {
         assertSafeDirectory(cwd);

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

@@ -48,6 +48,7 @@ export function showHelp(ctx) {
         "  /gsd cmux           Manage cmux integration  [status|on|off|notifications|sidebar|splits|browser]",
         "  /gsd config         Set API keys for external tools",
         "  /gsd keys           API key manager  [list|add|remove|test|rotate|doctor]",
+        "  /gsd show-config    Show effective configuration (models, routing, toggles)",
         "  /gsd hooks          Show post-unit hook configuration",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
         "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
@@ -66,6 +67,9 @@ export function showHelp(ctx) {
 }
 export async function handleStatus(ctx) {
     const basePath = projectRoot();
+    // Open DB in cold sessions so status uses DB-backed state, not filesystem fallback (#3385)
+    const { ensureDbOpen } = await import("../../bootstrap/dynamic-tools.js");
+    await ensureDbOpen();
     const state = await deriveState(basePath);
     if (state.registry.length === 0) {
         ctx.ui.notify("No GSD milestones found. Run /gsd to start.", "info");
@@ -188,6 +192,22 @@ export async function handleCoreCommand(trimmed, ctx) {
         await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "show-config") {
+        const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
+        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done()), {
+            overlay: true,
+            overlayOptions: {
+                width: "65%",
+                minWidth: 55,
+                maxHeight: "85%",
+                anchor: "center",
+            },
+        });
+        if (result === undefined) {
+            ctx.ui.notify(formatConfigText(), "info");
+        }
+        return true;
+    }
     if (trimmed === "setup" || trimmed.startsWith("setup ")) {
         await handleSetup(trimmed.replace(/^setup\s*/, "").trim(), ctx);
         return true;

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

@@ -68,7 +68,7 @@ function discoverManifests() {
     if (!existsSync(extDir))
         return manifests;
     for (const entry of readdirSync(extDir, { withFileTypes: true })) {
-        if (!entry.isDirectory())
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
             continue;
         const m = readManifest(join(extDir, entry.name));
         if (m)