gsd-pi 2.76.0-dev.707772f58 → 2.76.0-dev.7218806ab

package/dist/claude-cli-check.js

@@ -12,12 +12,41 @@ import { execFileSync } from 'node:child_process';
  * `src/resources/extensions/gsd/pre-execution-checks.ts`.
  */
 export const CLAUDE_COMMAND = process.platform === 'win32' ? 'claude.cmd' : 'claude';
+/**
+ * Ordered list of binary names to probe for the Claude Code CLI.
+ *
+ * Windows installs vary: npm-global installs produce a `claude.cmd` shim,
+ * direct binary installs produce `claude.exe`, and Git Bash wrappers may
+ * expose a bare `claude` shim. Try all three so no valid install is missed.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === 'win32' ? [CLAUDE_COMMAND, 'claude.exe', 'claude'] : [CLAUDE_COMMAND];
+/**
+ * Try to run `args` against each candidate binary.
+ * Returns the output buffer on first success, throws the last error if all fail.
+ */
+function execClaudeCheck(args) {
+    let lastError;
+    for (const command of CLAUDE_COMMAND_CANDIDATES) {
+        try {
+            return execFileSync(command, args, { timeout: 5_000, stdio: 'pipe' });
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            // EINVAL can surface on Windows Git Bash for .cmd spawn failures.
+            if (code === 'ENOENT' || code === 'EINVAL')
+                continue;
+            throw error;
+        }
+    }
+    throw lastError ?? new Error(`Claude CLI not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(', ')})`);
+}
 /**
  * Check if the `claude` binary is installed (regardless of auth state).
  */
 export function isClaudeBinaryInstalled() {
     try {
-        execFileSync(CLAUDE_COMMAND, ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        execClaudeCheck(['--version']);
         return true;
     }
     catch {
@@ -29,13 +58,13 @@ export function isClaudeBinaryInstalled() {
  */
 export function isClaudeCliReady() {
     try {
-        execFileSync(CLAUDE_COMMAND, ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        execClaudeCheck(['--version']);
     }
     catch {
         return false;
     }
     try {
-        const output = execFileSync(CLAUDE_COMMAND, ['auth', 'status'], { timeout: 5_000, stdio: 'pipe' })
+        const output = execClaudeCheck(['auth', 'status'])
             .toString()
             .toLowerCase();
         return !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));

package/dist/mcp-server.d.ts

@@ -1,6 +1,11 @@
 /**
  * Minimal tool interface matching GSD's AgentTool shape.
  * Avoids a direct dependency on @gsd/pi-agent-core from this compiled module.
+ *
+ * `details` and `isError` are optional fields that runtime tool implementations
+ * may populate. The MCP transport drops non-standard fields, so the wrapper at
+ * the call site mirrors `details` into `structuredContent` and forwards
+ * `isError` directly. See #4472.
  */
 export interface McpToolDef {
     name: string;
@@ -13,6 +18,8 @@ export interface McpToolDef {
             data?: string;
             mimeType?: string;
         }>;
+        details?: Record<string, unknown>;
+        isError?: boolean;
     }>;
 }
 /**

package/dist/mcp-server.js

@@ -1,3 +1,21 @@
+/**
+ * Strict plain-object guard. True only for object literals and
+ * `Object.create(null)` — not for `Date`, `URL`, `Map`, `Set`, class instances,
+ * or arrays. Used to gate `structuredContent` forwarding so the MCP transport
+ * receives only true JSON objects (the protocol contract). See #4477 review.
+ *
+ * Mirrored in `packages/mcp-server/src/workflow-tools.ts` for the
+ * `adaptExecutorResult` adapter on the workflow path. Keep both copies in
+ * sync if the contract definition needs to evolve.
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
 // MCP SDK subpath imports use wildcard exports (./*) in @modelcontextprotocol/sdk's
 // package.json export map. The wildcard maps "./foo" → "./dist/cjs/foo" (no .js
 // suffix), so bare subpath specifiers like `${MCP_PKG}/server/stdio` resolve to
@@ -83,7 +101,23 @@ export async function startMcpServer(options) {
                 // by stringifying into a text block so clients see the payload.
                 return { type: 'text', text: JSON.stringify(block) };
             });
-            return { content };
+            // Forward a tool's runtime `details` field to MCP's `structuredContent`
+            // channel. The protocol drops non-standard fields on the wire, so tools
+            // that populate `details` for client-side renderers (e.g. save_gate_result)
+            // would otherwise arrive empty on the other side. See #4472.
+            //
+            // Use a strict plain-object guard (prototype-chain check) rather than just
+            // `typeof === 'object' && !Array.isArray()` — Date, URL, Map, Set, and
+            // class instances would otherwise pass through and end up as
+            // `structuredContent`, violating the protocol's JSON-object contract.
+            // The mirror discipline applies in `workflow-tools.ts adaptExecutorResult`.
+            const base = { content };
+            if (isPlainObject(result.details)) {
+                base.structuredContent = result.details;
+            }
+            if (result.isError === true)
+                base.isError = true;
+            return base;
         }
         catch (err) {
             // AbortError from a cancelled tool surfaces as a normal error — MCP

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -18,10 +18,11 @@ import { execFileSync } from "node:child_process";
 const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
 /**
  * Windows installs vary: some environments expose `claude.cmd` (npm shim),
- * others expose a `claude` shim on PATH (for example Git Bash wrappers).
- * Try both to avoid false "not installed" results in readiness checks.
+ * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
+ * (for example Git Bash wrappers). Try all three to avoid false "not
+ * installed" results in readiness checks.
  */
-const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude"] : [CLAUDE_COMMAND];
+const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
 function execClaude(args) {
     let lastError;
     for (const command of CLAUDE_COMMAND_CANDIDATES) {

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -484,25 +484,23 @@ export function makeAbortedMessage(model, lastTextContent) {
 /**
  * Resolve the Claude Code permission mode for the current run.
  *
- * GSD subagents run underneath a host Claude Code session the user has
- * already consented to, and their work (edits, shell inspection, MCP calls)
- * spans the full workflow toolset. Defaulting the inner SDK to
- * `bypassPermissions` avoids per-tool approval prompts that offer no
- * meaningful safety beyond what the host session and the subagent prompts
- * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
- * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ * Defaults to `acceptEdits`, which auto-approves file reads/edits but
+ * surfaces a permission dialog for dangerous operations (e.g. general Bash,
+ * Agent, WebFetch). This prevents tools outside the allowlist from being
+ * silently denied — the SDK emits an `extension_ui_request` event so the
+ * user sees a prompt instead of a silent refusal that Claude Code mistakes
+ * for user rejection (#4383).
  *
- * Tradeoff: bypass means a prompt-injection payload read from an untrusted
- * file could trigger tool calls without a second gate. Accepted for GSD
- * because the workflow is explicit user intent and the alternative
- * (#4099) is continuous approval fatigue that blocks real work.
+ * Set `GSD_CLAUDE_CODE_PERMISSION_MODE` to `bypassPermissions` to restore
+ * the old always-approve behaviour, or to `default` / `plan` for stricter
+ * modes.
  */
 export async function resolveClaudePermissionMode(env = process.env) {
     const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
     if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
         return override;
     }
-    return "bypassPermissions";
+    return "acceptEdits";
 }
 // NOTE: These helpers intentionally mirror @gsd/pi-ai anthropic-shared
 // behavior so this extension remains typecheck-stable even when the published
@@ -554,7 +552,7 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const { reasoning, ...sdkExtraOptions } = extraOptions;
     const mcpServers = buildWorkflowMcpServers();
-    const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
+    const permissionMode = overrides?.permissionMode ?? "acceptEdits";
     const disallowedTools = ["AskUserQuestion"];
     // Pre-authorize the safe built-ins and every registered workflow MCP
     // server's tools. `acceptEdits` mode (the interactive default) only
@@ -637,6 +635,68 @@ function normalizeToolResultContent(content) {
     }
     return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
 }
+/**
+ * Extract a `details` payload from an MCP tool-result block.
+ *
+ * MCP's `CallToolResult` carries structured data in `structuredContent` — the
+ * protocol's supported channel for non-text payloads. Claude Code's synthetic
+ * user message may surface that field in one of two shapes depending on SDK
+ * version: as a sibling on the `mcp_tool_result` block itself, or as a
+ * dedicated content sub-block with `type: "structuredContent"`. Snake-case
+ * (`structured_content`) is accepted defensively in case a transport hop
+ * rewrites casing. All other shapes fall back to an empty object so callers
+ * can rely on `details` being present.
+ */
+function extractStructuredDetailsFromBlock(block) {
+    const sibling = block.structuredContent ?? block.structured_content;
+    if (sibling && typeof sibling === "object" && !Array.isArray(sibling)) {
+        return sibling;
+    }
+    if (Array.isArray(block.content)) {
+        for (const item of block.content) {
+            if (!item || typeof item !== "object")
+                continue;
+            const sub = item;
+            if (sub.type !== "structuredContent" && sub.type !== "structured_content")
+                continue;
+            const payload = sub.structuredContent ?? sub.structured_content ?? sub.data ?? sub.value;
+            if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                return payload;
+            }
+        }
+    }
+    // Return undefined (not {}) when no structured payload is present, matching
+    // the pre-#4477 contract where `details` was nullable. An empty-object
+    // sentinel is truthy and breaks downstream consumers that gate on
+    // `if (details)`. `undefined` matches the type of the field these results
+    // flow into (`Record<string, unknown> | undefined`).
+    return undefined;
+}
+/**
+ * True for items that are MCP `structuredContent` pseudo-blocks living inside
+ * a tool-result `content[]` array. These blocks carry the structured payload
+ * (extracted separately by `extractStructuredDetailsFromBlock`) and must NOT
+ * leak into the visible content rendered to the user — otherwise the renderer
+ * stringifies the JSON pseudo-block and shows it next to the actual tool
+ * output. See PR #4477 review (CodeRabbit, post-fix-round).
+ */
+function isStructuredContentPseudoBlock(item) {
+    if (!item || typeof item !== "object")
+        return false;
+    const type = item.type;
+    return type === "structuredContent" || type === "structured_content";
+}
+/**
+ * Strip `structuredContent` pseudo-blocks from a tool-result content array
+ * before normalization. The structured payload is extracted via the sibling
+ * `structuredContent` field (or a dedicated extractor pass on the raw block);
+ * the visible content path must not include the pseudo-block itself.
+ */
+function stripStructuredContentPseudoBlocks(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content.filter((item) => !isStructuredContentPseudoBlock(item));
+}
 /** Extract tool result payloads from an SDK synthetic user message, keyed by tool-use ID. */
 export function extractToolResultsFromSdkUserMessage(message) {
     const extracted = [];
@@ -657,8 +717,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
         extracted.push({
             toolUseId,
             result: {
-                content: normalizeToolResultContent(block.content),
-                details: {},
+                content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(block.content)),
+                details: extractStructuredDetailsFromBlock(block),
                 isError: block.is_error === true,
             },
         });
@@ -672,8 +732,8 @@ export function extractToolResultsFromSdkUserMessage(message) {
                 extracted.push({
                     toolUseId,
                     result: {
-                        content: normalizeToolResultContent(toolResult.content),
-                        details: {},
+                        content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(toolResult.content)),
+                        details: extractStructuredDetailsFromBlock(toolResult),
                         isError: toolResult.is_error === true,
                     },
                 });

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

@@ -291,7 +291,7 @@ autoModeStartThinkingLevel) {
                 // ADR-005: Adjust active tool set for the selected model's provider capabilities.
                 // Hard-filter incompatible tools, then let extensions override via adjust_tool_set hook.
                 const activeToolNames = pi.getActiveTools();
-                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api);
+                const { toolNames: compatibleTools, removedTools } = adjustToolSet(activeToolNames, model.api, model.provider);
                 let finalToolNames = compatibleTools;
                 // Fire adjust_tool_set hook — extensions can override the filtered tool set
                 if (routingConfig.hooks !== false) {

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

@@ -30,8 +30,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, openDatabase } from "./gsd-db.js";
-import { hideFooter } from "./auto-dashboard.js";
+import { isDbAvailable, getMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
@@ -247,7 +246,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // the parent git root). See #2393 and related issue.
         const hasLocalGit = existsSync(join(base, ".git"));
         if (!hasLocalGit || isInheritedRepo(base)) {
-            const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
+            const mainBranch = loadEffectiveGSDPreferences(base)?.preferences?.git?.main_branch || "main";
             nativeInit(base, mainBranch);
         }
         // Migrate legacy in-project .gsd/ to external state directory.
@@ -263,7 +262,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // 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 gitPrefs = loadEffectiveGSDPreferences(base)?.preferences?.git;
         const manageGitignore = gitPrefs?.manage_gitignore;
         ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
@@ -289,7 +288,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             prepareWorkflowMcpForProject(ctx, base);
         }
         // Initialize GitServiceImpl
-        s.gitService = new GitServiceImpl(s.basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
+        s.gitService = new GitServiceImpl(s.basePath, loadEffectiveGSDPreferences(base)?.preferences?.git ?? {});
         // ── Debug mode ──
         if (!isDebugEnabled() && process.env.GSD_DEBUG === "1") {
             enableDebug(base);
@@ -322,7 +321,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // was lost due to session ending between completion and teardown.
         // Must run after DB open and before worktree entry.
         try {
-            const auditResult = auditOrphanedMilestoneBranches(base, getIsolationMode());
+            const auditResult = auditOrphanedMilestoneBranches(base, getIsolationMode(base));
             for (const msg of auditResult.recovered) {
                 ctx.ui.notify(`Orphan audit: ${msg}`, "info");
             }
@@ -340,7 +339,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         let state = await deriveState(base);
         // Stale worktree state recovery (#654)
         if (state.activeMilestone &&
-            shouldUseWorktreeIsolation() &&
+            shouldUseWorktreeIsolation(base) &&
             !detectWorktreeName(base)) {
             const wtPath = getAutoWorktreePath(base, state.activeMilestone.id);
             if (wtPath) {
@@ -355,7 +354,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         let hasSurvivorBranch = false;
         if (state.activeMilestone &&
             (state.phase === "pre-planning" || state.phase === "complete") &&
-            getIsolationMode() !== "none" &&
+            getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
             const milestoneBranch = `milestone/${state.activeMilestone.id}`;
@@ -516,7 +515,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         registerSigtermHandler(base);
         // Capture integration branch
         if (s.currentMilestoneId) {
-            if (getIsolationMode() !== "none") {
+            if (getIsolationMode(base) !== "none") {
                 captureIntegrationBranch(base, s.currentMilestoneId);
             }
             setActiveMilestoneId(base, s.currentMilestoneId);
@@ -524,7 +523,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // 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)) {
+        if (getIsolationMode(base) === "none" && nativeIsRepo(base)) {
             try {
                 const currentBranch = nativeGetCurrentBranch(base);
                 if (currentBranch.startsWith("milestone/")) {
@@ -552,7 +551,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             return symlinkRe.test(p);
         };
         if (s.currentMilestoneId &&
-            getIsolationMode() !== "none" &&
+            getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !isUnderGsdWorktrees(base)) {
             buildResolver().enterMilestone(s.currentMilestoneId, {
@@ -597,8 +596,21 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // call returns "db_unavailable", triggering artifact-retry which
         // re-dispatches the same task — producing an infinite loop (#2419).
         if (existsSync(gsdDbPath) && !isDbAvailable()) {
-            ctx.ui.notify("SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
-                "Check for corrupt gsd.db or missing native SQLite bindings.", "error");
+            const dbStatus = getDbStatus();
+            const phaseHint = dbStatus.lastPhase === "open"
+                ? "The database file could not be opened"
+                : dbStatus.lastPhase === "initSchema"
+                    ? "The database schema could not be initialized"
+                    : dbStatus.lastPhase === "vacuum-recovery"
+                        ? "Corruption recovery (VACUUM) failed"
+                        : dbStatus.attempted
+                            ? "The database could not be opened (phase unknown)"
+                            : "The database provider could not be loaded";
+            const errorDetail = dbStatus.lastError ? ` (${dbStatus.lastError.message})` : "";
+            const providerHint = dbStatus.provider
+                ? ` Provider: ${dbStatus.provider}.`
+                : " No SQLite provider available — check Node >= 22 or install better-sqlite3.";
+            ctx.ui.notify(`SQLite database exists but failed to open: ${gsdDbPath}. ${phaseHint}${errorDetail}.${providerHint}`, "error");
             return releaseLockAndReturn();
         }
         // Initialize metrics
@@ -633,13 +645,10 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
         }
         // Snapshot installed skills
-        if (resolveSkillDiscoveryMode() !== "off") {
+        if (resolveSkillDiscoveryMode(base) !== "off") {
             snapshotSkills();
         }
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
-        ctx.ui.setFooter(hideFooter);
-        // Hide gsd-health during AUTO — gsd-progress is the single source of truth
-        // for last-commit / cost / health signal while auto is running.
         ctx.ui.setWidget("gsd-health", undefined);
         const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
         const pendingCount = (state.registry ?? []).filter((m) => m.status !== "complete" && m.status !== "parked").length;
@@ -661,7 +670,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // FlatRateContext used by selectAndApplyModel so user-declared
         // flat-rate providers and externalCli auto-detection are respected.
         const { isFlatRateProvider, buildFlatRateContext } = await import("./auto-model-selection.js");
-        const bannerPrefs = loadEffectiveGSDPreferences()?.preferences;
+        const bannerPrefs = loadEffectiveGSDPreferences(base)?.preferences;
         const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
         const effectivelyEnabled = routingConfig.enabled
             && (routingConfig.allow_flat_rate_providers

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

@@ -55,7 +55,7 @@ import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
-import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
+import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
@@ -145,8 +145,8 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
     });
 }
 /** Returns true if the project is configured for `isolation:worktree` mode. */
-export function shouldUseWorktreeIsolation() {
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+export function shouldUseWorktreeIsolation(basePath) {
+    const prefs = loadEffectiveGSDPreferences(basePath)?.preferences?.git;
     if (prefs?.isolation === "worktree")
         return true;
     // Default is false — worktree isolation requires explicit opt-in
@@ -215,7 +215,7 @@ export function getAutoDashboardData() {
     const rtkSavings = sessionId && s.basePath
         ? getRtkSessionSavings(s.basePath, sessionId)
         : null;
-    const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
+    const rtkEnabled = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences.experimental?.rtk === true;
     // Pending capture count — lazy check, non-fatal
     let pendingCaptureCount = 0;
     try {
@@ -393,7 +393,7 @@ function clearUnitTimeout() {
 }
 /** Build snapshot metric opts. */
 function buildSnapshotOpts(_unitType, _unitId) {
-    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const prefs = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const uokFlags = resolveUokFlags(prefs);
     return {
         ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
@@ -427,7 +427,7 @@ function handleLostSessionLock(ctx, lockStatus) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     deregisterSigtermHandler();
-    clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
+    clearCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences);
     const base = lockBase();
     const lockFilePath = base ? join(gsdRoot(base), "auto.lock") : "unknown";
     const recoverySuggestion = "\nTo recover, run: gsd doctor --fix";
@@ -443,7 +443,6 @@ function handleLostSessionLock(ctx, lockStatus) {
     ctx?.ui.notify(message, "error");
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
     if (ctx)
         initHealthWidget(ctx);
 }
@@ -480,7 +479,6 @@ function cleanupAfterLoopExit(ctx) {
     if (!s.paused) {
         ctx.ui.setStatus("gsd-auto", undefined);
         ctx.ui.setWidget("gsd-progress", undefined);
-        ctx.ui.setFooter(undefined);
         initHealthWidget(ctx);
     }
     // Restore CWD out of worktree back to original project root
@@ -498,7 +496,7 @@ function cleanupAfterLoopExit(ctx) {
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
         return;
-    const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
+    const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
     try {
         // ── Step 1: Timers and locks ──
@@ -743,7 +741,6 @@ export async function stopAuto(ctx, pi, reason) {
         // UI cleanup
         ctx?.ui.setStatus("gsd-auto", undefined);
         ctx?.ui.setWidget("gsd-progress", undefined);
-        ctx?.ui.setFooter(undefined);
         if (ctx)
             initHealthWidget(ctx);
         restoreProjectRootEnv();
@@ -832,7 +829,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
     if (ctx)
         initHealthWidget(ctx);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
@@ -1164,7 +1160,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         });
         // ── Auto-worktree / branch-mode: re-enter on resume ──
         if (s.currentMilestoneId &&
-            getIsolationMode() !== "none" &&
+            getIsolationMode(s.originalBasePath || s.basePath) !== "none" &&
             s.originalBasePath &&
             !isInAutoWorktree(s.basePath) &&
             !detectWorktreeName(s.basePath) &&
@@ -1175,7 +1171,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
-        ctx.ui.setFooter(hideFooter);
+        ctx.ui.setWidget("gsd-health", undefined);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
         // Re-sync managed resources on resume so long-lived auto sessions pick up
@@ -1197,7 +1193,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         await openProjectDbIfPresent(s.basePath);
         try {
             await rebuildState(s.basePath);
-            syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
+            syncCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, await deriveState(s.basePath));
         }
         catch (e) {
             debugLog("resume-rebuild-state-failed", {
@@ -1227,7 +1223,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
-        logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
+        logCmuxEvent(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
         captureProjectRootEnv(s.originalBasePath || s.basePath);
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
@@ -1253,13 +1249,13 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         return;
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     try {
-        syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
+        syncCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, await deriveState(s.basePath));
     }
     catch (err) {
         // Best-effort only — sidebar sync must never block auto-mode startup
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
-    logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
+    logCmuxEvent(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
     startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({

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

@@ -1,5 +1,5 @@
 import { logWarning } from "../workflow-logger.js";
-import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
+import { checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -53,6 +53,19 @@ export async function handleAgentEnd(pi, event, ctx) {
         clearDiscussionFlowState();
         return;
     }
+    // #4573 — When the LLM emits "Milestone X ready." but the required files
+    // are missing, `checkAutoStartAfterDiscuss` returns false silently. Surface
+    // that and nudge the LLM to complete the writes before the user hits the
+    // downstream "All milestones complete" warning loop.
+    if (maybeHandleReadyPhraseWithoutFiles(event))
+        return;
+    // #4573 — Empty-turn recovery: if the LLM announced intent in prose but
+    // emitted no tool calls, nudge it to execute. Fires only when auto-mode is
+    // active or a discussion autostart is pending (non-auto interactive discuss
+    // is user-driven). Runs before `isAutoActive` early return so pending
+    // discussions (where isAutoActive may be false) still get recovered.
+    if (maybeHandleEmptyIntentTurn(event, isAutoActive()))
+        return;
     if (!isAutoActive())
         return;
     if (isSessionSwitchInFlight())
@@ -286,6 +299,9 @@ export async function handleAgentEnd(pi, event, ctx) {
     // ── Success path ─────────────────────────────────────────────────────────
     try {
         resetRetryState(retryState);
+        // #4573 — Reset the empty-turn counter on any successful agent turn so
+        // transient stalls don't accumulate across independent units.
+        resetEmptyTurnCounter();
         resolveAgentEnd(event);
     }
     catch (err) {