@kolisachint/hoocode-agent 0.4.110 → 0.4.112

package/dist/core/tools/subagent.js

@@ -7,14 +7,19 @@
  * fresh, isolated child process (SubagentPool) and only its final answer is
  * returned to the parent.
  *
- * It is an optional, opt-in tool (enabled via --enable-subagents or the
- * `enableSubagent` setting); see buildSessionOptions in main.ts.
+ * Enabled by default (the `enableSubagent` setting defaults to true); disable
+ * with `enableSubagent: false`. The `--enable-subagents` flag still force-enables
+ * it. Nesting is bounded by the tree-wide depth cap (maxSubagentDepth, default 2:
+ * a spawned subagent may itself delegate one more level, and depth-2 grandchildren
+ * cannot). See buildSessionOptions in main.ts.
  */
 import { Text } from "@kolisachint/hoocode-tui";
 import { Type } from "typebox";
+import { agentColorFor } from "../../modes/interactive/theme/theme.js";
 import { TASK_TOOL_NAME } from "../agent-frontmatter.js";
 import { loadAgentRegistry } from "../agent-registry.js";
 import { defineTool } from "../extensions/types.js";
+import { formatDurationSecs } from "../format-duration.js";
 import { getProviderExhaustion } from "../provider-health.js";
 import { SessionManager } from "../session-manager.js";
 import { delegateAllowList, isDelegateAllowed } from "../subagent-depth.js";
@@ -33,7 +38,21 @@ export { summarizeAgentDescription } from "../agent-registry.js";
  *  `<available_agents>` block the system prompt emits whenever the Task tool is
  *  active (see agent-session `_rebuildSystemPrompt`); this appendix references
  *  that list rather than re-rendering the roster and paying for it twice. */
