gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1d17f366c

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

@@ -1,5 +1,6 @@
 import { logWarning } from "../workflow-logger.js";
-import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
+import { checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
+import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -49,10 +50,32 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
     });
 }
 export async function handleAgentEnd(pi, event, ctx) {
+    // #4648 — Invalidate the directory-listing cache before any artifact-existence
+    // checks. The LLM may have written milestone files (CONTEXT.md, ROADMAP.md,
+    // PROJECT.md, REQUIREMENTS.md) via tool calls during the turn that just
+    // ended. `paths.ts` caches readdir() results without a TTL, so without this
+    // flush, `resolveMilestoneFile` returns the pre-write listing and the guards
+    // below (`checkAutoStartAfterDiscuss` and `maybeHandleReadyPhraseWithoutFiles`)
+    // falsely report files as missing — producing a spurious "ready signal
+    // rejected" loop even though the files are on disk.
+    clearPathCache();
     if (checkAutoStartAfterDiscuss()) {
         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 +309,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) {

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -3,6 +3,8 @@ import { resetTransientRetryState } from "./agent-end-recovery.js";
 import { resetSessionTimeoutState } from "../auto/phases.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
+    resetTransientRetryState,
+    resetSessionTimeoutState,
     startAuto,
 };
 export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps) {
@@ -18,8 +20,8 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
     // Reset retry counters before restarting — without this, counters
     // accumulate across pause/resume cycles and permanently lock out
     // auto-resume after their respective MAX thresholds.
-    resetTransientRetryState();
-    resetSessionTimeoutState();
+    deps.resetTransientRetryState();
+    deps.resetSessionTimeoutState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }

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

@@ -12,6 +12,13 @@ import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
 import { logWarning } from "../workflow-logger.js";
