lsd-pi 1.3.2 → 1.3.7

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

@@ -11,24 +11,23 @@
  *
  * Uses JSON mode to capture structured output from subagents.
  */
-import { spawn, execFileSync } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { StringEnum } from "@gsd/pi-ai";
-import { getAgentDir, getMarkdownTheme, } from "@gsd/pi-coding-agent";
+import { getMarkdownTheme, } from "@gsd/pi-coding-agent";
 import { Container, Key, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { formatTokenCount, shortcutDesc } from "../shared/mod.js";
 import { discoverAgents } from "./agents.js";
-import { buildSubagentProcessArgs, getBundledExtensionPathsFromEnv } from "./launch-helpers.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
-import { handleSubagentPermissionRequest, isSubagentPermissionRequest } from "./approval-proxy.js";
 import { resolveConfiguredSubagentModel } from "./configured-model.js";
-import { normalizeSubagentModel, resolveSubagentModel, } from "./model-resolution.js";
+import { resolveSubagentModel } from "./model-resolution.js";
 import { loadEffectivePreferences } from "../shared/preferences.js";
+import { readBudgetSubagentModelFromSettings, runLegacySingleAgent, stopLegacySubagents, } from "./legacy-runner.js";
+import { MAX_IN_PROCESS_SUBAGENT_DEPTH, startInProcessSingleAgent, } from "./in-process-runner.js";
 import { CmuxClient } from "../cmux/index.js";
 import { BackgroundJobManager } from "./background-job-manager.js";
 import { runSubagentInBackground } from "./background-runner.js";
@@ -38,11 +37,13 @@ const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
 const DEFAULT_AWAIT_SUBAGENT_TIMEOUT_SECONDS = 120;
-const liveSubagentProcesses = new Set();
+const USE_IN_PROCESS_SUBAGENT = process.env.LSD_SUBAGENT_IN_PROCESS !== "0";
 const agentSessionLinksById = new Map();
 const agentSessionIdsByParent = new Map();
 const parentSessionByChild = new Map();
 const liveRuntimeBySessionFile = new Map();
+const inProcessSubagentDepthBySessionId = new Map();
+const inProcessSubagentAncestryBySessionId = new Map();
 let agentSessionLinkCounter = 0;
 function listSessionFiles(sessionDir) {
     if (!fs.existsSync(sessionDir))
@@ -57,25 +58,6 @@ function listSessionFiles(sessionDir) {
         return [];
     }
 }
-function detectNewSubagentSessionFile(sessionDir, before, startedAt) {
-    const after = listSessionFiles(sessionDir);
-    const created = after.filter((file) => !before.has(file));
-    const candidates = created.length > 0 ? created : after;
-    const ranked = candidates
-        .map((file) => {
-        let mtime = 0;
-        try {
-            mtime = fs.statSync(file).mtimeMs;
-        }
-        catch {
-            mtime = 0;
-        }
-        return { file, mtime };
-    })
-        .filter((entry) => entry.mtime >= startedAt - 5000)
-        .sort((a, b) => b.mtime - a.mtime);
-    return ranked[0]?.file;
-}
 function registerAgentSessionLink(link) {
     const now = Date.now();
     const id = `agent-${++agentSessionLinkCounter}`;
@@ -203,35 +185,7 @@ const AwaitSubagentParams = Type.Object({
     })),
 });
 export async function stopLiveSubagents() {
-    const active = Array.from(liveSubagentProcesses);
-    if (active.length === 0)
-        return;
-    for (const proc of active) {
-        try {
-            proc.kill("SIGTERM");
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    await Promise.all(active.map((proc) => new Promise((resolve) => {
-        const done = () => resolve();
-        const timer = setTimeout(done, 500);
-        proc.once("exit", () => {
-            clearTimeout(timer);
-            resolve();
-        });
-    })));
-    for (const proc of active) {
-        if (proc.exitCode === null) {
-            try {
-                proc.kill("SIGKILL");
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
+    await stopLegacySubagents();
 }
 function formatBackgroundSubagentResults(jobs) {
     if (jobs.length === 0)
@@ -449,442 +403,6 @@ async function mapWithConcurrencyLimit(items, concurrency, fn) {
     await Promise.all(workers);
     return results;
 }
-function writePromptToTempFile(agentName, prompt) {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-    const safeName = agentName.replace(/[^\w.-]+/g, "_");
-    const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
-    fs.writeFileSync(filePath, prompt, { encoding: "utf-8", mode: 0o600 });
-    return { dir: tmpDir, filePath };
-}
-function readBudgetSubagentModelFromSettings() {
-    try {
-        const settingsPath = path.join(getAgentDir(), "settings.json");
-        if (!fs.existsSync(settingsPath))
-            return undefined;
-        const raw = fs.readFileSync(settingsPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        return typeof parsed.budgetSubagentModel === "string"
-            ? normalizeSubagentModel(parsed.budgetSubagentModel)
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function resolveSubagentCliPath(defaultCwd) {
-    const candidates = [process.env.GSD_BIN_PATH, process.env.LSD_BIN_PATH, process.argv[1]]
-        .map((value) => value?.trim())
-        .filter((value) => Boolean(value && value !== "undefined"));
-    for (const candidate of candidates) {
-        if (path.isAbsolute(candidate) && fs.existsSync(candidate))
-            return candidate;
-    }
-    const cwdCandidates = [path.join(defaultCwd, "dist", "loader.js"), path.join(defaultCwd, "scripts", "dev-cli.js")];
-    for (const candidate of cwdCandidates) {
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    for (const binName of ["lsd", "gsd"]) {
-        try {
-            const resolved = execFileSync("which", [binName], { encoding: "utf-8" }).trim();
-            if (resolved)
-                return resolved;
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return null;
-}
-function processSubagentEventLine(line, currentResult, emitUpdate, proc, onSessionInfo, onEventType, onParsedEvent) {
-    if (!line.trim())
-        return false;
-    let event;
-    try {
-        event = JSON.parse(line);
-    }
-    catch {
-        return false;
-    }
-    const eventType = typeof event.type === "string" ? event.type : "unknown";
-    onEventType?.(eventType);
-    onParsedEvent?.(event);
-    if (event.type === "subagent_session_info") {
-        let changed = false;
-        if (typeof event.sessionFile === "string" && event.sessionFile) {
-            if (currentResult.sessionFile !== event.sessionFile)
-                changed = true;
-            currentResult.sessionFile = event.sessionFile;
-        }
-        if (typeof event.parentSessionFile === "string" && event.parentSessionFile) {
-            if (currentResult.parentSessionFile !== event.parentSessionFile)
-                changed = true;
-            currentResult.parentSessionFile = event.parentSessionFile;
-        }
-        if (changed) {
-            onSessionInfo?.({
-                sessionFile: currentResult.sessionFile,
-                parentSessionFile: currentResult.parentSessionFile,
-            });
-        }
-        return false;
-    }
-    if (proc && isSubagentPermissionRequest(event)) {
-        void handleSubagentPermissionRequest(event, proc);
-        return false;
-    }
-    if ((event.type === "message_end" || event.type === "turn_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 (msg.model && (!currentResult.model || msg.model.includes("/")))
-                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();
-    }
-    return event.type === "agent_end";
-}
-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, modelOverride, parentModel, signal, onUpdate, makeDetails, parentSessionFile, attachableSession, onSessionInfo, onSubagentEvent, foregroundHooks) {
-    const agent = agents.find((a) => a.name === agentName);
-    if (!agent) {
-        const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
-        return {
-            agent: agentName,
-            agentSource: "unknown",
-            task,
-            exitCode: 1,
-            messages: [],
-            stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
-            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-            step,
-        };
-    }
-    let tmpPromptDir = null;
-    let tmpPromptPath = null;
-    const preferences = loadEffectivePreferences()?.preferences;
-    const settingsBudgetModel = readBudgetSubagentModelFromSettings();
-    const resolvedModel = resolveConfiguredSubagentModel(agent, preferences, settingsBudgetModel);
-    const inferredModel = resolveSubagentModel({ name: agent.name, model: resolvedModel }, { overrideModel: modelOverride, parentModel });
-    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: inferredModel,
-        step,
-        parentSessionFile,
-    };
-    const emitUpdate = () => {
-        if (onUpdate) {
-            onUpdate({
-                content: [{ type: "text", text: getFinalOutput(currentResult.messages) || "(running...)" }],
-                details: makeDetails([currentResult]),
-            });
-        }
-    };
-    let wasAborted = false;
-    let deferTempPromptCleanup = false;
-    let tempPromptCleanupDone = false;
-    const cleanupTempPromptFiles = () => {
-        if (tempPromptCleanupDone)
-            return;
-        tempPromptCleanupDone = true;
-        if (tmpPromptPath)
-            try {
-                fs.unlinkSync(tmpPromptPath);
-            }
-            catch {
-                /* ignore */
-            }
-        if (tmpPromptDir)
-            try {
-                fs.rmdirSync(tmpPromptDir);
-            }
-            catch {
-                /* ignore */
-            }
-    };
-    try {
-        if (agent.systemPrompt.trim()) {
-            const tmp = writePromptToTempFile(agent.name, agent.systemPrompt);
-            tmpPromptDir = tmp.dir;
-            tmpPromptPath = tmp.filePath;
-        }
-        const effectiveCwd = cwd ?? defaultCwd;
-        const subagentSessionDir = parentSessionFile ? path.dirname(parentSessionFile) : undefined;
-        const sessionFilesBefore = attachableSession && subagentSessionDir
-            ? new Set(listSessionFiles(subagentSessionDir))
-            : undefined;
-        const launchStartedAt = Date.now();
-        const args = buildSubagentProcessArgs(agent, task, tmpPromptPath, inferredModel, {
-            noSession: !attachableSession,
-            parentSessionFile: parentSessionFile,
-            mode: attachableSession ? "rpc" : "json",
-        });
-        const exitCode = await new Promise((resolve) => {
-            const bundledPaths = getBundledExtensionPathsFromEnv();
-            const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
-            const cliPath = resolveSubagentCliPath(effectiveCwd);
-            if (!cliPath) {
-                currentResult.stderr += "Unable to resolve LSD/GSD CLI path for subagent launch.";
-                resolve(1);
-                return;
-            }
-            const proc = spawn(process.execPath, [cliPath, ...extensionArgs, ...args], { cwd: effectiveCwd, shell: false, stdio: ["pipe", "pipe", "pipe"] });
-            // Keep stdin open so approval/classifier responses can be proxied back
-            // into the child process. Closing it here can leave the subagent stuck
-            // after its first turn when it requests permission for a tool call.
-            liveSubagentProcesses.add(proc);
-            let buffer = "";
-            let completionSeen = false;
-            let resolved = false;
-            let foregroundReleased = false;
-            let isBusy = false;
-            let commandSeq = 0;
-            const pendingCommandResponses = new Map();
-            const procAbortController = new AbortController();
-            let resolveBackgroundResult;
-            let rejectBackgroundResult;
-            const backgroundResultPromise = new Promise((resolveBg, rejectBg) => {
-                resolveBackgroundResult = resolveBg;
-                rejectBackgroundResult = rejectBg;
-            });
-            const sendRpcCommand = async (command) => {
-                const id = `sa_cmd_${++commandSeq}`;
-                if (!proc.stdin)
-                    throw new Error("Subagent RPC stdin is not available.");
-                return new Promise((resolveCmd, rejectCmd) => {
-                    pendingCommandResponses.set(id, { resolve: resolveCmd, reject: rejectCmd });
-                    proc.stdin.write(JSON.stringify({ id, ...command }) + "\n");
-                });
-            };
-            const finishForeground = (code) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                resolve(code);
-            };
-            const adoptToBackground = (jobId) => {
-                if (resolved || foregroundReleased)
-                    return false;
-                foregroundReleased = true;
-                deferTempPromptCleanup = true;
-                currentResult.backgroundJobId = jobId;
-                finishForeground(0);
-                return true;
-            };
-            backgroundResultPromise.finally(() => {
-                if (deferTempPromptCleanup)
-                    cleanupTempPromptFiles();
-            });
-            foregroundHooks?.onStart?.({
-                agentName,
-                task,
-                cwd: cwd ?? defaultCwd,
-                parentSessionFile,
-                abortController: procAbortController,
-                resultPromise: backgroundResultPromise,
-                adoptToBackground,
-                sendPrompt: attachableSession
-                    ? async (text, images) => {
-                        await sendRpcCommand({ type: "prompt", message: text, images });
-                    }
-                    : undefined,
-                sendSteer: attachableSession
-                    ? async (text, images) => {
-                        await sendRpcCommand({ type: "steer", message: text, images });
-                    }
-                    : undefined,
-                sendFollowUp: attachableSession
-                    ? async (text, images) => {
-                        await sendRpcCommand({ type: "follow_up", message: text, images });
-                    }
-                    : undefined,
-                isBusy: attachableSession ? () => isBusy : undefined,
-            });
-            proc.stdout.on("data", (data) => {
-                buffer += data.toString();
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (!trimmed)
-                        continue;
-                    if (attachableSession) {
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            if (parsed?.type === "response" && typeof parsed.id === "string" && pendingCommandResponses.has(parsed.id)) {
-                                const pending = pendingCommandResponses.get(parsed.id);
-                                pendingCommandResponses.delete(parsed.id);
-                                if (parsed.success === false) {
-                                    pending.reject(new Error(typeof parsed.error === "string" ? parsed.error : "Subagent RPC command failed."));
-                                }
-                                else {
-                                    pending.resolve(parsed.data);
-                                }
-                                continue;
-                            }
-                        }
-                        catch {
-                            // Fall through to generic event processing.
-                        }
-                    }
-                    if (processSubagentEventLine(trimmed, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
-                        if (eventType === "agent_start")
-                            isBusy = true;
-                        if (eventType === "agent_end")
-                            isBusy = false;
-                    }, (event) => onSubagentEvent?.(event, currentResult))) {
-                        completionSeen = true;
-                        try {
-                            proc.kill("SIGTERM");
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                    }
-                }
-            });
-            proc.stderr.on("data", (data) => {
-                currentResult.stderr += data.toString();
-            });
-            proc.on("close", (code) => {
-                liveSubagentProcesses.delete(proc);
-                if (buffer.trim()) {
-                    const completedOnFlush = processSubagentEventLine(buffer, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
-                        if (eventType === "agent_start")
-                            isBusy = true;
-                        if (eventType === "agent_end")
-                            isBusy = false;
-                    }, (event) => onSubagentEvent?.(event, currentResult));
-                    completionSeen = completionSeen || completedOnFlush;
-                }
-                isBusy = false;
-                for (const pending of pendingCommandResponses.values()) {
-                    pending.reject(new Error("Subagent process closed before command response."));
-                }
-                pendingCommandResponses.clear();
-                const finalExitCode = completionSeen && (code === null || code === 143 || code === 15) ? 0 : (code ?? 0);
-                currentResult.exitCode = finalExitCode;
-                if (attachableSession && sessionFilesBefore && subagentSessionDir && !currentResult.sessionFile) {
-                    const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
-                    if (detected)
-                        currentResult.sessionFile = detected;
-                }
-                resolveBackgroundResult?.({
-                    summary: getFinalOutput(currentResult.messages),
-                    stderr: currentResult.stderr,
-                    exitCode: finalExitCode,
-                    model: currentResult.model,
-                    sessionFile: currentResult.sessionFile,
-                    parentSessionFile: currentResult.parentSessionFile,
-                });
-                foregroundHooks?.onFinish?.();
-                finishForeground(finalExitCode);
-            });
-            proc.on("error", (error) => {
-                liveSubagentProcesses.delete(proc);
-                isBusy = false;
-                for (const pending of pendingCommandResponses.values()) {
-                    pending.reject(error instanceof Error ? error : new Error(String(error)));
-                }
-                pendingCommandResponses.clear();
-                rejectBackgroundResult?.(error);
-                foregroundHooks?.onFinish?.();
-                finishForeground(1);
-            });
-            if (attachableSession) {
-                void sendRpcCommand({ type: "prompt", message: task }).catch((error) => {
-                    currentResult.stderr += error instanceof Error ? error.message : String(error);
-                    try {
-                        proc.kill("SIGTERM");
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                });
-            }
-            const killProc = () => {
-                // If the process has been adopted to the background (e.g. via Ctrl+B or
-                // /agent attach_live), foregroundReleased is true and the process should
-                // survive the parent session's abort — don't kill it.
-                if (foregroundReleased)
-                    return;
-                wasAborted = true;
-                procAbortController.abort();
-                proc.kill("SIGTERM");
-                setTimeout(() => {
-                    if (!proc.killed)
-                        proc.kill("SIGKILL");
-                }, 5000);
-            };
-            if (signal) {
-                if (signal.aborted)
-                    killProc();
-                else
-                    signal.addEventListener("abort", killProc, { once: true });
-            }
-            if (procAbortController.signal.aborted) {
-                killProc();
-            }
-            else {
-                procAbortController.signal.addEventListener("abort", () => {
-                    proc.kill("SIGTERM");
-                    setTimeout(() => {
-                        if (!proc.killed)
-                            proc.kill("SIGKILL");
-                    }, 5000);
-                }, { once: true });
-            }
-        });
-        currentResult.exitCode = exitCode;
-        if (attachableSession && sessionFilesBefore && subagentSessionDir) {
-            const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
-            if (detected) {
-                currentResult.sessionFile = detected;
-            }
-        }
-        if (wasAborted)
-            throw new Error("Subagent was aborted");
-        return currentResult;
-    }
-    finally {
-        if (!deferTempPromptCleanup)
-            cleanupTempPromptFiles();
-    }
-}
 const TaskItem = Type.Object({
     agent: Type.String({ description: "Name of the agent to invoke" }),
     task: Type.String({ description: "Task to delegate to the agent" }),
@@ -1033,7 +551,6 @@ export default function (pi) {
             "Do not spawn or delegate to another subagent with the same name as yourself.",
             `If the user asks you to continue ${subagentName} work, do that work directly in this session.`,
             taskNote,
-            "IMPORTANT: There is NO human available to answer questions in this session. Do NOT call ask_user_questions. Make all decisions autonomously based on the task and context.",
         ].join("\n");
         return {
             systemPrompt: `${event.systemPrompt}\n\n${antiRecursion}\n\n${metadata.subagentSystemPrompt}`,
@@ -1041,9 +558,19 @@ export default function (pi) {
     });
     pi.on("input", async (event, ctx) => {
         const sessionFile = ctx.sessionManager.getSessionFile();
-        if (!sessionFile)
-            return;
-        const runtime = liveRuntimeBySessionFile.get(sessionFile);
+        const runtimeFromSession = sessionFile ? liveRuntimeBySessionFile.get(sessionFile) : undefined;
+        const runtimeFromForeground = (!runtimeFromSession && activeForegroundSubagent && !activeForegroundSubagent.claimed &&
+            activeForegroundSubagent.sendPrompt && activeForegroundSubagent.sendSteer && activeForegroundSubagent.sendFollowUp && activeForegroundSubagent.isBusy &&
+            sessionFile && activeForegroundSubagent.parentSessionFile === sessionFile)
+            ? {
+                agentName: activeForegroundSubagent.agentName,
+                isBusy: activeForegroundSubagent.isBusy,
+                sendPrompt: activeForegroundSubagent.sendPrompt,
+                sendSteer: activeForegroundSubagent.sendSteer,
+                sendFollowUp: activeForegroundSubagent.sendFollowUp,
+            }
+            : undefined;
+        const runtime = runtimeFromSession ?? runtimeFromForeground;
         if (!runtime)
             return;
         const text = event.text?.trim();
@@ -1087,6 +614,8 @@ export default function (pi) {
         agentSessionIdsByParent.clear();
         parentSessionByChild.clear();
         liveRuntimeBySessionFile.clear();
+        inProcessSubagentDepthBySessionId.clear();
+        inProcessSubagentAncestryBySessionId.clear();
         liveStreamBufferBySession.clear();
     });
     // /subagents command
@@ -1226,31 +755,6 @@ export default function (pi) {
                         ctx.ui.notify("Live runtime is no longer available for this subagent. It may have completed.", "warning");
                         return;
                     }
-                    // Adopt the foreground subagent to background before switching sessions.
-                    // switchSession calls abort() which would fire the tool signal and SIGTERM
-                    // the running subagent process. Adopting to background detaches the process
-                    // from the foreground abort chain so it survives the session switch.
-                    const foreground = activeForegroundSubagent;
-                    if (foreground && !foreground.claimed && bgManager) {
-                        foreground.claimed = true;
-                        try {
-                            const jobId = bgManager.adoptRunning(foreground.agentName, foreground.task, foreground.cwd, foreground.abortController, foreground.resultPromise, {
-                                parentSessionFile: foreground.parentSessionFile ?? ctx.sessionManager.getSessionFile(),
-                            });
-                            const released = foreground.adoptToBackground(jobId);
-                            if (!released) {
-                                foreground.claimed = false;
-                                bgManager.cancel(jobId);
-                            }
-                            else {
-                                activeForegroundSubagent = null;
-                                ctx.ui.setStatus(foregroundSubagentStatusKey, undefined);
-                            }
-                        }
-                        catch {
-                            foreground.claimed = false;
-                        }
-                    }
                     const switched = await ctx.switchSession(target.sessionFile);
                     if (switched.cancelled) {
                         ctx.ui.notify("Session switch was cancelled.", "warning");
@@ -1390,9 +894,19 @@ export default function (pi) {
             running.claimed = true;
             let jobId;
             try {
-                jobId = manager.adoptRunning(running.agentName, running.task, running.cwd, running.abortController, running.resultPromise, {
-                    parentSessionFile: running.parentSessionFile ?? ctx.sessionManager.getSessionFile(),
-                });
+                if (running.handle) {
+                    jobId = manager.adoptHandle(running.agentName, running.task, running.cwd, running.handle, running.resultPromise, {
+                        parentSessionFile: running.parentSessionFile ?? ctx.sessionManager.getSessionFile(),
+                    });
+                }
+                else if (running.abortController) {
+                    jobId = manager.adoptRunning(running.agentName, running.task, running.cwd, running.abortController, running.resultPromise, {
+                        parentSessionFile: running.parentSessionFile ?? ctx.sessionManager.getSessionFile(),
+                    });
+                }
+                else {
+                    throw new Error("Foreground subagent cannot be moved to background (missing runtime handle).");
+                }
             }
             catch (error) {
                 running.claimed = false;
@@ -1456,7 +970,7 @@ export default function (pi) {
             "For broad review or audit requests, use scout only as a prep step; the parent model or a reviewer should make the final judgments.",
             "Skip scout when the user already named the exact file/function to inspect or the task is obviously narrow.",
             "Use parallel mode when tasks are independent and don't need each other's output.",
-            "Default to foreground (background: false) for single-mode subagents. Only set background: true when the user explicitly asks to run it in the background or to keep chatting while it runs.",
+            "Use background: true when the user wants to keep chatting while a long-running agent works in parallel.",
             "If the user wants to wait for a background subagent result, use await_subagent.",
         ],
         parameters: SubagentParams,
@@ -1468,6 +982,14 @@ export default function (pi) {
             const cmuxClient = CmuxClient.fromPreferences(loadEffectivePreferences()?.preferences);
             const cmuxSplitsEnabled = cmuxClient.getConfig().splits;
             const invokingSessionFile = ctx.sessionManager.getSessionFile();
+            const invokingSessionId = ctx.sessionManager.getSessionId();
+            const invokingMetadata = getCurrentSessionSubagentMetadata(invokingSessionFile);
+            const currentSubagentName = invokingMetadata?.subagentName;
+            const trackedAncestry = inProcessSubagentAncestryBySessionId.get(invokingSessionId);
+            const currentAncestry = trackedAncestry ?? (currentSubagentName ? [currentSubagentName] : []);
+            const inferredCurrentDepth = currentSubagentName ? Math.max(currentAncestry.length, 1) : 0;
+            const currentSubagentDepth = Math.max(inProcessSubagentDepthBySessionId.get(invokingSessionId) ?? 0, inferredCurrentDepth);
+            const nextSubagentDepth = currentSubagentDepth + 1;
             // Resolve isolation mode
             const isolationMode = readIsolationMode();
             const useIsolation = Boolean(params.isolated) && isolationMode !== "none";
@@ -1481,6 +1003,30 @@ export default function (pi) {
                 projectAgentsDir: discovery.projectAgentsDir,
                 results,
             });
+            const trackInProcessDepth = (started, depth, ancestry) => {
+                const sessionId = started.handle.sessionId;
+                if (!sessionId)
+                    return;
+                inProcessSubagentDepthBySessionId.set(sessionId, depth);
+                inProcessSubagentAncestryBySessionId.set(sessionId, ancestry);
+                void started.resultPromise.finally(() => {
+                    inProcessSubagentDepthBySessionId.delete(sessionId);
+                    inProcessSubagentAncestryBySessionId.delete(sessionId);
+                });
+            };
+            const buildChildAncestry = (childAgentName) => [...currentAncestry, childAgentName];
+            const requestedAgentNames = hasSingle
+                ? [params.agent]
+                : hasChain
+                    ? (params.chain ?? []).map((step) => step.agent)
+                    : (params.tasks ?? []).map((task) => task.agent);
+            if (currentSubagentName && requestedAgentNames.some((name) => name === currentSubagentName)) {
+                return {
+                    content: [{ type: "text", text: `Subagent "${currentSubagentName}" cannot spawn another subagent with the same name as itself.` }],
+                    details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
+                    isError: true,
+                };
+            }
             if (modeCount !== 1) {
                 const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
                 return {
@@ -1500,6 +1046,20 @@ export default function (pi) {
                     isError: true,
                 };
             }
+            if (params.background && currentSubagentDepth > 0) {
+                return {
+                    content: [{ type: "text", text: "Nested background subagent launches are not supported yet. Run the nested subagent in foreground mode." }],
+                    details: makeDetails("single")([]),
+                    isError: true,
+                };
+            }
+            if (USE_IN_PROCESS_SUBAGENT && nextSubagentDepth > MAX_IN_PROCESS_SUBAGENT_DEPTH) {
+                return {
+                    content: [{ type: "text", text: `Max subagent depth (${MAX_IN_PROCESS_SUBAGENT_DEPTH}) exceeded.` }],
+                    details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
+                    isError: true,
+                };
+            }
             if ((agentScope === "project" || agentScope === "both") && confirmProjectAgents && ctx.hasUI) {
                 const requestedAgentNames = new Set();
                 if (params.chain)
@@ -1544,7 +1104,13 @@ export default function (pi) {
                             }
                         }
                         : undefined;
-                    const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, step.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, chainUpdate, makeDetails("chain"), invokingSessionFile, false, undefined, undefined);
+                    const result = USE_IN_PROCESS_SUBAGENT
+                        ? await (async () => {
+                            const started = await startInProcessSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, step.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, chainUpdate, makeDetails("chain"), invokingSessionFile, nextSubagentDepth, invokingSessionId, currentAncestry);
+                            trackInProcessDepth(started, nextSubagentDepth, buildChildAncestry(step.agent));
+                            return started.resultPromise;
+                        })()
+                        : await runLegacySingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, step.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, chainUpdate, makeDetails("chain"), invokingSessionFile, false, undefined, undefined);
                     results.push(result);
                     const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
                     if (isError) {
@@ -1606,12 +1172,23 @@ export default function (pi) {
                 const gridSurfaces = [];
                 const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
                     const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
-                    const runTask = () => runSingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, t.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, (partial) => {
-                        if (partial.details?.results[0]) {
-                            allResults[index] = partial.details.results[0];
-                            emitParallelUpdate();
-                        }
-                    }, makeDetails("parallel"), invokingSessionFile, false, undefined);
+                    const runTask = () => USE_IN_PROCESS_SUBAGENT
+                        ? (async () => {
+                            const started = await startInProcessSingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, t.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, (partial) => {
+                                if (partial.details?.results[0]) {
+                                    allResults[index] = partial.details.results[0];
+                                    emitParallelUpdate();
+                                }
+                            }, makeDetails("parallel"), invokingSessionFile, nextSubagentDepth, invokingSessionId, currentAncestry);
+                            trackInProcessDepth(started, nextSubagentDepth, buildChildAncestry(t.agent));
+                            return started.resultPromise;
+                        })()
+                        : runLegacySingleAgent(ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, t.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, (partial) => {
+                            if (partial.details?.results[0]) {
+                                allResults[index] = partial.details.results[0];
+                                emitParallelUpdate();
+                            }
+                        }, makeDetails("parallel"), invokingSessionFile, false, undefined);
                     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);
@@ -1668,11 +1245,164 @@ export default function (pi) {
                     const bgInferredModel = resolveSubagentModel({ name: agentForBg.name, model: bgResolvedModelCfg }, { overrideModel: params.model, parentModel: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined });
                     let jobId;
                     try {
-                        jobId = runSubagentInBackground(manager, agents, params.agent, params.task, params.cwd, params.model, { defaultCwd: ctx.cwd, model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, parentSessionFile: invokingSessionFile }, async (bgSignal) => {
-                            let liveSessionFile;
-                            let liveRuntime;
-                            const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, bgSignal, undefined, // no streaming updates for background jobs
-                            makeDetails("single"), invokingSessionFile, true, (info) => {
+                        if (USE_IN_PROCESS_SUBAGENT) {
+                            const started = await startInProcessSingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, undefined, undefined, makeDetails("single"), invokingSessionFile, nextSubagentDepth, invokingSessionId, currentAncestry);
+                            trackInProcessDepth(started, nextSubagentDepth, buildChildAncestry(params.agent));
+                            const effectiveCwd = params.cwd ?? ctx.cwd;
+                            jobId = manager.adoptHandle(params.agent, params.task, effectiveCwd, started.handle, started.resultPromise.then((result) => ({
+                                summary: (getFinalOutput(result.messages) || "(no output)").slice(0, 300),
+                                stderr: result.stderr,
+                                exitCode: result.exitCode,
+                                model: result.model,
+                                sessionFile: result.sessionFile,
+                                parentSessionFile: result.parentSessionFile,
+                            })), {
+                                parentSessionFile: invokingSessionFile,
+                                model: bgInferredModel,
+                            });
+                        }
+                        else {
+                            jobId = runSubagentInBackground(manager, agents, params.agent, params.task, params.cwd, params.model, { defaultCwd: ctx.cwd, model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, parentSessionFile: invokingSessionFile }, async (bgSignal) => {
+                                let liveSessionFile;
+                                let liveRuntime;
+                                const result = await runLegacySingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, bgSignal, undefined, // no streaming updates for background jobs
+                                makeDetails("single"), invokingSessionFile, true, (info) => {
+                                    if (!invokingSessionFile || !info.sessionFile)
+                                        return;
+                                    upsertAgentSessionLink(params.agent, params.task, invokingSessionFile, info.sessionFile, "running");
+                                    liveSessionFile = info.sessionFile;
+                                    if (liveRuntime) {
+                                        liveRuntime.sessionFile = info.sessionFile;
+                                        liveRuntime.parentSessionFile = info.parentSessionFile ?? invokingSessionFile;
+                                        liveRuntimeBySessionFile.set(info.sessionFile, liveRuntime);
+                                    }
+                                }, (event, partial) => {
+                                    const sessionFile = partial.sessionFile;
+                                    if (!sessionFile || activeSessionFileForUi !== sessionFile)
+                                        return;
+                                    if (event?.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
+                                        const delta = String(event.assistantMessageEvent.delta ?? "");
+                                        if (delta)
+                                            pushLiveStreamDelta(sessionFile, delta);
+                                    }
+                                    if (event?.type === "message_end") {
+                                        flushLiveStream(sessionFile);
+                                    }
+                                }, {
+                                    onStart: (control) => {
+                                        if (!control.sendPrompt || !control.sendSteer || !control.sendFollowUp || !control.isBusy)
+                                            return;
+                                        liveRuntime = {
+                                            sessionFile: liveSessionFile,
+                                            parentSessionFile: invokingSessionFile,
+                                            agentName: params.agent,
+                                            isBusy: control.isBusy,
+                                            sendPrompt: control.sendPrompt,
+                                            sendSteer: control.sendSteer,
+                                            sendFollowUp: control.sendFollowUp,
+                                        };
+                                        if (liveSessionFile) {
+                                            liveRuntimeBySessionFile.set(liveSessionFile, liveRuntime);
+                                        }
+                                    },
+                                    onFinish: () => {
+                                        if (liveSessionFile)
+                                            liveRuntimeBySessionFile.delete(liveSessionFile);
+                                    },
+                                });
+                                return {
+                                    exitCode: result.exitCode,
+                                    finalOutput: getFinalOutput(result.messages),
+                                    stderr: result.stderr,
+                                    model: result.model,
+                                    sessionFile: result.sessionFile,
+                                    parentSessionFile: result.parentSessionFile,
+                                };
+                            });
+                        }
+                    }
+                    catch (err) {
+                        return {
+                            content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+                            details: makeDetails("single")([]),
+                            isError: true,
+                        };
+                    }
+                    const bgModelLine = bgInferredModel ? `\nModel: ${bgInferredModel}` : "";
+                    return {
+                        content: [{ type: "text", text: `Background subagent started. Job ID: **${jobId}**\nAgent: ${params.agent}${bgModelLine}\nUse \`await_subagent\` to wait, \`/subagents wait ${jobId}\` to block in the TUI, or \`/subagents cancel ${jobId}\` to stop it.` }],
+                        details: makeDetails("single")([]),
+                    };
+                }
+                // ── Foreground (blocking) mode ───────────────────────────────
+                let isolation = null;
+                let mergeResult;
+                try {
+                    const effectiveCwd = params.cwd ?? ctx.cwd;
+                    if (useIsolation) {
+                        const taskId = crypto.randomUUID();
+                        isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
+                    }
+                    let result;
+                    if (USE_IN_PROCESS_SUBAGENT && !isolation) {
+                        const started = await startInProcessSingleAgent(ctx.cwd, agents, params.agent, params.task, params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, onUpdate, makeDetails("single"), invokingSessionFile, nextSubagentDepth, invokingSessionId, currentAncestry);
+                        trackInProcessDepth(started, nextSubagentDepth, buildChildAncestry(params.agent));
+                        const effectiveRunCwd = params.cwd ?? ctx.cwd;
+                        let releaseToBackground;
+                        const movedToBackground = new Promise((resolve) => {
+                            releaseToBackground = resolve;
+                        });
+                        activeForegroundSubagent = {
+                            claimed: false,
+                            agentName: params.agent,
+                            task: params.task,
+                            cwd: effectiveRunCwd,
+                            parentSessionFile: invokingSessionFile,
+                            handle: started.handle,
+                            resultPromise: started.resultPromise.then((done) => ({
+                                summary: getFinalOutput(done.messages) || "(no output)",
+                                stderr: done.stderr,
+                                exitCode: done.exitCode,
+                                model: done.model,
+                                sessionFile: done.sessionFile,
+                                parentSessionFile: done.parentSessionFile,
+                            })),
+                            adoptToBackground: (jobId) => {
+                                if (!releaseToBackground)
+                                    return false;
+                                releaseToBackground(jobId);
+                                releaseToBackground = undefined;
+                                return true;
+                            },
+                            sendPrompt: started.handle.prompt,
+                            sendSteer: started.handle.steer,
+                            sendFollowUp: started.handle.followUp,
+                            isBusy: started.handle.isBusy,
+                        };
+                        ctx.ui.setStatus(foregroundSubagentStatusKey, foregroundSubagentHint);
+                        const winner = await Promise.race([
+                            started.resultPromise.then((done) => ({ type: "done", done })),
+                            movedToBackground.then((jobId) => ({ type: "background", jobId })),
+                        ]);
+                        if (winner.type === "background") {
+                            activeForegroundSubagent = null;
+                            ctx.ui.setStatus(foregroundSubagentStatusKey, undefined);
+                            result = {
+                                ...started.currentResult,
+                                backgroundJobId: winner.jobId,
+                            };
+                        }
+                        else {
+                            activeForegroundSubagent = null;
+                            ctx.ui.setStatus(foregroundSubagentStatusKey, undefined);
+                            result = winner.done;
+                        }
+                    }
+                    else {
+                        let liveSessionFile;
+                        let liveRuntime;
+                        result = await runLegacySingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, onUpdate, makeDetails("single"), invokingSessionFile, !isolation, !isolation
+                            ? (info) => {
                                 if (!invokingSessionFile || !info.sessionFile)
                                     return;
                                 upsertAgentSessionLink(params.agent, params.task, invokingSessionFile, info.sessionFile, "running");
@@ -1682,7 +1412,9 @@ export default function (pi) {
                                     liveRuntime.parentSessionFile = info.parentSessionFile ?? invokingSessionFile;
                                     liveRuntimeBySessionFile.set(info.sessionFile, liveRuntime);
                                 }
-                            }, (event, partial) => {
+                            }
+                            : undefined, !isolation
+                            ? (event, partial) => {
                                 const sessionFile = partial.sessionFile;
                                 if (!sessionFile || activeSessionFileForUi !== sessionFile)
                                     return;
@@ -1694,8 +1426,12 @@ export default function (pi) {
                                 if (event?.type === "message_end") {
                                     flushLiveStream(sessionFile);
                                 }
-                            }, {
+                            }
+                            : undefined, !isolation
+                            ? {
                                 onStart: (control) => {
+                                    activeForegroundSubagent = { ...control, claimed: false };
+                                    ctx.ui.setStatus(foregroundSubagentStatusKey, foregroundSubagentHint);
                                     if (!control.sendPrompt || !control.sendSteer || !control.sendFollowUp || !control.isBusy)
                                         return;
                                     liveRuntime = {
@@ -1707,103 +1443,19 @@ export default function (pi) {
                                         sendSteer: control.sendSteer,
                                         sendFollowUp: control.sendFollowUp,
                                     };
-                                    if (liveSessionFile) {
+                                    if (liveSessionFile && liveRuntime) {
                                         liveRuntimeBySessionFile.set(liveSessionFile, liveRuntime);
                                     }
                                 },
                                 onFinish: () => {
+                                    activeForegroundSubagent = null;
+                                    ctx.ui.setStatus(foregroundSubagentStatusKey, undefined);
                                     if (liveSessionFile)
                                         liveRuntimeBySessionFile.delete(liveSessionFile);
                                 },
-                            });
-                            return {
-                                exitCode: result.exitCode,
-                                finalOutput: getFinalOutput(result.messages),
-                                stderr: result.stderr,
-                                model: result.model,
-                                sessionFile: result.sessionFile,
-                                parentSessionFile: result.parentSessionFile,
-                            };
-                        });
-                    }
-                    catch (err) {
-                        return {
-                            content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
-                            details: makeDetails("single")([]),
-                            isError: true,
-                        };
-                    }
-                    const bgModelLine = bgInferredModel ? `\nModel: ${bgInferredModel}` : "";
-                    return {
-                        content: [{ type: "text", text: `Background subagent started. Job ID: **${jobId}**\nAgent: ${params.agent}${bgModelLine}\nUse \`await_subagent\` to wait, \`/subagents wait ${jobId}\` to block in the TUI, or \`/subagents cancel ${jobId}\` to stop it.` }],
-                        details: makeDetails("single")([]),
-                    };
-                }
-                // ── Foreground (blocking) mode ───────────────────────────────
-                let isolation = null;
-                let mergeResult;
-                try {
-                    const effectiveCwd = params.cwd ?? ctx.cwd;
-                    if (useIsolation) {
-                        const taskId = crypto.randomUUID();
-                        isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
-                    }
-                    let liveSessionFile;
-                    let liveRuntime;
-                    const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, params.model, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, signal, onUpdate, makeDetails("single"), invokingSessionFile, !isolation, !isolation
-                        ? (info) => {
-                            if (!invokingSessionFile || !info.sessionFile)
-                                return;
-                            upsertAgentSessionLink(params.agent, params.task, invokingSessionFile, info.sessionFile, "running");
-                            liveSessionFile = info.sessionFile;
-                            if (liveRuntime) {
-                                liveRuntime.sessionFile = info.sessionFile;
-                                liveRuntime.parentSessionFile = info.parentSessionFile ?? invokingSessionFile;
-                                liveRuntimeBySessionFile.set(info.sessionFile, liveRuntime);
                             }
-                        }
-                        : undefined, !isolation
-                        ? (event, partial) => {
-                            const sessionFile = partial.sessionFile;
-                            if (!sessionFile || activeSessionFileForUi !== sessionFile)
-                                return;
-                            if (event?.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
-                                const delta = String(event.assistantMessageEvent.delta ?? "");
-                                if (delta)
-                                    pushLiveStreamDelta(sessionFile, delta);
-                            }
-                            if (event?.type === "message_end") {
-                                flushLiveStream(sessionFile);
-                            }
-                        }
-                        : undefined, !isolation
-                        ? {
-                            onStart: (control) => {
-                                activeForegroundSubagent = { ...control, claimed: false };
-                                ctx.ui.setStatus(foregroundSubagentStatusKey, foregroundSubagentHint);
-                                if (!control.sendPrompt || !control.sendSteer || !control.sendFollowUp || !control.isBusy)
-                                    return;
-                                liveRuntime = {
-                                    sessionFile: liveSessionFile,
-                                    parentSessionFile: invokingSessionFile,
-                                    agentName: params.agent,
-                                    isBusy: control.isBusy,
-                                    sendPrompt: control.sendPrompt,
-                                    sendSteer: control.sendSteer,
-                                    sendFollowUp: control.sendFollowUp,
-                                };
-                                if (liveSessionFile && liveRuntime) {
-                                    liveRuntimeBySessionFile.set(liveSessionFile, liveRuntime);
-                                }
-                            },
-                            onFinish: () => {
-                                activeForegroundSubagent = null;
-                                ctx.ui.setStatus(foregroundSubagentStatusKey, undefined);
-                                if (liveSessionFile)
-                                    liveRuntimeBySessionFile.delete(liveSessionFile);
-                            },
-                        }
-                        : undefined);
+                            : undefined);
+                    }
                     if (result.sessionFile && invokingSessionFile) {
                         const existingParent = parentSessionByChild.get(result.sessionFile);
                         if (!existingParent) {