gsd-pi 2.36.0-dev.f887f4e → 2.37.0-dev.8acfc31

package/dist/resources/extensions/gsd/auto.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) {
@@ -455,6 +460,8 @@ function buildLoopDeps() {
         pauseAuto,
         clearUnitTimeout,
         updateProgressWidget,
+        syncCmuxSidebar,
+        logCmuxEvent,
         // State and cache
         invalidateAllCaches,
         deriveState,
@@ -605,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", {
@@ -634,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;
     }
@@ -647,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());
 }

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-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",

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

@@ -37,6 +37,7 @@ import { runEnvironmentChecks } from "./doctor-environment.js";
 import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
+import { handleCmux } from "./commands-cmux.js";
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot() {
     const cwd = process.cwd();
@@ -89,7 +90,7 @@ function notifyRemoteAutoActive(ctx, basePath) {
 }
 export function registerGSDCommand(pi) {
     pi.registerCommand("gsd", {
-        description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|update",
+        description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|update",
         getArgumentCompletions: (prefix) => {
             const subcommands = [
                 { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -98,6 +99,7 @@ export function registerGSDCommand(pi) {
                 { cmd: "stop", desc: "Stop auto mode gracefully" },
                 { cmd: "pause", desc: "Pause auto-mode (preserves state, /gsd auto to resume)" },
                 { cmd: "status", desc: "Progress dashboard" },
+                { cmd: "widget", desc: "Cycle widget: full → small → min → off" },
                 { cmd: "visualize", desc: "Open 10-tab workflow visualizer (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)" },
                 { cmd: "queue", desc: "Queue and reorder future milestones" },
                 { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
@@ -131,6 +133,7 @@ export function registerGSDCommand(pi) {
                 { cmd: "knowledge", desc: "Add persistent project knowledge (rule, pattern, or lesson)" },
                 { cmd: "new-milestone", desc: "Create a milestone from a specification document (headless)" },
                 { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge)" },
+                { cmd: "cmux", desc: "Manage cmux integration (status, sidebar, notifications, splits)" },
                 { cmd: "park", desc: "Park a milestone — skip without deleting" },
                 { cmd: "unpark", desc: "Reactivate a parked milestone" },
                 { cmd: "update", desc: "Update GSD to the latest version" },
@@ -182,6 +185,36 @@ export function registerGSDCommand(pi) {
                     .filter((s) => s.cmd.startsWith(subPrefix))
                     .map((s) => ({ value: `parallel ${s.cmd}`, label: s.cmd, description: s.desc }));
             }
+            if (parts[0] === "cmux") {
+                if (parts.length <= 2) {
+                    const subPrefix = parts[1] ?? "";
+                    const subs = [
+                        { cmd: "status", desc: "Show cmux detection, prefs, and capabilities" },
+                        { cmd: "on", desc: "Enable cmux integration" },
+                        { cmd: "off", desc: "Disable cmux integration" },
+                        { cmd: "notifications", desc: "Toggle cmux desktop notifications" },
+                        { cmd: "sidebar", desc: "Toggle cmux sidebar metadata" },
+                        { cmd: "splits", desc: "Toggle cmux visual subagent splits" },
+                        { cmd: "browser", desc: "Toggle future browser integration flag" },
+                    ];
+                    return subs
+                        .filter((s) => s.cmd.startsWith(subPrefix))
+                        .map((s) => ({ value: `cmux ${s.cmd}`, label: s.cmd, description: s.desc }));
+                }
+                if (parts.length <= 3 && ["notifications", "sidebar", "splits", "browser"].includes(parts[1])) {
+                    const togglePrefix = parts[2] ?? "";
+                    return [
+                        { cmd: "on", desc: "Enable this cmux area" },
+                        { cmd: "off", desc: "Disable this cmux area" },
+                    ]
+                        .filter((item) => item.cmd.startsWith(togglePrefix))
+                        .map((item) => ({
+                        value: `cmux ${parts[1]} ${item.cmd}`,
+                        label: item.cmd,
+                        description: item.desc,
+                    }));
+                }
+            }
             if (parts[0] === "setup" && parts.length <= 2) {
                 const subPrefix = parts[1] ?? "";
                 const subs = [
@@ -430,6 +463,18 @@ export async function handleGSDCommand(args, ctx, pi) {
         await handleStatus(ctx);
         return;
     }
+    if (trimmed === "widget" || trimmed.startsWith("widget ")) {
+        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("./auto-dashboard.js");
+        const arg = trimmed.replace(/^widget\s*/, "").trim();
+        if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
+            setWidgetMode(arg);
+        }
+        else {
+            cycleWidgetMode();
+        }
+        ctx.ui.notify(`Widget: ${getWidgetMode()}`, "info");
+        return;
+    }
     if (trimmed === "visualize") {
         await handleVisualize(ctx);
         return;
@@ -446,6 +491,10 @@ export async function handleGSDCommand(args, ctx, pi) {
         await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
         return;
     }
+    if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
+        await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
+        return;
+    }
     if (trimmed === "init") {
         const { detectProjectState } = await import("./detection.js");
         const { showProjectInit, handleReinit } = await import("./init-wizard.js");
@@ -900,6 +949,7 @@ function showHelp(ctx) {
         "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
         "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
         "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
+        "  /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 hooks          Show post-unit hook configuration",

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -173,6 +173,13 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `on_milestone`: boolean — notify when a milestone finishes. Default: `true`.
   - `on_attention`: boolean — notify when manual attention is needed. Default: `true`.
 
+- `cmux`: configures cmux terminal integration when GSD is running inside a cmux workspace. Keys:
+  - `enabled`: boolean — master toggle for cmux integration. Default: `false`.
+  - `notifications`: boolean — route desktop notifications through cmux. Default: `true` when enabled.
+  - `sidebar`: boolean — publish status, progress, and log metadata to the cmux sidebar. Default: `true` when enabled.
+  - `splits`: boolean — run supported subagent work in visible cmux splits. Default: `false`.
+  - `browser`: boolean — reserve the future browser integration flag. Default: `false`.
+
 - `dynamic_routing`: configures the dynamic model router that adjusts model selection based on task complexity. Keys:
   - `enabled`: boolean — enable dynamic routing. Default: `false`.
   - `tier_models`: object — model overrides per complexity tier. Keys: `light`, `standard`, `heavy`. Values are model ID strings.
@@ -477,6 +484,24 @@ Disables per-unit completion notifications (noisy in long runs) while keeping er
 
 ---
 
+## cmux Example
+
+```yaml
+---
+version: 1
+cmux:
+  enabled: true
+  notifications: true
+  sidebar: true
+  splits: true
+  browser: false
+---
+```
+
+Enables cmux-aware notifications, sidebar metadata, and visible subagent splits when GSD is running inside a cmux terminal.
+
+---
+
 ## Post-Unit Hooks Example
 
 ```yaml

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

@@ -46,6 +46,7 @@ import { pauseAutoForProviderError, classifyProviderError } from "./provider-err
 import { toPosixPath } from "../shared/mod.js";
 import { isParallelActive, shutdownParallel } from "./parallel-orchestrator.js";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "./constants.js";
+import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../cmux/index.js";
 // ── Agent Instructions (DEPRECATED) ──────────────────────────────────────
 // agent-instructions.md is deprecated. Use AGENTS.md or CLAUDE.md instead.
 // Pi core natively supports AGENTS.md (with CLAUDE.md fallback) per directory.
@@ -532,6 +533,10 @@ export default function (pi) {
         const stopContextTimer = debugTime("context-inject");
         const systemContent = loadPrompt("system");
         const loadedPreferences = loadEffectiveGSDPreferences();
+        if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
+            markCmuxPromptShown();
+            ctx.ui.notify("cmux detected. Run /gsd cmux on to enable sidebar metadata, notifications, and visual subagent splits for this project.", "info");
+        }
         let preferenceBlock = "";
         if (loadedPreferences) {
             const cwd = process.cwd();

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

@@ -2,13 +2,22 @@
 // Cross-platform desktop notifications for auto-mode events.
 import { execFileSync } from "node:child_process";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { CmuxClient, emitOsc777Notification, resolveCmuxConfig } from "../cmux/index.js";
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
  */
 export function sendDesktopNotification(title, message, level = "info", kind = "complete") {
-    if (!shouldSendDesktopNotification(kind))
+    const loaded = loadEffectiveGSDPreferences()?.preferences;
+    if (!shouldSendDesktopNotification(kind, loaded?.notifications))
         return;
+    const cmux = resolveCmuxConfig(loaded);
+    if (cmux.notifications) {
+        const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
+        if (delivered)
+            return;
+        emitOsc777Notification(title, message);
+    }
     try {
         const command = buildDesktopNotificationCommand(process.platform, title, message, level);
         if (!command)

package/dist/resources/extensions/gsd/preferences-types.js

@@ -47,6 +47,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "budget_enforcement",
     "context_pause_threshold",
     "notifications",
+    "cmux",
     "remote_questions",
     "git",
     "post_unit_hooks",
@@ -63,6 +64,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "search_provider",
     "compression_strategy",
     "context_selection",
+    "widget_mode",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -225,6 +225,35 @@ export function validatePreferences(preferences) {
             errors.push("notifications must be an object");
         }
     }
+    // ─── Cmux ───────────────────────────────────────────────────────────────
+    if (preferences.cmux !== undefined) {
+        if (preferences.cmux && typeof preferences.cmux === "object") {
+            const cmux = preferences.cmux;
+            const validatedCmux = {};
+            if (cmux.enabled !== undefined)
+                validatedCmux.enabled = !!cmux.enabled;
+            if (cmux.notifications !== undefined)
+                validatedCmux.notifications = !!cmux.notifications;
+            if (cmux.sidebar !== undefined)
+                validatedCmux.sidebar = !!cmux.sidebar;
+            if (cmux.splits !== undefined)
+                validatedCmux.splits = !!cmux.splits;
+            if (cmux.browser !== undefined)
+                validatedCmux.browser = !!cmux.browser;
+            const knownCmuxKeys = new Set(["enabled", "notifications", "sidebar", "splits", "browser"]);
+            for (const key of Object.keys(cmux)) {
+                if (!knownCmuxKeys.has(key)) {
+                    warnings.push(`unknown cmux key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validatedCmux).length > 0) {
+                validated.cmux = validatedCmux;
+            }
+        }
+        else {
+            errors.push("cmux must be an object");
+        }
+    }
     // ─── Remote Questions ───────────────────────────────────────────────
     if (preferences.remote_questions !== undefined) {
         if (preferences.remote_questions && typeof preferences.remote_questions === "object") {

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

@@ -174,6 +174,9 @@ function mergePreferences(base, override) {
         notifications: (base.notifications || override.notifications)
             ? { ...(base.notifications ?? {}), ...(override.notifications ?? {}) }
             : undefined,
+        cmux: (base.cmux || override.cmux)
+            ? { ...(base.cmux ?? {}), ...(override.cmux ?? {}) }
+            : undefined,
         remote_questions: override.remote_questions
             ? { ...(base.remote_questions ?? {}), ...override.remote_questions }
             : base.remote_questions,

package/dist/resources/extensions/gsd/prompts/research-milestone.md

@@ -25,9 +25,10 @@ Then research the codebase and relevant technologies. Narrate key findings and s
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code. For small/familiar codebases, use `rg`, `find`, and targeted reads. For large or unfamiliar codebases, use `scout` to build a broad map efficiently before diving in.
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
-5. Use the **Research** output template from the inlined context above — include only sections that have real content
-6. If `.gsd/REQUIREMENTS.md` exists, research against it. Identify which Active requirements are table stakes, likely omissions, overbuilt risks, or domain-standard behaviors the user may or may not want.
-7. Write `{{outputPath}}`
+5. **Web search budget:** You have a limited budget of web searches (max ~15 per session). Use them strategically — prefer `resolve_library` / `get_library_docs` for library documentation. Do NOT repeat the same or similar queries. If a search didn't find what you need, rephrase once or move on. Target 3-5 total web searches for a typical research unit.
+6. Use the **Research** output template from the inlined context above — include only sections that have real content
+7. If `.gsd/REQUIREMENTS.md` exists, research against it. Identify which Active requirements are table stakes, likely omissions, overbuilt risks, or domain-standard behaviors the user may or may not want.
+8. Write `{{outputPath}}`
 
 ## Strategic Questions to Answer
 

package/dist/resources/extensions/gsd/prompts/research-slice.md

@@ -46,8 +46,9 @@ Research what this slice needs. Narrate key findings and surprises as you go —
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code for this slice's scope. For targeted exploration, use `rg`, `find`, and reads. For broad or unfamiliar subsystems, use `scout` to map the relevant area first.
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
-5. Use the **Research** output template from the inlined context above — include only sections that have real content. The template is already inlined above; do NOT attempt to read any template file from disk (there is no `templates/SLICE-RESEARCH.md` — the correct template is already present in this prompt).
-6. Write `{{outputPath}}`
+5. **Web search budget:** You have a limited budget of web searches (max ~15 per session). Use them strategically — prefer `resolve_library` / `get_library_docs` for library documentation. Do NOT repeat the same or similar queries. If a search didn't find what you need, rephrase once or move on. Target 3-5 total web searches for a typical research unit.
+6. Use the **Research** output template from the inlined context above — include only sections that have real content. The template is already inlined above; do NOT attempt to read any template file from disk (there is no `templates/SLICE-RESEARCH.md` — the correct template is already present in this prompt).
+7. Write `{{outputPath}}`
 
 The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir — just write the file.
 

package/dist/resources/extensions/gsd/templates/preferences.md

@@ -57,6 +57,12 @@ notifications:
   on_budget:
   on_milestone:
   on_attention:
+cmux:
+  enabled:
+  notifications:
+  sidebar:
+  splits:
+  browser:
 remote_questions:
   channel:
   channel_id:

package/dist/resources/extensions/search-the-web/native-search.js

@@ -11,6 +11,15 @@ export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "google_search"];
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+/**
+ * Maximum number of native web searches allowed per session (agent unit).
+ * The Anthropic API's `max_uses` is per-request — it resets on each API call.
+ * When `pause_turn` triggers a resubmit, the model gets a fresh budget.
+ * This session-level cap prevents unbounded search accumulation (#1309).
+ *
+ * 15 = 3 full turns of 5 searches each — generous for research, but bounded.
+ */
+export const MAX_NATIVE_SEARCHES_PER_SESSION = 15;
 /** When true, skip native web search injection and keep Brave/custom tools active on Anthropic. */
 export function preferBraveSearch() {
     // preferences.md takes priority over env var
@@ -57,6 +66,10 @@ export function stripThinkingFromHistory(messages) {
 export function registerNativeSearchHooks(pi) {
     let isAnthropicProvider = false;
     let modelSelectFired = false;
+    // Session-level native search counter (#1309).
+    // Tracks cumulative web_search_tool_result blocks across all turns in a session.
+    // Reset on session_start. Used to compute remaining budget for max_uses.
+    let sessionSearchCount = 0;
     // Track provider changes via model selection — also handles diagnostics
     // since model_select fires AFTER session_start and knows the provider.
     pi.on("model_select", async (event, ctx) => {
@@ -135,18 +148,46 @@ export function registerNativeSearchHooks(pi) {
         // the model and causes it to pick custom tools which can fail with network errors.
         tools = tools.filter((t) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t.name));
         payload.tools = tools;
+        // ── Session-level search budget (#1309) ──────────────────────────────
+        // Count web_search_tool_result blocks in the conversation history to
+        // determine how many native searches have already been used this session.
+        // The Anthropic API's max_uses resets per request, so without this guard,
+        // pause_turn → resubmit cycles allow unlimited total searches.
+        if (Array.isArray(messages)) {
+            let historySearchCount = 0;
+            for (const msg of messages) {
+                const content = msg.content;
+                if (!Array.isArray(content))
+                    continue;
+                for (const block of content) {
+                    if (block?.type === "web_search_tool_result") {
+                        historySearchCount++;
+                    }
+                }
+            }
+            // Sync counter from history (handles session restore / context replay)
+            sessionSearchCount = historySearchCount;
+        }
+        const remaining = Math.max(0, MAX_NATIVE_SEARCHES_PER_SESSION - sessionSearchCount);
+        if (remaining <= 0) {
+            // Budget exhausted — don't inject the search tool at all.
+            // The model will proceed without web search capability.
+            return payload;
+        }
         tools.push({
             type: "web_search_20250305",
             name: "web_search",
-            // Cap server-side searches per response to prevent the model from
-            // looping on web_search without synthesizing results (#817).
-            // 5 searches is generous — most queries need 1-2.
-            max_uses: 5,
+            // Cap per-request searches to the lesser of 5 (per-turn cap) or the
+            // remaining session budget (#1309). This prevents the model from
+            // consuming unlimited searches via pause_turn → resubmit cycles.
+            max_uses: Math.min(5, remaining),
         });
         return payload;
     });
     // Basic startup diagnostics — provider-specific info comes from model_select
     pi.on("session_start", async (_event, ctx) => {
+        // Reset session-level search budget (#1309)
+        sessionSearchCount = 0;
         const hasBrave = !!process.env.BRAVE_API_KEY;
         const hasJina = !!process.env.JINA_API_KEY;
         const hasAnswers = !!process.env.BRAVE_ANSWERS_KEY;

package/dist/resources/extensions/shared/terminal.js

@@ -5,9 +5,14 @@
  * Terminals that lack this support silently swallow the key combos.
  */
 const UNSUPPORTED_TERMS = ["apple_terminal", "warpterm"];
+export function isCmuxTerminal(env = process.env) {
+    return Boolean(env.CMUX_WORKSPACE_ID && env.CMUX_SURFACE_ID);
+}
 export function supportsCtrlAltShortcuts() {
     const term = (process.env.TERM_PROGRAM || "").toLowerCase();
     const jetbrains = (process.env.TERMINAL_EMULATOR || "").toLowerCase().includes("jetbrains");
+    if (isCmuxTerminal())
+        return true;
     return !UNSUPPORTED_TERMS.some((t) => term.includes(t)) && !jetbrains;
 }
 /**