@humain/terminal 0.0.15 → 0.0.17

package/dist/core/tools/subagent.js

@@ -23,6 +23,7 @@ import { getMarkdownTheme } from "../../modes/interactive/theme/theme.js";
 import { parseFrontmatter } from "../../utils/frontmatter.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { shortenPath } from "./render-utils.js";
+import { createSubagentWorktree, isGitWorkTree, } from "./subagent-worktree.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -223,7 +224,10 @@ function getFinalOutput(messages) {
     return "";
 }
 function isFailedResult(result) {
-    return result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+    return (Boolean(result.errorMessage) ||
+        result.exitCode !== 0 ||
+        result.stopReason === "error" ||
+        result.stopReason === "aborted");
 }
 function getResultOutput(result) {
     if (isFailedResult(result)) {
@@ -255,7 +259,7 @@ function getDisplayItems(messages) {
     }
     return items;
 }
-async function mapWithConcurrencyLimit(items, concurrency, fn, signal) {
+async function mapWithConcurrencyLimit(items, concurrency, fn, signal, onAbort) {
     if (items.length === 0)
         return [];
     const limit = Math.max(1, Math.min(concurrency, items.length));
@@ -263,12 +267,14 @@ async function mapWithConcurrencyLimit(items, concurrency, fn, signal) {
     let nextIndex = 0;
     const workers = new Array(limit).fill(null).map(async () => {
         while (true) {
-            // Don't spawn doomed children for tasks still queued after an abort.
-            if (signal?.aborted)
-                throw new Error("Subagent was aborted");
             const current = nextIndex++;
             if (current >= items.length)
                 return;
+            if (signal?.aborted) {
+                if (onAbort)
+                    results[current] = await onAbort(items[current], current);
+                continue;
+            }
             results[current] = await fn(items[current], current);
         }
     });
@@ -297,7 +303,7 @@ function getCliInvocation(args) {
     }
     return { command: "humain-terminal", args };
 }
-async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, model, parentModel, signal, onUpdate, makeDetails) {
+async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, isolation, step, model, parentModel, signal, onUpdate, makeDetails, toolCallId, childIndex) {
     const agent = agents.find((a) => a.name === agentName);
     if (!agent) {
         const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
@@ -310,8 +316,13 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
             stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
             usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
             step,
+            isolation: "shared",
         };
     }
+    let worktree = null;
+    let isolationDegradedReason;
+    const parentCwd = cwd ?? defaultCwd;
+    let childCwd = parentCwd;
     const args = ["--mode", "json", "-p", "--no-session"];
     if (model) {
         // Canonical "provider/modelId" handle: split on the FIRST slash so
@@ -343,6 +354,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
         model: model ?? `${parentModel.provider}/${parentModel.id}`,
         step,
+        isolation: "shared",
     };
     const emitUpdate = () => {
         if (onUpdate) {
@@ -352,7 +364,22 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
             });
         }
     };