+// Static import so cmux event listeners are registered synchronously during
+// extension bootstrap. Prior implementation used `void import().then()` which
+// queued listener registration as a microtask — any CMUX_CHANNELS emit fired
+// in the same event loop turn as registration (e.g. from a provider-error
+// session hook calling startAuto) would be silently dropped because Node's
+// EventEmitter does not buffer events for late subscribers.
+import { initCmuxEventListeners } from "../../cmux/index.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
@@ -89,6 +96,10 @@ export function registerGsdExtension(pi) {
         ["memory-tools", () => registerMemoryTools(pi)],
         ["exec-tools", () => registerExecTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
+        // cmux is a library (no pi), so gsd sets up the event listeners on its
+        // behalf using the shared event channel contract. Registration is
+        // synchronous — see the import comment above for the rationale.
+        ["cmux-events", () => initCmuxEventListeners(pi.events)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {
                 void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {

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

@@ -13,12 +13,12 @@ import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { deriveState } from "../state.js";
 import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
-import { hideFooter } from "../auto-dashboard.js";
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
 import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
-import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult } from "../safety/evidence-collector.js";
+import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
+import { parseUnitId } from "../unit-id.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
 import { logWarning as safetyLogWarning } from "../workflow-logger.js";
 import { installNotifyInterceptor } from "./notify-interceptor.js";
@@ -37,7 +37,9 @@ export function registerHooks(pi, ecosystemHandlers) {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
         initNotificationWidget(ctx);
-        initHealthWidget(ctx);
+        if (!isAutoActive()) {
+            initHealthWidget(ctx);
+        }
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -79,7 +81,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         loadToolApiKeys();
         if (isAutoActive()) {
-            ctx.ui.setFooter(hideFooter);
+            ctx.ui.setWidget("gsd-health", undefined);
         }
     });
     pi.on("session_switch", async (_event, ctx) => {
@@ -101,7 +103,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         loadToolApiKeys();
         if (isAutoActive()) {
-            ctx.ui.setFooter(hideFooter);
+            ctx.ui.setWidget("gsd-health", undefined);
         }
     });
     pi.on("before_agent_start", async (event, ctx) => {
@@ -441,7 +443,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     pi.on("tool_execution_start", async (event) => {
         if (!isAutoActive())
             return;
-        markToolStart(event.toolCallId);
+        markToolStart(event.toolCallId, event.toolName);
     });
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);
@@ -456,6 +458,15 @@ export function registerHooks(pi, ecosystemHandlers) {
         // Safety harness: record tool execution results for evidence cross-referencing
         if (isAutoActive()) {
             safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);
+            // Persist evidence to disk after each tool result so it survives a session
+            // restart mid-unit (Bug #4385 — non-persisted evidence false positives).
+            const dash = getAutoDashboardData();
+            if (dash.basePath && dash.currentUnit?.type === "execute-task") {
+                const { milestone: pMid, slice: pSid, task: pTid } = parseUnitId(dash.currentUnit.id);
+                if (pMid && pSid && pTid) {
+                    saveEvidenceToDisk(dash.basePath, pMid, pSid, pTid);
+                }
+            }
         }
     });
     pi.on("model_select", async (_event, ctx) => {

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -16,7 +16,6 @@ import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-comma
 import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";
 import { toPosixPath } from "../../shared/mod.js";
-import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../../cmux/index.js";
 import { autoEnableCmuxPreferences } from "../commands-cmux.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 /**
@@ -87,13 +86,19 @@ export async function buildBeforeAgentStartResult(event, ctx) {
         shortcutShell: formatShortcut("Ctrl+Alt+B"),
     });
     let loadedPreferences = loadEffectiveGSDPreferences();
-    if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
-        markCmuxPromptShown();
-        if (autoEnableCmuxPreferences()) {
-            loadedPreferences = loadEffectiveGSDPreferences();
-            ctx.ui.notify("cmux detected — auto-enabled. Run /gsd cmux off to disable.", "info");
+    try {
+        const { markCmuxPromptShown, shouldPromptToEnableCmux } = await import("../../cmux/index.js");
+        if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
+            markCmuxPromptShown();
+            if (autoEnableCmuxPreferences()) {
+                loadedPreferences = loadEffectiveGSDPreferences();
+                ctx.ui.notify("cmux detected — auto-enabled. Run /gsd cmux off to disable.", "info");
+            }
         }
     }
+    catch (e) {
+        logWarning("bootstrap", `cmux prompt setup skipped: ${e.message}`);
+    }
     let preferenceBlock = "";
     if (loadedPreferences) {
         const cwd = process.cwd();

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

@@ -24,8 +24,29 @@ const QUEUE_SAFE_TOOLS = new Set([
 /**
  * Bash commands that are read-only / investigative — safe during queue mode.
  * Matches the leading command in a bash invocation.
+ *
+ * Extension policy: add commands here when they are read-only / diagnostic.
+ * Never add commands that mutate project state (write files, run builds that
+ * emit artifacts, install packages, etc.).
+ *
+ * Current read-only additions (Bug #4385):
+ *   npm run <diagnostic> — read-only diagnostic scripts: test, lint, typecheck, etc.
+ *                         NOT: build, install, compile, generate, deploy (artifact-producing)
+ *   npm ls/list/info    — inspect installed packages (read-only)
+ *   npm outdated/audit  — security/update checks (read-only)
+ *   npx <pkg>           — run a package binary without installing globally
+ *   tsx                 — TypeScript runner used for dry-run / inspection scripts
+ *   node --print        — evaluate and print an expression, no side effects
+ *   python / python3    — script inspection, version checks
+ *   pip / pip3 show     — show installed package info (read-only)
+ *   jq                  — read-only JSON query
+ *   yq                  — read-only YAML query
+ *   curl -s / curl --silent — fetch for inspection (no -o / no output redirect)
+ *   openssl version     — version / certificate inspection
+ *   env / printenv      — print environment variables
+ *   true / false        — shell no-ops / test exit codes
  */
-const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s)/;
+const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s|npm\s+run\s+(test|test:\w+|lint|lint:\w+|typecheck|type-check|type-check:\w+|check|verify|audit|outdated|format:check|ci|validate)\b|npm\s+(ls|list|info|view|show|outdated|audit|explain|doctor|ping|--version|-v)\b|npx\s|tsx\s|node\s+(--print|--version|-v\b)|python[23]?\s+(-c\s+'[^']*'|--version|-V\b|-m\s+(pip\s+show|pip\s+list|site))|pip[23]?\s+(show|list|freeze|check|index\s+versions)\b|jq\s|yq\s|curl\s+(-s\b|--silent\b)(?!\s+[^|>]*\s-[oO]\b)(?!\s+[^|>]*\s--output\b)[^|>]*$|openssl\s+(version|x509|s_client)|env\b|printenv\b|true\b|false\b)/;
 const verifiedDepthMilestones = new Set();
 let activeQueuePhase = false;
 /**
@@ -99,10 +120,21 @@ function normalizeWriteGateSnapshot(value) {
         pendingGateId: typeof record.pendingGateId === "string" ? record.pendingGateId : null,
     };
 }
+const EMPTY_SNAPSHOT = {
+    verifiedDepthMilestones: [],
+    activeQueuePhase: false,
+    pendingGateId: null,
+};
 export function loadWriteGateSnapshot(basePath = process.cwd()) {
     const path = writeGateSnapshotPath(basePath);
-    if (!existsSync(path))
+    if (!existsSync(path)) {
+        // When persist mode is active and the file has been deleted, treat it as a
+        // full state reset so deleting the file clears the HARD BLOCK gate.
+        // In non-persist mode the file is never written, so fall back to in-memory.
+        if (shouldPersistWriteGateSnapshot())
+            return EMPTY_SNAPSHOT;
         return currentWriteGateSnapshot();
+    }
     try {
         return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
     }

package/dist/resources/extensions/gsd/clean-root-preflight.js

@@ -0,0 +1,93 @@
+/**
+ * clean-root-preflight.ts — Preflight gate for dirty working trees before milestone merges.
+ *
+ * #2909: Adds a fast-path git status check before milestone completion merges.
+ * When the working tree is dirty the user is warned and changes are auto-stashed
+ * so the merge can proceed cleanly.  After the merge completes, postflightPopStash
+ * restores the stashed changes.
+ *
+ * Design constraints (from Trek-e approval):
+ *  - Warn the user before stashing (no silent surprises)
+ *  - git stash push / git stash pop only — no custom stash management layer
+ *  - Stash/pop errors are logged but MUST NOT block the merge
+ *  - Fast-path status check — clean trees pay no extra cost
+ */
+import { execFileSync } from "node:child_process";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
+import { logWarning } from "./workflow-logger.js";
+import { nativeHasChanges } from "./native-git-bridge.js";
+/**
+ * Check the working tree for dirty files before a milestone merge.
+ *
+ * Clean tree path: O(1) — returns immediately with stashPushed=false.
+ *
+ * Dirty tree path:
+ *  1. Emits a warning notification via the provided `notify` callback.
+ *  2. Runs `git stash push --include-untracked -m "gsd-preflight-stash"`.
+ *  3. Returns stashPushed=true so the caller knows to call postflightPopStash.
+ *
+ * Any stash error is logged but does NOT throw — the merge proceeds regardless.
+ */
+export function preflightCleanRoot(basePath, milestoneId, notify) {
+    // Fast-path: clean tree — nothing to do
+    let isDirty = false;
+    try {
+        isDirty = nativeHasChanges(basePath);
+    }
+    catch (err) {
+        // If the status check itself fails, treat as clean and let the merge decide
+        logWarning("preflight", `clean-root status check failed: ${err instanceof Error ? err.message : String(err)}`);
+        return { stashPushed: false, summary: "" };
+    }
+    if (!isDirty) {
+        return { stashPushed: false, summary: "" };
+    }
+    // Warn the user before stashing
+    const warnMsg = `Working tree has uncommitted changes before milestone ${milestoneId} merge. Auto-stashing to allow clean merge (stash will be restored after merge).`;
+    notify(warnMsg, "warning");
+    // Push the stash
+    try {
+        execFileSync("git", ["stash", "push", "--include-untracked", "-m", "gsd-preflight-stash"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return {
+            stashPushed: true,
+            summary: `Stashed uncommitted changes before merge (milestone ${milestoneId}).`,
+        };
+    }
+    catch (err) {
+        // Stash failure is non-fatal — log and let the merge attempt proceed
+        const msg = `git stash push failed before merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}`;
+        logWarning("preflight", msg);
+        notify(`Auto-stash failed before milestone ${milestoneId} merge — proceeding anyway. ${msg}`, "warning");
+        return { stashPushed: false, summary: `stash-push-failed: ${msg}` };
+    }
+}
+/**
+ * Restore stashed changes after a milestone merge completes.
+ *
+ * Only called when preflightCleanRoot returned stashPushed=true.
+ * Any pop error (e.g. conflict) is logged and notified but does NOT throw —
+ * the merge already completed successfully.
+ */
+export function postflightPopStash(basePath, milestoneId, notify) {
+    try {
+        execFileSync("git", ["stash", "pop"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        notify(`Restored stashed changes after milestone ${milestoneId} merge.`, "info");
+    }
+    catch (err) {
+        // Pop conflicts mean the merged code collides with the stashed changes.
+        // Log a warning — the user needs to resolve manually, but the merge succeeded.
+        const msg = `git stash pop failed after merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. Run "git stash pop" manually to restore your changes.`;
+        logWarning("preflight", msg);
+        notify(msg, "warning");
+    }
+}

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

@@ -17,6 +17,22 @@ import { validateDefinition } from "../../definition-loader.js";
 import { formatPluginInfo, listPluginsFormatted, resolvePlugin, } from "../../workflow-plugins.js";
 import { dispatchOneshot } from "../../workflow-dispatch.js";
 import { fetchWorkflowSource, globalInstallDir, inferPluginName, installPlugin, previewContent, projectInstallDir, resolveSourceUrl, uninstallPlugin, validateFetchedContent, } from "../../workflow-install.js";
+/**
+ * Refuses interactive commands that mutate durable .gsd/ planning state while
+ * auto-mode holds the worktree. Returns true if the command was blocked and
+ * the caller should return immediately; false if it is safe to proceed.
+ *
+ * Auto-mode's squash merge performs a pre-merge dirty-tree check; concurrent
+ * writes by interactive commands between that check and the merge itself
+ * cause __dirty_working_tree__ failures (#4704).
+ */
+function requireNotAutoActive(commandName, ctx) {
+    if (!isAutoActive())
+        return false;
+    ctx.ui.notify(`${commandName} cannot run while auto-mode is active.\n` +
+        `Stop auto-mode first with /gsd stop, then run ${commandName}.`, "error");
+    return true;
+}
 // ─── Custom Workflow Subcommands ─────────────────────────────────────────
 const RESERVED_SUBCOMMANDS = new Set([
     "new", "run", "list", "validate", "pause", "resume",
@@ -394,12 +410,16 @@ async function handleCustomWorkflow(sub, ctx, pi) {
 export async function handleWorkflowCommand(trimmed, ctx, pi) {
     // ── /gsd do — natural language routing (must be early to route to other commands) ──
     if (trimmed === "do" || trimmed.startsWith("do ")) {
+        if (requireNotAutoActive("/gsd do", ctx))
+            return true;
         const { handleDo } = await import("../../commands-do.js");
         await handleDo(trimmed.replace(/^do\s*/, "").trim(), ctx, pi);
         return true;
     }
     // ── Backlog management ──
     if (trimmed === "backlog" || trimmed.startsWith("backlog ")) {
+        if (requireNotAutoActive("/gsd backlog", ctx))
+            return true;
         const { handleBacklog } = await import("../../commands-backlog.js");
         await handleBacklog(trimmed.replace(/^backlog\s*/, "").trim(), ctx, pi);
         return true;
@@ -410,23 +430,26 @@ export async function handleWorkflowCommand(trimmed, ctx, pi) {
         return handleCustomWorkflow(sub, ctx, pi);
     }
     if (trimmed === "queue") {
+        if (requireNotAutoActive("/gsd queue", ctx))
+            return true;
         await showQueue(ctx, pi, projectRoot());
         return true;
     }
     if (trimmed === "discuss") {
+        if (requireNotAutoActive("/gsd discuss", ctx))
+            return true;
         await showDiscuss(ctx, pi, projectRoot());
         return true;
     }
     if (trimmed === "quick" || trimmed.startsWith("quick ")) {
-        if (isAutoActive()) {
-            ctx.ui.notify("/gsd quick cannot run while auto-mode is active.\n" +
-                "Stop auto-mode first with /gsd stop, then run /gsd quick.", "error");
+        if (requireNotAutoActive("/gsd quick", ctx))
             return true;
-        }
         await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
         return true;
     }
     if (trimmed === "new-milestone") {
+        if (requireNotAutoActive("/gsd new-milestone", ctx))
+            return true;
         const basePath = projectRoot();
         const headlessContextPath = join(gsdRoot(basePath), "runtime", "headless-context.md");
         if (existsSync(headlessContextPath)) {
@@ -452,6 +475,8 @@ export async function handleWorkflowCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "park" || trimmed.startsWith("park ")) {
+        if (requireNotAutoActive("/gsd park", ctx))
+            return true;
         const basePath = projectRoot();
         const arg = trimmed.replace(/^park\s*/, "").trim();
         let targetId = arg;
@@ -474,6 +499,8 @@ export async function handleWorkflowCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "unpark" || trimmed.startsWith("unpark ")) {
+        if (requireNotAutoActive("/gsd unpark", ctx))
+            return true;
         const basePath = projectRoot();
         const arg = trimmed.replace(/^unpark\s*/, "").trim();
         let targetId = arg;

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

@@ -1,5 +1,4 @@
 import { existsSync, readFileSync, writeFileSync } 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";
@@ -63,7 +62,8 @@ async function writeProjectCmuxPreferences(ctx, updater) {
 function resolveProjectPreferencesWritePath() {
     return loadProjectGSDPreferences()?.path ?? getProjectGSDPreferencesPath();
 }
-function formatCmuxStatus() {
+async function formatCmuxStatus() {
+    const { CmuxClient, detectCmuxEnvironment, resolveCmuxConfig } = await import("../cmux/index.js");
     const loaded = loadEffectiveGSDPreferences();
     const detected = detectCmuxEnvironment();
     const resolved = resolveCmuxConfig(loaded?.preferences);
@@ -87,7 +87,8 @@ function formatCmuxStatus() {
         `Capabilities: access=${accessMode}, methods=${methods}`,
     ].join("\n");
 }
-function ensureCmuxAvailableForEnable(ctx) {
+async function ensureCmuxAvailableForEnable(ctx) {
+    const { detectCmuxEnvironment } = await import("../cmux/index.js");
     const detected = detectCmuxEnvironment();
     if (detected.available)
         return true;
@@ -97,11 +98,11 @@ function ensureCmuxAvailableForEnable(ctx) {
 export async function handleCmux(args, ctx) {
     const trimmed = args.trim();
     if (!trimmed || trimmed === "status") {
-        ctx.ui.notify(formatCmuxStatus(), "info");
+        ctx.ui.notify(await formatCmuxStatus(), "info");
         return;
     }
     if (trimmed === "on") {
-        if (!ensureCmuxAvailableForEnable(ctx))
+        if (!await ensureCmuxAvailableForEnable(ctx))
             return;
         await writeProjectCmuxPreferences(ctx, (prefs) => {
             prefs.cmux = {
@@ -122,6 +123,7 @@ export async function handleCmux(args, ctx) {
         await writeProjectCmuxPreferences(ctx, (prefs) => {
             prefs.cmux = { ...(prefs.cmux ?? {}), enabled: false };
         });
+        const { clearCmuxSidebar } = await import("../cmux/index.js");
         clearCmuxSidebar(effective);
         ctx.ui.notify("cmux integration disabled in project preferences.", "info");
         return;
@@ -130,7 +132,7 @@ export async function handleCmux(args, ctx) {
     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))
+        if (enabled && !await ensureCmuxAvailableForEnable(ctx))
             return;
         await writeProjectCmuxPreferences(ctx, (prefs) => {
             const next = { ...(prefs.cmux ?? {}) };
@@ -140,6 +142,7 @@ export async function handleCmux(args, ctx) {
             prefs.cmux = next;
         });
         if (!enabled && feature === "sidebar") {
+            const { clearCmuxSidebar } = await import("../cmux/index.js");
             clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
         }
         const note = feature === "browser" && enabled