-export function buildTaskMainPrompt() {
+/**
+ * Build the main-session subagent instructions appended to the system prompt.
+ *
+ * The detailed background/barrier guidance (the three heaviest bullets) is only
+ * emitted when the project actually has background-capable agents; otherwise a
+ * single concise line covers the per-call `background: true` escape hatch. This
+ * keeps the always-on cost down for the common case where nothing runs in the
+ * background. `cwd` is used only to detect those agents.
+ */
+export function buildTaskMainPrompt(cwd = process.cwd()) {
+    const hasBackgroundAgents = collectBackgroundAgentNames(cwd).size > 0;
+    const backgroundGuidance = hasBackgroundAgents
+        ? `- Background agents run non-blocking (or force per call with \`background: true\`): you get a short "explore#1 finished" notification and pull the full result with \`TaskOutput\` (e.g. \`TaskOutput("explore#1")\`); \`TaskOutput(list: true)\` shows what's running.
+- After dispatching, don't idle — keep doing independent work (read/edit unrelated files, draft, dispatch more); barrier with \`TaskOutput(wait: true)\` (a named task, or all outstanding when no id) only when you genuinely can't proceed.`
+        : `- You can force any task to run in the background with \`background: true\` (non-blocking): keep working, then pull its result with \`TaskOutput\` (e.g. \`TaskOutput("explore#1")\`) or block on it with \`TaskOutput(wait: true)\`.`;
     return `You have access to the **Task** tool. Use it to delegate self-contained tasks to specialized subagents that run in their own isolated context and return only their final answer. Pick an agent by name from the <available_agents> list in this prompt and pass it as \`subagent_type\`.
 
 When to delegate:
@@ -50,9 +69,8 @@ Guidelines:
 - Do NOT delegate tasks that require tight back-and-forth with your current reasoning, or edits to files you are actively reasoning about.
 - The subagent returns ONLY its final answer. Its intermediate reasoning, tool calls, and output are hidden from you.
 - Delegate proactively when work is self-contained or parallelizable: multi-step investigation, read-only exploration (use \`explore\`), research before changes (use \`plan\`), drafting a standalone file/section, or running a long command/test suite. Dispatch independent subtasks in the same turn. Handle only trivial single-step edits or tightly interactive back-and-forth inline.
-- Some agents run in the background (non-blocking); force it per call with \`background: true\` (or \`background: false\` to wait inline). A background Task does not block your turn and does not return its answer inline: you get a short notification ("explore#1 finished") and the full result is held for you to pull with \`TaskOutput\`. Keep working in the meantime.
-- After dispatching background work, DO NOT stop and wait — that wastes the parallelism and looks stuck. Immediately continue with the next useful thing: read or edit an independent file, draft the parts of your answer that don't depend on the pending result, or dispatch more independent subtasks. Only barrier (with \`TaskOutput(wait: true)\`) when you genuinely cannot proceed without the result. Prefer background dispatch for any self-contained or parallelizable work so your turn never blocks on a subagent.
-- Use **TaskOutput** to manage background subagents: \`TaskOutput(list: true)\` shows every running/finished subagent and what each is doing; \`TaskOutput("explore#1")\` reads a finished subagent's full result (or reports its status if still running); \`TaskOutput(wait: true)\` blocks until a named task — or, with no task_id, ALL outstanding subagents — finish. Dispatch a batch in one turn, then barrier on them with \`TaskOutput(wait: true)\` only once you've exhausted the work you can do without them.
+${backgroundGuidance}
+- When working through a TodoWrite plan, mark the plan item in_progress BEFORE dispatching subagents for it: each dispatch is attributed to the current in_progress item in the user's task panel, so dispatching first (or with several items in_progress) leaves the run unattributed.
 - To continue a previous subagent (for example one that returned partial results), call Task again with \`resume_task_id\` set to its task_id; it resumes with its full prior transcript and \`prompt\` is your follow-up.`;
 }
 const taskParams = Type.Object({
@@ -106,18 +124,37 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
                 return override;
             return backgroundAgents.has(String(toolCall.arguments?.subagent_type ?? ""));
         },
-        // Kept lean: the available agents are listed in the system prompt, and the
-        // `complexity`/`background` semantics live in their parameter descriptions —
-        // repeating them here would re-spend those tokens on every turn.
-        description: [
-            "Delegate a focused task to a specialized subagent that runs in a fresh, isolated context (it cannot see this conversation). Choose one of the available agents (listed in the system prompt) via `subagent_type` and pass everything it needs via `prompt`; the subagent returns only its final answer.",
-            "WHEN TO USE: (1) self-contained work where you only need the final result; (2) parallel investigation/edits without losing your reasoning chain; (3) a discrete unit (explore one module, run one test file, review one PR, fix one isolated bug, write docs); (4) a long command or test suite you want to run without blocking your reasoning.",
-            "Do NOT use for tasks needing tight back-and-forth with your current reasoning, or edits to files you are actively reasoning about. Delegate proactively for self-contained or parallelizable work; handle only trivial single-step or tightly interactive work inline.",
-        ].join("\n"),
+        // Kept to mechanics only: the when-to-use / when-not-to guidance lives once in
+        // the system-prompt block (buildTaskMainPrompt), the available agents are
+        // listed there too, and the `complexity`/`background`/`resume_task_id`
+        // semantics live in their parameter descriptions. Repeating any of that here
+        // would re-spend those tokens on every turn.
+        description: "Delegate a focused task to a specialized subagent that runs in a fresh, isolated context (it cannot see this conversation). Choose one of the available agents (listed in the system prompt) via `subagent_type` and pass everything it needs via `prompt`; the subagent returns only its final answer.",
         promptSnippet: "delegate a self-contained task to a specialized subagent (choose via subagent_type)",
         parameters: taskParams,
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
             const pool = getSubagentPool(ctx.cwd);
+            // User-initiated cancel (Esc/abort): kill the dispatched run's whole
+            // process tree and let the dispatch settle with status "cancelled" —
+            // distinct from "failed" everywhere it surfaces (panel, inbox, result).
+            // Cold dispatches only: a warm worker has no cancel surface (it is
+            // reused), so warm runs still complete server-side and are discarded.
+            const cancelOnAbort = async (poolRunId, run) => {
+                if (!signal)
+                    return run();
+                const onAbort = () => {
+                    pool.cancel?.(poolRunId);
+                };
+                if (signal.aborted)
+                    onAbort();
+                signal.addEventListener("abort", onAbort, { once: true });
+                try {
+                    return await run();
+                }
+                finally {
+                    signal.removeEventListener("abort", onAbort);
+                }
+            };
             // Pre-flight: if the inherited provider recently exhausted its quota (the
             // parent's own turn failed with a usage/rate-limit error that did not
             // recover), skip the spawn. Subagents run on the same provider, so this
@@ -126,12 +163,16 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
             const provider = ctx.model?.provider;
             const exhaustion = provider ? getProviderExhaustion(provider) : undefined;
             if (exhaustion) {
+                const skippedRunId = newDispatchTaskId();
                 const skipped = taskStore.create(params.description?.trim() || summarize(params.prompt), {
                     source: "subagent",
                     subagentMode: params.subagent_type,
-                    agent: params.subagent_type,
+                    agent: skippedRunId,
+                    linkedTaskId: linkedTodoId(),
                 });
+                registerSubagentDispatch(skippedRunId, subagentInbox.nextLabel(params.subagent_type));
                 taskStore.update(skipped.id, { status: "failed", note: `${provider} exhausted` });
+                taskStore.patchAgent(skippedRunId, { state: "failed" });
                 return {
                     content: [
                         {
@@ -156,23 +197,27 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
             const resumeId = params.resume_task_id?.trim();
             if (resumeId) {
                 const summary = params.description?.trim() || summarize(params.prompt);
+                const runId = newDispatchTaskId();
+                const label = subagentInbox.nextLabel(params.subagent_type);
                 const task = taskStore.create(summary, {
                     source: "subagent",
                     subagentMode: params.subagent_type,
-                    agent: params.subagent_type,
+                    agent: runId,
+                    linkedTaskId: linkedTodoId(),
                 });
-                registerSubagentDispatch(params.subagent_type);
+                registerSubagentDispatch(runId, label);
                 taskStore.update(task.id, { status: "in_progress" });
                 try {
-                    const dispatchResult = await pool.resume(resumeId, params.prompt, {
+                    const dispatchResult = await cancelOnAbort(runId, () => pool.resume(resumeId, params.prompt, {
                         model: ctx.model?.id,
                         provider: ctx.model?.provider,
-                    });
+                        taskId: runId,
+                    }));
                     // The session lives under the original task id; keep it as the resume handle.
-                    return finalizeDispatchResult(dispatchResult, params.subagent_type, task.id, resumeId);
+                    return finalizeDispatchResult(dispatchResult, params.subagent_type, runId, task.id, resumeId);
                 }
                 catch (error) {
-                    taskStore.update(task.id, { status: "failed" });
+                    markDispatchFailed(task.id, runId);
                     throw error;
                 }
             }
@@ -188,12 +233,23 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
                 throw new Error(`Unknown subagent_type: "${params.subagent_type}". Available agents: ${available || "(none)"}.`);
             }
             const summary = params.description?.trim() || summarize(params.prompt);
+            // One roster row per dispatch, keyed by the (pre-allocated) pool task id.
+            // Keying by agent TYPE made concurrent same-type runs share a single row:
+            // their activity, state, and stats collided last-writer-wins. The inbox
+            // already keys by task id; this aligns the panel to the same model. The
+            // pool's task_progress events carry the task id, so patching by this id
+            // routes live activity to the right row.
+            const poolTaskId = newDispatchTaskId();
+            const label = subagentInbox.nextLabel(params.subagent_type);
             const task = taskStore.create(summary, {
                 source: "subagent",
                 subagentMode: params.subagent_type,
-                agent: params.subagent_type,
+                agent: poolTaskId,
+                // Tie this run to the plan item it executes (the single in_progress
+                // TodoWrite task, when unambiguous) so the panel can nest it there.
+                linkedTaskId: linkedTodoId(),
             });
-            registerSubagentDispatch(params.subagent_type);
+            registerSubagentDispatch(poolTaskId, label);
             taskStore.update(task.id, { status: "in_progress" });
             // Fork agents inherit the parent's conversation via a forked session.
             const forkSessionFile = def.fork
@@ -210,11 +266,9 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
             // recompute it here to choose the notify-and-pull return shape.
             const isBackground = params.background ?? backgroundAgents.has(params.subagent_type);
             if (isBackground) {
-                // Notify-and-pull: register the dispatch in the inbox under a pre-allocated
-                // id, await it, retain the body in the inbox, and return a compact
-                // notification (not the body). The model pulls the body with TaskOutput.
-                const poolTaskId = `dispatch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                const label = subagentInbox.nextLabel(params.subagent_type);
+                // Notify-and-pull: register the dispatch in the inbox under the
+                // pre-allocated id, await it, retain the body in the inbox, and return a
+                // compact notification (not the body). The model pulls it with TaskOutput.
                 subagentInbox.observe(pool);
                 subagentInbox.start(poolTaskId, label, params.subagent_type);
                 // Warm path (opt-in): run on a reused RPC worker, retain the body in the
@@ -229,10 +283,10 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
                                 cwd: ctx.cwd,
                                 model: dispatchModel,
                                 provider: ctx.model?.provider,
-                            }, (activity) => taskStore.patchAgent(params.subagent_type, { activity }));
+                            }, (activity) => taskStore.patchAgent(poolTaskId, { activity }));
                             const dispatchResult = warmResultToTaskResult(warmResult, params.subagent_type, task.id);
                             subagentInbox.finish(poolTaskId, dispatchResult);
-                            return finalizeDispatchResult(dispatchResult, params.subagent_type, task.id, poolTaskId, {
+                            return finalizeDispatchResult(dispatchResult, params.subagent_type, poolTaskId, task.id, poolTaskId, {
                                 taskId: poolTaskId,
                                 label,
                             });
@@ -245,23 +299,23 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
                     }
                 }
                 try {
-                    const dispatchResult = await pool.dispatch(params.prompt, {
+                    const dispatchResult = await cancelOnAbort(poolTaskId, () => pool.dispatch(params.prompt, {
                         forceAgent: params.subagent_type,
                         context: "",
                         model: dispatchModel,
                         provider: ctx.model?.provider,
                         sessionFile: forkSessionFile,
                         taskId: poolTaskId,
-                    });
+                    }));
                     subagentInbox.finish(poolTaskId, dispatchResult);
-                    return finalizeDispatchResult(dispatchResult, params.subagent_type, task.id, poolTaskId, {
+                    return finalizeDispatchResult(dispatchResult, params.subagent_type, poolTaskId, task.id, poolTaskId, {
                         taskId: poolTaskId,
                         label,
                     });
                 }
                 catch (error) {
                     const reason = error instanceof Error ? error.message : String(error);
-                    taskStore.update(task.id, { status: "failed" });
+                    markDispatchFailed(task.id, poolTaskId);
                     subagentInbox.fail(poolTaskId, reason);
                     // A background dispatch reports failure as a compact notification, not a
                     // thrown tool error — the call was already answered by a placeholder.
@@ -295,15 +349,16 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
                         }, 
                         // Mirror the cold pool's live progress on the task panel roster so a
                         // warm dispatch reads as busy (⋯ grep), not stuck.
-                        (activity) => taskStore.patchAgent(params.subagent_type, { activity }));
+                        (activity) => taskStore.patchAgent(poolTaskId, { activity }));
                         const dispatchResult = warmResultToTaskResult(warmResult, params.subagent_type, task.id);
-                        return finalizeDispatchResult(dispatchResult, params.subagent_type, task.id, undefined);
+                        return finalizeDispatchResult(dispatchResult, params.subagent_type, poolTaskId, task.id, undefined);
                     }
                     catch (error) {
                         // A genuine infra failure (worker crash/timeout) retries cold; any other
                         // error is a real dispatch failure and propagates.
                         if (!(error instanceof WarmWorkerError)) {
                             taskStore.update(task.id, { status: "failed" });
+                            taskStore.patchAgent(poolTaskId, { state: "failed", activity: "" });
                             throw error;
                         }
                         console.error(`[WARM] ${params.subagent_type} fell back to cold spawn: ${error.message}`);
@@ -312,23 +367,27 @@ export function createTaskToolDefinition(cwd = process.cwd()) {
             }
             // Foreground: block the turn and return the subagent's full answer inline.
             try {
-                const dispatchResult = await pool.dispatch(params.prompt, {
+                const dispatchResult = await cancelOnAbort(poolTaskId, () => pool.dispatch(params.prompt, {
                     forceAgent: params.subagent_type,
                     context: "",
                     model: dispatchModel,
                     provider: ctx.model?.provider,
                     sessionFile: forkSessionFile,
-                });
-                return finalizeDispatchResult(dispatchResult, params.subagent_type, task.id, dispatchResult.task_id);
+                    taskId: poolTaskId,
+                }));
+                return finalizeDispatchResult(dispatchResult, params.subagent_type, poolTaskId, task.id, dispatchResult.task_id);
             }
             catch (error) {
-                taskStore.update(task.id, { status: "failed" });
+                markDispatchFailed(task.id, poolTaskId);
                 throw error;
             }
         },
         renderCall(args, theme) {
             const type = args.subagent_type ?? "agent";
-            const text = theme.fg("toolTitle", theme.bold("Agent ")) + theme.fg("accent", `[${type}]`);
+            // The [type] tag carries the agent's identity color — the same hue this
+            // agent has in the task panel and TaskOutput — so a transcript full of
+            // concurrent dispatches is scannable by color.
+            const text = theme.fg("toolTitle", theme.bold("Agent ")) + theme.fg(agentColorFor(type), `[${type}]`);
             return new Text(text, 0, 0);
         },
     });
@@ -350,13 +409,47 @@ export function resolveForkSessionFile(def, parentSessionPath, cwd) {
         return undefined;
     }
 }
+/** Pre-allocated pool task id for a dispatch (matches the pool's own format). */
+function newDispatchTaskId() {
+    return `dispatch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * The TodoWrite plan item this dispatch is (most plausibly) working on: the
+ * single in_progress main-agent task. TodoWrite discipline keeps exactly one
+ * item in_progress, so when that holds the link is unambiguous; with zero or
+ * several in_progress items no link is recorded rather than guessing. Used to
+ * nest the run under its plan item in the task panel's flat lens.
+ */
+function linkedTodoId() {
+    const inProgress = taskStore
+        .list()
+        .filter((t) => t.source === undefined &&
+        t.agent === undefined &&
+        t.parentTaskId === undefined &&
+        t.status === "in_progress");
+    return inProgress.length === 1 ? inProgress[0]?.id : undefined;
+}
 /**
- * Register the dispatched agent in the task store's roster so the task pane's
- * grouped views (subagents/teams) can draw a group header for it. Upsert keeps
- * accumulated stats across re-dispatches of the same agent type.
+ * Register this dispatch in the task store's roster, keyed by its run id (the
+ * pool task id) so concurrent runs of the same agent type each get their own
+ * row, state, activity, and stats. The friendly label ("explore#1") names the
+ * row the same way the inbox names background tasks.
  */
-function registerSubagentDispatch(type) {
-    taskStore.upsertAgent({ id: type, name: type, role: "subagent", kind: "subagent", state: "running" });
+function registerSubagentDispatch(runId, label) {
+    taskStore.upsertAgent({ id: runId, name: label, role: "subagent", kind: "subagent", state: "running" });
+}
+/**
+ * Catch-path bookkeeping: mark the dispatch failed unless it already settled.
+ * finalizeDispatchResult records a terminal status (failed/cancelled) *before*
+ * throwing, so a blanket "failed" here would clobber a cancellation with a
+ * failure the moment the thrown error passed through.
+ */
+function markDispatchFailed(taskStoreId, runId) {
+    const current = taskStore.list().find((t) => t.id === taskStoreId);
+    if (current && current.status !== "pending" && current.status !== "in_progress")
+        return;
+    taskStore.update(taskStoreId, { status: "failed" });
+    taskStore.patchAgent(runId, { state: "failed", activity: "" });
 }
 /** Names of agents configured to run in the background (non-blocking). */
 function collectBackgroundAgentNames(cwd) {
@@ -426,26 +519,29 @@ function warmResultToTaskResult(warm, agentType, taskStoreId) {
  * inbox, so it returns a compact, self-contained notification (success or
  * failure) and never throws — the call was already answered by a placeholder.
  */
-function finalizeDispatchResult(dispatchResult, subagentType, taskStoreId, resumeHandle, background) {
+function finalizeDispatchResult(dispatchResult, subagentType, runAgentId, taskStoreId, resumeHandle, background) {
     const result = dispatchResult.result;
     const resultData = result?.result_data;
     const usage = resultData?.usage;
     // Merge the child's own task subtree under the dispatching task so nested
     // delegation (depth >= 2) is visible in the subagents lens's task tree.
     mergeChildTaskTree(resultData?.task_tree, taskStoreId);
-    // Roll the agent's per-run usage into its roster stats so the grouped views'
-    // header carries the agent's own token/cost totals.
+    // Roll this run's usage into its own roster row (rows are per-dispatch).
     if (usage) {
-        taskStore.addAgentStats(subagentType, { input: usage.input, output: usage.output, cost: usage.cost });
+        taskStore.addAgentStats(runAgentId, { input: usage.input, output: usage.output, cost: usage.cost });
     }
     if (!result || !result.ok) {
+        // A user-initiated cancel is not a failure: it gets its own terminal
+        // status so the panel shows ⊘ cancelled (dim) instead of ✗ failed (red).
+        const cancelled = result?.status === "cancelled";
         const failNote = result?.usedInheritedModelFallback ? "inherited-model retry failed" : undefined;
-        taskStore.update(taskStoreId, { status: "failed", usage, note: failNote });
-        taskStore.patchAgent(subagentType, { state: "failed" });
+        taskStore.update(taskStoreId, { status: cancelled ? "cancelled" : "failed", usage, note: failNote });
+        taskStore.patchAgent(runAgentId, { state: cancelled ? "cancelled" : "failed", activity: "" });
         const reason = result?.error ?? (result?.status ? `subagent ${result.status}` : "unknown error");
         if (background) {
+            const verdict = cancelled ? "cancelled ⊘" : "failed ✗";
             return {
-                content: [{ type: "text", text: `${background.label} failed ✗ — ${reason}` }],
+                content: [{ type: "text", text: `${background.label} ${verdict} — ${reason}` }],
                 details: {
                     subagent_type: subagentType,
                     ok: false,
@@ -456,20 +552,20 @@ function finalizeDispatchResult(dispatchResult, subagentType, taskStoreId, resum
                 },
             };
         }
+        if (cancelled) {
+            throw new Error(`Subagent (${subagentType}) cancelled by user.`);
+        }
         const stderr = result?.stderr?.trim();
         throw new Error(`Subagent (${subagentType}) failed: ${reason}${stderr ? `\nstderr: ${stderr.slice(-500)}` : ""}`);
     }
     // Leave the task in the store with its final status; it stays visible in the
     // task panel until the next user message arrives. Surface a ⚠ cue when the run
-    // fell back to the inherited model rather than emitting a chat message.
+    // fell back to the inherited model rather than emitting a chat message — and
+    // clear any stale note otherwise (note is clearable via an explicit undefined).
     const fallbackNote = dispatchResult.result?.usedInheritedModelFallback ? "ran on inherited model" : undefined;
     taskStore.update(taskStoreId, { status: "done", usage, note: fallbackNote });
-    // Parallel dispatches share one roster entry per agent type: stay `running`
-    // while a sibling task is still live, settle to `done` otherwise.
-    const siblingLive = taskStore
-        .list()
-        .some((t) => t.agent === subagentType && (t.status === "in_progress" || t.status === "pending"));
-    taskStore.patchAgent(subagentType, { state: siblingLive ? "running" : "done" });
+    // Rows are per-run, so this run settles to done regardless of siblings.
+    taskStore.patchAgent(runAgentId, { state: "done", activity: "" });
     let answer = resultData?.summary || "(subagent returned no output)";
     // Partial results are resumable; surface the handle so the parent can continue.
     if (result.status === "partial" && resumeHandle) {
@@ -504,7 +600,7 @@ const taskOutputParams = Type.Object({
         description: 'Handle of a background subagent — its task_id or friendly label (e.g. "explore#1") from a Task notification. Omit (or set list:true) to see every background task.',
     })),
     list: Type.Optional(Type.Boolean({
-        description: "List all background subagents with their status (running/done/failed) and current activity. No result bodies are returned.",
+        description: "List all background subagents with their status (running/done/failed/cancelled) and current activity. No result bodies are returned.",
     })),
     wait: Type.Optional(Type.Boolean({
         description: "Block until the named task finishes — or, with no task_id, until all outstanding subagents finish (a swarm barrier) — before returning. Bounded by timeout_ms.",
@@ -512,10 +608,13 @@ const taskOutputParams = Type.Object({
     timeout_ms: Type.Optional(Type.Number({ description: "Maximum time to block in wait mode, in milliseconds (default 120000)." })),
 });
 const TASK_OUTPUT_DEFAULT_TIMEOUT_MS = 120_000;
-/** Whole seconds a record has run (so far, or until it settled). */
+/**
+ * Elapsed time a record has run (so far, or until it settled), in the same
+ * format the task panel uses so the two surfaces always agree.
+ */
 function recordElapsed(rec) {
     const end = rec.endedAt ?? Date.now();
-    return `${Math.max(0, Math.round((end - rec.startedAt) / 1000))}s`;
+    return formatDurationSecs((end - rec.startedAt) / 1000);
 }
 /** A compact roster of every known background subagent — status + activity, no bodies. */
 function formatTaskRoster() {
@@ -536,6 +635,8 @@ function formatTaskRoster() {
                 return `- ${r.label}  done (uncollected)  ${when} — ${r.summaryLine ?? ""}`;
             case "collected":
                 return `- ${r.label}  collected  ${when} — ${r.summaryLine ?? ""}`;
+            case "cancelled":
+                return `- ${r.label}  cancelled ⊘  — ${r.error ?? "cancelled by user"}`;
             default:
                 return `- ${r.label}  ${r.lifecycle} ✗  — ${r.error ?? "unknown error"}`;
         }
@@ -629,19 +730,62 @@ export function createTaskOutputToolDefinition() {
                     details: { task_id: handle, status: "collected", ok: true },
                 };
             }
-            // failed / stalled / timeout
+            // failed / stalled / timeout / cancelled
+            const glyph = rec.lifecycle === "cancelled" ? "⊘" : "✗";
             return {
                 content: [
-                    { type: "text", text: `${rec.label} ${rec.lifecycle} ✗ — ${rec.error ?? "unknown error"}.` },
+                    {
+                        type: "text",
+                        text: `${rec.label} ${rec.lifecycle} ${glyph} — ${rec.error ?? "unknown error"}.`,
+                    },
                 ],
                 details: { task_id: handle, status: rec.lifecycle, ok: false },
             };
         },
         renderCall(args, theme) {
             const target = args.list ? "list" : String(args.task_id ?? "");
-            const text = theme.fg("toolTitle", theme.bold("TaskOutput ")) + theme.fg("dim", args.wait ? `${target} (wait)` : target);
+            // A friendly label ("explore#1") gets its agent's identity color so the
+            // pull visually pairs with the dispatch that produced it; raw ids and
+            // "list" stay dim.
+            const hashIdx = target.indexOf("#");
+            const styledTarget = hashIdx > 0 ? theme.fg(agentColorFor(target.slice(0, hashIdx)), target) : theme.fg("dim", target);
+            const text = theme.fg("toolTitle", theme.bold("TaskOutput ")) +
+                styledTarget +
+                (args.wait ? theme.fg("dim", " (wait)") : "");
             return new Text(text, 0, 0);
         },
+        renderResult(result, _options, theme) {
+            // Display-only colorization of the roster/status lines (the text sent to
+            // the model stays plain). Lines that aren't roster rows — collected
+            // bodies, status sentences — render exactly like the default fallback.
+            const text = result.content
+                .map((c) => (c.type === "text" ? c.text : ""))
+                .filter(Boolean)
+                .join("\n");
+            if (!text)
+                return new Text("", 0, 0);
+            const rosterLine = /^- (\S+)\s{2}(running|done \(uncollected\)|collected|failed|stalled|timeout|cancelled)(.*)$/;
+            const styled = text
+                .split("\n")
+                .map((line) => {
+                const match = rosterLine.exec(line);
+                if (!match)
+                    return theme.fg("toolOutput", line);
+                const [, label, status, rest] = match;
+                const hashIdx = label.indexOf("#");
+                const labelColor = hashIdx > 0 ? agentColorFor(label.slice(0, hashIdx)) : "accent";
+                const statusColor = status === "running"
+                    ? "warning"
+                    : status.startsWith("done")
+                        ? "success"
+                        : status === "collected" || status === "cancelled"
+                            ? "muted"
+                            : "error";
+                return `- ${theme.fg(labelColor, label)}  ${theme.fg(statusColor, status)}${theme.fg("dim", rest)}`;
+            })
+                .join("\n");
+            return new Text(styled, 0, 0);
+        },
     });
 }
 //# sourceMappingURL=subagent.js.map