+    let wasAborted = false;
     try {
+        if (isolation === "worktree") {
+            if (await isGitWorkTree(parentCwd)) {
+                worktree = await createSubagentWorktree({ parentCwd, label: `${toolCallId}-${childIndex}` });
+                childCwd = worktree.path;
+                currentResult.isolation = "worktree";
+            }
+            else {
+                isolationDegradedReason = "not-a-git-repo";
+            }
+        }
+        if (isolationDegradedReason)
+            currentResult.isolationDegradedReason = isolationDegradedReason;
+        if (signal?.aborted)
+            throw new Error("Subagent was aborted");
         if (agent.systemPrompt.trim()) {
             const tmp = await writePromptToTempFile(agent.name, agent.systemPrompt);
             tmpPromptDir = tmp.dir;
@@ -360,16 +387,16 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
             args.push("--append-system-prompt", tmpPromptPath);
         }
         args.push(`Task: ${task}`);
-        let wasAborted = false;
         const exitCode = await new Promise((resolve) => {
             const invocation = getCliInvocation(args);
             const proc = spawn(invocation.command, invocation.args, {
-                cwd: cwd ?? defaultCwd,
+                cwd: childCwd,
                 shell: false,
                 stdio: ["ignore", "pipe", "pipe"],
                 env: { ...process.env, [SUBAGENT_DEPTH_ENV]: String(currentSubagentDepth() + 1) },
             });
             let buffer = "";
+            let settled = false;
             const processLine = (line) => {
                 if (!line.trim())
                     return;
@@ -418,23 +445,39 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
             proc.stderr.on("data", (data) => {
                 currentResult.stderr += data.toString();
             });
+            let abortListener;
+            let killTimer;
+            const cleanupAbort = () => {
+                if (signal && abortListener)
+                    signal.removeEventListener("abort", abortListener);
+                if (killTimer)
+                    clearTimeout(killTimer);
+            };
             proc.on("close", (code) => {
+                settled = true;
+                cleanupAbort();
                 if (buffer.trim())
                     processLine(buffer);
                 resolve(code ?? 0);
             });
             proc.on("error", () => {
+                settled = true;
+                cleanupAbort();
                 resolve(1);
             });
             if (signal) {
                 const killProc = () => {
+                    if (settled)
+                        return;
                     wasAborted = true;
-                    proc.kill("SIGTERM");
-                    setTimeout(() => {
-                        if (!proc.killed)
+                    killTimer = setTimeout(() => {
+                        if (!settled)
                             proc.kill("SIGKILL");
                     }, 5000);
+                    killTimer.unref?.();
+                    proc.kill("SIGTERM");
                 };
+                abortListener = killProc;
                 if (signal.aborted)
                     killProc();
                 else
@@ -442,11 +485,50 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
             }
         });
         currentResult.exitCode = exitCode;
-        if (wasAborted)
-            throw new Error("Subagent was aborted");
-        return currentResult;
+        if (wasAborted || signal?.aborted) {
+            currentResult.exitCode = 1;
+            currentResult.stopReason = "aborted";
+            currentResult.errorMessage = "Subagent was aborted";
+        }
+    }
+    catch (error) {
+        currentResult.exitCode = 1;
+        currentResult.errorMessage = error instanceof Error ? error.message : String(error);
+        if (wasAborted || signal?.aborted)
+            currentResult.stopReason = "aborted";
     }
     finally {
+        if (worktree) {
+            try {
+                if (isFailedResult(currentResult) || signal?.aborted) {
+                    currentResult.mergeOutcome = "skipped";
+                }
+                else {
+                    const merged = await worktree.mergeBack();
+                    currentResult.mergeOutcome = merged.outcome;
+                    currentResult.changedFiles = merged.changedFiles;
+                    if (merged.patchPath)
+                        currentResult.patchPath = merged.patchPath;
+                    if (merged.outcome === "conflict") {
+                        currentResult.errorMessage = `subagent merge conflict: ${merged.changedFiles.join(", ")} could not be applied to the parent workspace; patch kept at ${merged.patchPath}`;
+                    }
+                }
+            }
+            catch (error) {
+                currentResult.exitCode = 1;
+                currentResult.mergeOutcome = "skipped";
+                currentResult.errorMessage = `subagent merge failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            finally {
+                try {
+                    await worktree.dispose();
+                }
+                catch (error) {
+                    currentResult.exitCode = 1;
+                    currentResult.errorMessage = `subagent worktree cleanup failed: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+        }
         if (tmpPromptPath)
             try {
                 fs.unlinkSync(tmpPromptPath);
@@ -462,6 +544,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
                 /* ignore */
             }
     }
+    return currentResult;
 }
 const TaskItem = Type.Object({
     agent: Type.String({ description: "Name of the agent to invoke" }),
@@ -470,6 +553,9 @@ const TaskItem = Type.Object({
         description: "Optional canonical provider/model for this child. Defaults to the parent provider/model.",
     })),
     cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
+    isolation: Type.Optional(StringEnum(["shared", "worktree"], {
+        description: "Filesystem isolation for this child. 'worktree' runs it in a disposable git worktree and merges its changes back; the caller's policy sets this, not the model.",
+    })),
 });
 const ChainItem = Type.Object({
     agent: Type.String({ description: "Name of the agent to invoke" }),
@@ -494,6 +580,9 @@ const SubagentParams = Type.Object({
     agentScope: Type.Optional(AgentScopeSchema),
     confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: true.", default: true })),
     cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
+    isolation: Type.Optional(StringEnum(["shared", "worktree"], {
+        description: "Filesystem isolation for this child. 'worktree' runs it in a disposable git worktree and merges its changes back; the caller's policy sets this, not the model.",
+    })),
 });
 export function createSubagentToolDefinition(cwd) {
     return {
@@ -502,6 +591,7 @@ export function createSubagentToolDefinition(cwd) {
         description: [
             "Delegate tasks to specialized subagents with isolated context.",
             "Modes: single (agent + task), parallel (tasks array), chain (sequential with {previous} placeholder).",
+            "The optional isolation field is policy-set for each child.",
             `Default agent scope is "user" (from ${path.join(getAgentDir(), "agents")}).`,
             `To enable project-local agents in ${CONFIG_DIR_NAME}/agents, set agentScope: "both" (or "project").`,
         ].join(" "),
@@ -510,7 +600,7 @@ export function createSubagentToolDefinition(cwd) {
             "Use subagent to fan out independent work in parallel (tasks array) or run multi-step pipelines (chain). Subagents run with isolated context and cannot delegate further.",
         ],
         parameters: SubagentParams,
-        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
             const agentScope = params.agentScope ?? "user";
             const defaultCwd = ctx?.cwd ?? cwd;
             const parentModel = ctx?.model;
@@ -539,6 +629,7 @@ export function createSubagentToolDefinition(cwd) {
                 usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
                 errorMessage,
                 step: child.step,
+                isolation: "shared",
             });
             const stubAllChildren = (errorMessage) => requestedChildren().map((child) => stubResult(child, errorMessage));
             const makeDetails = (mode) => (results) => ({
@@ -631,7 +722,7 @@ export function createSubagentToolDefinition(cwd) {
                             }
                         }
                         : undefined;
-                    const result = await runSingleAgent(defaultCwd, agents, step.agent, taskWithContext, step.cwd, i + 1, step.model, parentModel, signal, chainUpdate, makeDetails("chain"));
+                    const result = await runSingleAgent(defaultCwd, agents, step.agent, taskWithContext, step.cwd, undefined, i + 1, step.model, parentModel, signal, chainUpdate, makeDetails("chain"), toolCallId, i);
                     results.push(result);
                     const isError = isFailedResult(result);
                     if (isError) {
@@ -676,6 +767,7 @@ export function createSubagentToolDefinition(cwd) {
                         messages: [],
                         stderr: "",
                         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+                        isolation: "shared",
                     };
                 }
                 const emitParallelUpdate = () => {
@@ -691,18 +783,18 @@ export function createSubagentToolDefinition(cwd) {
                     }
                 };
                 const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
-                    const result = await runSingleAgent(defaultCwd, agents, t.agent, t.task, t.cwd, undefined, t.model, parentModel, signal, 
+                    const result = await runSingleAgent(defaultCwd, agents, t.agent, t.task, t.cwd, t.isolation, undefined, t.model, parentModel, signal, 
                     // Per-task update callback
                     (partial) => {
                         if (partial.details?.results[0]) {
                             allResults[index] = partial.details.results[0];
                             emitParallelUpdate();
                         }
-                    }, makeDetails("parallel"));
+                    }, makeDetails("parallel"), toolCallId, index);
                     allResults[index] = result;
                     emitParallelUpdate();
                     return result;
-                }, signal);
+                }, signal, (t) => stubResult({ agent: t.agent, task: t.task }, "not run: subagent was aborted"));
                 const successCount = results.filter((r) => !isFailedResult(r)).length;
                 const summaries = results.map((r) => {
                     const output = truncateParallelOutput(getResultOutput(r));
@@ -719,10 +811,11 @@ export function createSubagentToolDefinition(cwd) {
                         },
                     ],
                     details: makeDetails("parallel")(results),
+                    isError: successCount !== results.length,
                 };
             }
             if (params.agent && params.task) {
-                const result = await runSingleAgent(defaultCwd, agents, params.agent, params.task, params.cwd, undefined, params.model, parentModel, signal, onUpdate, makeDetails("single"));
+                const result = await runSingleAgent(defaultCwd, agents, params.agent, params.task, params.cwd, params.isolation, undefined, params.model, parentModel, signal, onUpdate, makeDetails("single"), toolCallId, 0);
                 const isError = isFailedResult(result);
                 if (isError) {
                     const errorMsg = getResultOutput(result);