gsd-pi 2.36.0-dev.f887f4e → 2.37.0-dev.3186675

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/session-lock.js

@@ -320,7 +320,7 @@ export function updateSessionLock(basePath, unitType, unitId, completedUnits, se
  *
  * This is called periodically during the dispatch loop.
  */
-export function validateSessionLock(basePath) {
+export function getSessionLockStatus(basePath) {
     // Lock was compromised by proper-lockfile (mtime drift from sleep, stall, etc.)
     if (_lockCompromised) {
         // Recovery gate (#1512): Before declaring the lock lost, check if the lock
@@ -335,27 +335,47 @@ export function validateSessionLock(basePath) {
                 const result = acquireSessionLock(basePath);
                 if (result.acquired) {
                     process.stderr.write(`[gsd] Lock recovered after onCompromised — lock file PID matched, re-acquired.\n`);
-                    return true;
+                    return { valid: true, recovered: true };
                 }
             }
             catch {
                 // Re-acquisition failed — fall through to return false
             }
         }
-        return false;
+        return {
+            valid: false,
+            failureReason: "compromised",
+            existingPid: existing?.pid,
+            expectedPid: process.pid,
+        };
     }
     // If we have an OS-level lock, we're still the owner
     if (_releaseFunction && _lockedPath === basePath) {
-        return true;
+        return { valid: true };
     }
     // Fallback: check the lock file PID
     const lp = lockPath(basePath);
     const existing = readExistingLockData(lp);
     if (!existing) {
         // Lock file was deleted — we lost ownership
-        return false;
+        return {
+            valid: false,
+            failureReason: "missing-metadata",
+            expectedPid: process.pid,
+        };
+    }
+    if (existing.pid !== process.pid) {
+        return {
+            valid: false,
+            failureReason: "pid-mismatch",
+            existingPid: existing.pid,
+            expectedPid: process.pid,
+        };
     }
-    return existing.pid === process.pid;
+    return { valid: true };
+}
+export function validateSessionLock(basePath) {
+    return getSessionLockStatus(basePath).valid;
 }
 /**
  * Release the session lock. Called on clean stop/pause.

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/format-utils.js

@@ -1,10 +1,11 @@
 /**
- * Shared formatting and layout utilities for TUI dashboard components.
+ * Shared pure formatting utilities — no @gsd/pi-tui dependency.
  *
- * Consolidates helpers that were previously duplicated across
- * auto-dashboard.ts, dashboard-overlay.ts, and visualizer-views.ts.
+ * ANSI-aware layout helpers (padRight, joinColumns, centerLine, fitColumns)
+ * live in layout-utils.ts to avoid pulling @gsd/pi-tui into modules that
+ * run outside jiti's alias resolution (e.g. HTML report generation via
+ * dynamic import in auto-loop).
  */
-import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 // ─── Duration Formatting ──────────────────────────────────────────────────────
 /** Format a millisecond duration as a compact human-readable string. */
 export function formatDuration(ms) {
@@ -30,43 +31,6 @@ export function formatTokenCount(count) {
         return `${(count / 1000).toFixed(1)}k`;
     return `${(count / 1_000_000).toFixed(2)}M`;
 }
-// ─── Layout Helpers ───────────────────────────────────────────────────────────
-/** Pad a string with trailing spaces to fill `width` (ANSI-aware). */
-export function padRight(content, width) {
-    const vis = visibleWidth(content);
-    return content + " ".repeat(Math.max(0, width - vis));
-}
-/** Build a line with left-aligned and right-aligned content. */
-export function joinColumns(left, right, width) {
-    const leftW = visibleWidth(left);
-    const rightW = visibleWidth(right);
-    if (leftW + rightW + 2 > width) {
-        return truncateToWidth(`${left}  ${right}`, width);
-    }
-    return left + " ".repeat(width - leftW - rightW) + right;
-}
-/** Center content within `width` (ANSI-aware). */
-export function centerLine(content, width) {
-    const vis = visibleWidth(content);
-    if (vis >= width)
-        return truncateToWidth(content, width);
-    const leftPad = Math.floor((width - vis) / 2);
-    return " ".repeat(leftPad) + content;
-}
-/** Join as many parts as fit within `width`, separated by `separator`. */
-export function fitColumns(parts, width, separator = "  ") {
-    const filtered = parts.filter(Boolean);
-    if (filtered.length === 0)
-        return "";
-    let result = filtered[0];
-    for (let i = 1; i < filtered.length; i++) {
-        const candidate = `${result}${separator}${filtered[i]}`;
-        if (visibleWidth(candidate) > width)
-            break;
-        result = candidate;
-    }
-    return truncateToWidth(result, width);
-}
 // ─── Text Truncation ─────────────────────────────────────────────────────────
 /** Truncate a string to `maxLength` characters, replacing the last character with an ellipsis if needed. */
 export function truncateWithEllipsis(text, maxLength) {

package/dist/resources/extensions/shared/layout-utils.js

@@ -0,0 +1,46 @@
+/**
+ * ANSI-aware TUI layout utilities that depend on @gsd/pi-tui.
+ *
+ * Separated from format-utils.ts so that modules needing only pure
+ * formatting (e.g. HTML report generation) can import format-utils
+ * without pulling in the @gsd/pi-tui dependency — which fails when
+ * loaded outside jiti's alias resolution context.
+ */
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+// ─── Layout Helpers ───────────────────────────────────────────────────────────
+/** Pad a string with trailing spaces to fill `width` (ANSI-aware). */
+export function padRight(content, width) {
+    const vis = visibleWidth(content);
+    return content + " ".repeat(Math.max(0, width - vis));
+}
+/** Build a line with left-aligned and right-aligned content. */
+export function joinColumns(left, right, width) {
+    const leftW = visibleWidth(left);
+    const rightW = visibleWidth(right);
+    if (leftW + rightW + 2 > width) {
+        return truncateToWidth(`${left}  ${right}`, width);
+    }
+    return left + " ".repeat(width - leftW - rightW) + right;
+}
+/** Center content within `width` (ANSI-aware). */
+export function centerLine(content, width) {
+    const vis = visibleWidth(content);
+    if (vis >= width)
+        return truncateToWidth(content, width);
+    const leftPad = Math.floor((width - vis) / 2);
+    return " ".repeat(leftPad) + content;
+}
+/** Join as many parts as fit within `width`, separated by `separator`. */
+export function fitColumns(parts, width, separator = "  ") {
+    const filtered = parts.filter(Boolean);
+    if (filtered.length === 0)
+        return "";
+    let result = filtered[0];
+    for (let i = 1; i < filtered.length; i++) {
+        const candidate = `${result}${separator}${filtered[i]}`;
+        if (visibleWidth(candidate) > width)
+            break;
+        result = candidate;
+    }
+    return truncateToWidth(result, width);
+}

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

@@ -1,6 +1,7 @@
 // Barrel file — re-exports consumed by external modules
 export { makeUI, GLYPH, INDENT, STATUS_GLYPH, STATUS_COLOR, } from "./ui.js";
-export { stripAnsi, formatTokenCount, formatDuration, padRight, joinColumns, centerLine, fitColumns, sparkline, normalizeStringArray, fileLink, } from "./format-utils.js";
+export { stripAnsi, formatTokenCount, formatDuration, sparkline, normalizeStringArray, fileLink, } from "./format-utils.js";
+export { padRight, joinColumns, centerLine, fitColumns, } from "./layout-utils.js";
 export { shortcutDesc } from "./terminal.js";
 export { toPosixPath } from "./path-display.js";
 export { showInterviewRound } from "./interview-ui.js";

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;
 }
 /**

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

@@ -24,6 +24,8 @@ import { formatTokenCount } from "../shared/mod.js";
 import { discoverAgents } from "./agents.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
+import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { CmuxClient, shellEscape } from "../cmux/index.js";
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
@@ -191,6 +193,66 @@ function writePromptToTempFile(agentName, prompt) {
     fs.writeFileSync(filePath, prompt, { encoding: "utf-8", mode: 0o600 });
     return { dir: tmpDir, filePath };
 }
+function buildSubagentProcessArgs(agent, task, tmpPromptPath) {
+    const args = ["--mode", "json", "-p", "--no-session"];
+    if (agent.model)
+        args.push("--model", agent.model);
+    if (agent.tools && agent.tools.length > 0)
+        args.push("--tools", agent.tools.join(","));
+    if (tmpPromptPath)
+        args.push("--append-system-prompt", tmpPromptPath);
+    args.push(`Task: ${task}`);
+    return args;
+}
+function processSubagentEventLine(line, currentResult, emitUpdate) {
+    if (!line.trim())
+        return;
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    if (event.type === "message_end" && event.message) {
+        const msg = event.message;
+        currentResult.messages.push(msg);
+        if (msg.role === "assistant") {
+            currentResult.usage.turns++;
+            const usage = msg.usage;
+            if (usage) {
+                currentResult.usage.input += usage.input || 0;
+                currentResult.usage.output += usage.output || 0;
+                currentResult.usage.cacheRead += usage.cacheRead || 0;
+                currentResult.usage.cacheWrite += usage.cacheWrite || 0;
+                currentResult.usage.cost += usage.cost?.total || 0;
+                currentResult.usage.contextTokens = usage.totalTokens || 0;
+            }
+            if (!currentResult.model && msg.model)
+                currentResult.model = msg.model;
+            if (msg.stopReason)
+                currentResult.stopReason = msg.stopReason;
+            if (msg.errorMessage)
+                currentResult.errorMessage = msg.errorMessage;
+        }
+        emitUpdate();
+    }
+    if (event.type === "tool_result_end" && event.message) {
+        currentResult.messages.push(event.message);
+        emitUpdate();
+    }
+}
+async function waitForFile(filePath, signal, timeoutMs = 30 * 60 * 1000) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        if (signal?.aborted)
+            return false;
+        if (fs.existsSync(filePath))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+    return false;
+}
 async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails) {
     const agent = agents.find((a) => a.name === agentName);
     if (!agent) {
@@ -206,11 +268,6 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             step,
         };
     }
-    const args = ["--mode", "json", "-p", "--no-session"];
-    if (agent.model)
-        args.push("--model", agent.model);
-    if (agent.tools && agent.tools.length > 0)
-        args.push("--tools", agent.tools.join(","));
     let tmpPromptDir = null;
     let tmpPromptPath = null;
     const currentResult = {
@@ -237,9 +294,8 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             const tmp = writePromptToTempFile(agent.name, agent.systemPrompt);
             tmpPromptDir = tmp.dir;
             tmpPromptPath = tmp.filePath;
-            args.push("--append-system-prompt", tmpPromptPath);
         }
-        args.push(`Task: ${task}`);
+        const args = buildSubagentProcessArgs(agent, task, tmpPromptPath);
         let wasAborted = false;
         const exitCode = await new Promise((resolve) => {
             const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map(s => s.trim()).filter(Boolean);
@@ -247,50 +303,12 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             const proc = spawn(process.execPath, [process.env.GSD_BIN_PATH, ...extensionArgs, ...args], { cwd: cwd ?? defaultCwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
             liveSubagentProcesses.add(proc);
             let buffer = "";
-            const processLine = (line) => {
-                if (!line.trim())
-                    return;
-                let event;
-                try {
-                    event = JSON.parse(line);
-                }
-                catch {
-                    return;
-                }
-                if (event.type === "message_end" && event.message) {
-                    const msg = event.message;
-                    currentResult.messages.push(msg);
-                    if (msg.role === "assistant") {
-                        currentResult.usage.turns++;
-                        const usage = msg.usage;
-                        if (usage) {
-                            currentResult.usage.input += usage.input || 0;
-                            currentResult.usage.output += usage.output || 0;
-                            currentResult.usage.cacheRead += usage.cacheRead || 0;
-                            currentResult.usage.cacheWrite += usage.cacheWrite || 0;
-                            currentResult.usage.cost += usage.cost?.total || 0;
-                            currentResult.usage.contextTokens = usage.totalTokens || 0;
-                        }
-                        if (!currentResult.model && msg.model)
-                            currentResult.model = msg.model;
-                        if (msg.stopReason)
-                            currentResult.stopReason = msg.stopReason;
-                        if (msg.errorMessage)
-                            currentResult.errorMessage = msg.errorMessage;
-                    }
-                    emitUpdate();
-                }
-                if (event.type === "tool_result_end" && event.message) {
-                    currentResult.messages.push(event.message);
-                    emitUpdate();
-                }
-            };
             proc.stdout.on("data", (data) => {
                 buffer += data.toString();
                 const lines = buffer.split("\n");
                 buffer = lines.pop() || "";
                 for (const line of lines)
-                    processLine(line);
+                    processSubagentEventLine(line, currentResult, emitUpdate);
             });
             proc.stderr.on("data", (data) => {
                 currentResult.stderr += data.toString();
@@ -298,7 +316,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             proc.on("close", (code) => {
                 liveSubagentProcesses.delete(proc);
                 if (buffer.trim())
-                    processLine(buffer);
+                    processSubagentEventLine(buffer, currentResult, emitUpdate);
                 resolve(code ?? 0);
             });
             proc.on("error", () => {
@@ -342,6 +360,103 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             }
     }
 }
+async function runSingleAgentInCmuxSplit(cmuxClient, direction, defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails) {
+    const agent = agents.find((a) => a.name === agentName);
+    if (!agent) {
+        return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+    }
+    let tmpPromptDir = null;
+    let tmpPromptPath = null;
+    let tmpOutputDir = null;
+    const currentResult = {
+        agent: agentName,
+        agentSource: agent.source,
+        task,
+        exitCode: 0,
+        messages: [],
+        stderr: "",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+        model: agent.model,
+        step,
+    };
+    const emitUpdate = () => {
+        if (onUpdate) {
+            onUpdate({
+                content: [{ type: "text", text: getFinalOutput(currentResult.messages) || "(running...)" }],
+                details: makeDetails([currentResult]),
+            });
+        }
+    };
+    try {
+        if (agent.systemPrompt.trim()) {
+            const tmp = writePromptToTempFile(agent.name, agent.systemPrompt);
+            tmpPromptDir = tmp.dir;
+            tmpPromptPath = tmp.filePath;
+        }
+        tmpOutputDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-cmux-"));
+        const stdoutPath = path.join(tmpOutputDir, "stdout.jsonl");
+        const stderrPath = path.join(tmpOutputDir, "stderr.log");
+        const exitPath = path.join(tmpOutputDir, "exit.code");
+        const cmuxSurfaceId = await cmuxClient.createSplit(direction);
+        if (!cmuxSurfaceId) {
+            return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+        }
+        const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
+        const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
+        const processArgs = [process.env.GSD_BIN_PATH, ...extensionArgs, ...buildSubagentProcessArgs(agent, task, tmpPromptPath)];
+        const innerScript = [
+            `cd ${shellEscape(cwd ?? defaultCwd)}`,
+            "set -o pipefail",
+            `${shellEscape(process.execPath)} ${processArgs.map(shellEscape).join(" ")} 2> >(tee ${shellEscape(stderrPath)} >&2) | tee ${shellEscape(stdoutPath)}`,
+            "status=${PIPESTATUS[0]}",
+            `printf '%s' "$status" > ${shellEscape(exitPath)}`,
+        ].join("; ");
+        const sent = await cmuxClient.sendSurface(cmuxSurfaceId, `bash -lc ${shellEscape(innerScript)}`);
+        if (!sent) {
+            return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+        }
+        const finished = await waitForFile(exitPath, signal);
+        if (!finished) {
+            currentResult.exitCode = 1;
+            currentResult.stderr = "cmux split execution timed out or was aborted";
+            return currentResult;
+        }
+        if (fs.existsSync(stdoutPath)) {
+            const stdout = fs.readFileSync(stdoutPath, "utf-8");
+            for (const line of stdout.split("\n")) {
+                processSubagentEventLine(line, currentResult, emitUpdate);
+            }
+        }
+        if (fs.existsSync(stderrPath)) {
+            currentResult.stderr = fs.readFileSync(stderrPath, "utf-8");
+        }
+        currentResult.exitCode = Number.parseInt(fs.readFileSync(exitPath, "utf-8").trim() || "1", 10) || 0;
+        return currentResult;
+    }
+    finally {
+        if (tmpPromptPath)
+            try {
+                fs.unlinkSync(tmpPromptPath);
+            }
+            catch {
+                /* ignore */
+            }
+        if (tmpPromptDir)
+            try {
+                fs.rmdirSync(tmpPromptDir);
+            }
+            catch {
+                /* ignore */
+            }
+        if (tmpOutputDir)
+            try {
+                fs.rmSync(tmpOutputDir, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore */
+            }
+    }
+}
 const TaskItem = Type.Object({
     agent: Type.String({ description: "Name of the agent to invoke" }),
     task: Type.String({ description: "Task to delegate to the agent" }),
@@ -412,6 +527,8 @@ export default function (pi) {
             const discovery = discoverAgents(ctx.cwd, agentScope);
             const agents = discovery.agents;
             const confirmProjectAgents = params.confirmProjectAgents ?? false;
+            const cmuxClient = CmuxClient.fromPreferences(loadEffectiveGSDPreferences()?.preferences);
+            const cmuxSplitsEnabled = cmuxClient.getConfig().splits;
             // Resolve isolation mode
             const isolationMode = readIsolationMode();
             const useIsolation = Boolean(params.isolated) && isolationMode !== "none";
@@ -541,23 +658,24 @@ export default function (pi) {
                 const batchSize = params.tasks.length;
                 const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
                     const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
-                    let result = await runSingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, 
-                    // Per-task update callback
-                    (partial) => {
-                        if (partial.details?.results[0]) {
-                            allResults[index] = partial.details.results[0];
-                            emitParallelUpdate();
-                        }
-                    }, makeDetails("parallel"));
-                    // Auto-retry failed tasks (likely API rate limit or transient error)
-                    const isFailed = result.exitCode !== 0 || (result.messages.length === 0 && !signal?.aborted);
-                    if (isFailed && MAX_RETRIES > 0 && !signal?.aborted) {
-                        result = await runSingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, (partial) => {
+                    const runTask = () => cmuxSplitsEnabled
+                        ? runSingleAgentInCmuxSplit(cmuxClient, index % 2 === 0 ? "right" : "down", ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, (partial) => {
+                            if (partial.details?.results[0]) {
+                                allResults[index] = partial.details.results[0];
+                                emitParallelUpdate();
+                            }
+                        }, makeDetails("parallel"))
+                        : runSingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, (partial) => {
                             if (partial.details?.results[0]) {
                                 allResults[index] = partial.details.results[0];
                                 emitParallelUpdate();
                             }
                         }, makeDetails("parallel"));
+                    let result = await runTask();
+                    // Auto-retry failed tasks (likely API rate limit or transient error)
+                    const isFailed = result.exitCode !== 0 || (result.messages.length === 0 && !signal?.aborted);
+                    if (isFailed && MAX_RETRIES > 0 && !signal?.aborted) {
+                        result = await runTask();
                     }
                     updateWorker(workerId, result.exitCode === 0 ? "completed" : "failed");
                     allResults[index] = result;
@@ -591,7 +709,9 @@ export default function (pi) {
                         const taskId = crypto.randomUUID();
                         isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
                     }
-                    const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, onUpdate, makeDetails("single"));
+                    const result = cmuxSplitsEnabled
+                        ? await runSingleAgentInCmuxSplit(cmuxClient, "right", ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, onUpdate, makeDetails("single"))
+                        : await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, onUpdate, makeDetails("single"));
                     // Capture and merge delta if isolated
                     if (isolation) {
                         const patches = await isolation.captureDelta();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.36.0-dev.f887f4e",
+  "version": "2.37.0-dev.3186675",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {