reasonix 0.28.0 → 0.29.0

package/dist/cli/index.js

@@ -2742,6 +2742,10 @@ var ToolRegistry = class {
   wasFlattened(name) {
     return Boolean(this._tools.get(name)?.flatSchema);
   }
+  /** Unknown / unannotated tools default to false — third-party MCP tools must opt in. */
+  isParallelSafe(name) {
+    return this._tools.get(name)?.parallelSafe === true;
+  }
   specs() {
     return [...this._tools.values()].map((t3) => ({
       type: "function",
@@ -4433,6 +4437,48 @@ var CacheFirstLoop = class {
     this._escalateThisTurn = true;
     return true;
   }
+  async runOneToolCall(call, signal) {
+    const name = call.function?.name ?? "";
+    const args = call.function?.arguments ?? "{}";
+    const parsedArgs = safeParseToolArgs(args);
+    const preReport = await runHooks({
+      hooks: this.hooks,
+      payload: {
+        event: "PreToolUse",
+        cwd: this.hookCwd,
+        toolName: name,
+        toolArgs: parsedArgs
+      }
+    });
+    const preWarnings = [...hookWarnings(preReport.outcomes, this._turn)];
+    if (preReport.blocked) {
+      const blocking = preReport.outcomes[preReport.outcomes.length - 1];
+      const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
+      return {
+        preWarnings,
+        postWarnings: [],
+        result: `[hook block] ${blocking?.hook.command ?? "<unknown>"}
+${reason}`
+      };
+    }
+    const result = await this.tools.dispatch(name, args, {
+      signal,
+      maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
+      confirmationGate: this.confirmationGate
+    });
+    const postReport = await runHooks({
+      hooks: this.hooks,
+      payload: {
+        event: "PostToolUse",
+        cwd: this.hookCwd,
+        toolName: name,
+        toolArgs: parsedArgs,
+        toolResult: result
+      }
+    });
+    const postWarnings = [...hookWarnings(postReport.outcomes, this._turn)];
+    return { preWarnings, postWarnings, result };
+  }
   buildMessages(pendingUser) {
     const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
     const msgs = [...this.prefix.toMessages(), ...healed.messages];
@@ -4924,71 +4970,69 @@ var CacheFirstLoop = class {
         yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "context-guard" });
         return;
       }
-      for (const call of repairedCalls) {
-        const name = call.function?.name ?? "";
-        const args = call.function?.arguments ?? "{}";
-        yield {
-          turn: this._turn,
-          role: "tool_start",
-          content: "",
-          toolName: name,
-          toolArgs: args
-        };
-        const parsedArgs = safeParseToolArgs(args);
-        const preReport = await runHooks({
-          hooks: this.hooks,
-          payload: {
-            event: "PreToolUse",
-            cwd: this.hookCwd,
-            toolName: name,
-            toolArgs: parsedArgs
+      const dispatchSerial = (process.env.REASONIX_TOOL_DISPATCH ?? "auto").toLowerCase() === "serial";
+      const parallelMaxParsed = Number.parseInt(process.env.REASONIX_PARALLEL_MAX ?? "", 10);
+      const parallelMax = Number.isFinite(parallelMaxParsed) && parallelMaxParsed >= 1 ? Math.min(parallelMaxParsed, 16) : 3;
+      let callIdx = 0;
+      while (callIdx < repairedCalls.length) {
+        const chunk = [];
+        if (!dispatchSerial) {
+          while (callIdx < repairedCalls.length && chunk.length < parallelMax && this.tools.isParallelSafe(repairedCalls[callIdx]?.function?.name ?? "")) {
+            chunk.push(repairedCalls[callIdx++]);
           }
-        });
-        for (const w of hookWarnings(preReport.outcomes, this._turn)) yield w;
-        let result;
-        if (preReport.blocked) {
-          const blocking = preReport.outcomes[preReport.outcomes.length - 1];
-          const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
-          result = `[hook block] ${blocking?.hook.command ?? "<unknown>"}
-${reason}`;
-        } else {
-          result = await this.tools.dispatch(name, args, {
-            signal,
-            maxResultTokens: DEFAULT_MAX_RESULT_TOKENS,
-            confirmationGate: this.confirmationGate
-          });
-          const postReport = await runHooks({
-            hooks: this.hooks,
-            payload: {
-              event: "PostToolUse",
-              cwd: this.hookCwd,
-              toolName: name,
-              toolArgs: parsedArgs,
-              toolResult: result
-            }
-          });
-          for (const w of hookWarnings(postReport.outcomes, this._turn)) yield w;
         }
-        this.appendAndPersist({
-          role: "tool",
-          tool_call_id: call.id ?? "",
-          name,
-          content: result
-        });
-        if (this.noteToolFailureSignal(result)) {
+        if (chunk.length === 0) {
+          chunk.push(repairedCalls[callIdx++]);
+        }
+        for (const call of chunk) {
           yield {
             turn: this._turn,
-            role: "warning",
-            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+            role: "tool_start",
+            content: "",
+            toolName: call.function?.name ?? "",
+            toolArgs: call.function?.arguments ?? "{}"
+          };
+        }
+        const settled = await Promise.allSettled(chunk.map((c) => this.runOneToolCall(c, signal)));
+        for (let k = 0; k < chunk.length; k++) {
+          const call = chunk[k];
+          const name = call.function?.name ?? "";
+          const args = call.function?.arguments ?? "{}";
+          const s = settled[k];
+          let result;
+          let preWarnings = [];
+          let postWarnings = [];
+          if (s.status === "fulfilled") {
+            preWarnings = s.value.preWarnings;
+            postWarnings = s.value.postWarnings;
+            result = s.value.result;
+          } else {
+            const err = s.reason instanceof Error ? s.reason : new Error(String(s.reason));
+            result = JSON.stringify({ error: `${err.name}: ${err.message}` });
+          }
+          for (const w of preWarnings) yield w;
+          for (const w of postWarnings) yield w;
+          this.appendAndPersist({
+            role: "tool",
+            tool_call_id: call.id ?? "",
+            name,
+            content: result
+          });
+          if (this.noteToolFailureSignal(result)) {
+            yield {
+              turn: this._turn,
+              role: "warning",
+              content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailures.formatBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
+            };
+          }
+          yield {
+            turn: this._turn,
+            role: "tool",
+            content: result,
+            toolName: name,
+            toolArgs: args
           };
         }
-        yield {
-          turn: this._turn,
-          role: "tool",
-          content: result,
-          toolName: name,
-          toolArgs: args
-        };
       }
     }
     yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "budget" });
@@ -5633,6 +5677,7 @@ function registerFilesystemTools(registry, opts) {
   };
   registry.register({
     name: "read_file",
+    parallelSafe: true,
     description: `Read a file under the sandbox root. To save context, PREFER to scope the read instead of pulling the whole file:
   - head: N  \u2192 first N lines (imports, public API, small configs)
   - tail: N  \u2192 last N lines (recently-added code, log tails)
@@ -5716,6 +5761,7 @@ ${slice.join("\n")}`;
   });
   registry.register({
     name: "list_directory",
+    parallelSafe: true,
     description: "List entries in a directory under the sandbox root. Returns one line per entry, marking directories with a trailing slash. Not recursive \u2014 use directory_tree for that.",
     readOnly: true,
     parameters: {
@@ -5736,6 +5782,7 @@ ${slice.join("\n")}`;
   });
   registry.register({
     name: "directory_tree",
+    parallelSafe: true,
     description: `Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Budget-aware by default:
   - maxDepth defaults to 2 (root + one level). A depth-4 tree on a real repo blew ~5K tokens in one call. If you truly need deeper, pass maxDepth:N explicitly.
   - Skips ${[...SKIP_DIR_NAMES].sort().join(", ")} unless include_deps:true. Traversing into node_modules / .git / dist is almost always token-waste.
@@ -5814,6 +5861,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "search_files",
+    parallelSafe: true,
     description: "Find files whose NAME matches a substring or regex. Case-insensitive. Walks the directory recursively under the sandbox root. Returns one path per line. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) by default.",
     readOnly: true,
     parameters: {
@@ -5839,6 +5887,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "search_content",
+    parallelSafe: true,
     description: "Recursively grep file CONTENTS for a substring or regex. This is the right tool for 'find all places that call X', 'where is Y referenced', 'what files contain Z'. Different from search_files (which matches FILE NAMES). Returns one match per line in 'path:line: text' format. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) and binary files by default.",
     readOnly: true,
     parameters: {
@@ -5881,6 +5930,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "get_file_info",
+    parallelSafe: true,
     description: "Stat a path under the sandbox root. Returns type (file|directory|symlink), size in bytes, mtime in ISO-8601.",
     readOnly: true,
     parameters: {
@@ -6061,6 +6111,7 @@ function registerMemoryTools(registry, opts = {}) {
     name: "recall_memory",
     description: "Read the full body of a memory file when its MEMORY.md one-liner (already in the system prompt) isn't enough detail. Most of the time the index suffices \u2014 only call this when the user's question genuinely requires the full context.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -6413,6 +6464,11 @@ var SUBAGENT_TYPE_NAMES = Object.freeze(
 );
 
 // src/tools/subagent.ts
+var runIdCounter = 0;
+function nextRunId() {
+  runIdCounter++;
+  return `sub-${runIdCounter.toString(36)}`;
+}
 var DEFAULT_SUBAGENT_SYSTEM = `You are a Reasonix subagent. The parent agent spawned you to handle one focused subtask, then return.
 
 Rules:
@@ -6439,9 +6495,11 @@ async function spawnSubagent(opts) {
   const sink = opts.sink;
   const skillName = opts.skillName;
   const startedAt = Date.now();
+  const runId = nextRunId();
   const taskPreview = opts.task.length > 30 ? `${opts.task.slice(0, 30)}\u2026` : opts.task;
   sink?.current?.({
     kind: "start",
+    runId,
     task: taskPreview,
     skillName,
     model: model2,
@@ -6454,6 +6512,7 @@ async function spawnSubagent(opts) {
       const errorMessage2 = `subagent allow-list names tool(s) not registered in the parent: ${missing.join(", ")}. Fix the skill's \`allowed-tools\` frontmatter or check spelling.`;
       sink?.current?.({
         kind: "end",
+        runId,
         task: taskPreview,
         skillName,
         model: model2,
@@ -6515,12 +6574,13 @@ async function spawnSubagent(opts) {
   let summarisingEmitted = false;
   try {
     for await (const ev of childLoop.step(opts.task)) {
-      sink?.current?.({ kind: "inner", task: taskPreview, skillName, model: model2, inner: ev });
+      sink?.current?.({ kind: "inner", runId, task: taskPreview, skillName, model: model2, inner: ev });
       if (ev.role === "tool") {
         toolIter++;
         summarisingEmitted = false;
         sink?.current?.({
           kind: "progress",
+          runId,
           task: taskPreview,
           skillName,
           model: model2,
@@ -6532,6 +6592,7 @@ async function spawnSubagent(opts) {
         summarisingEmitted = true;
         sink?.current?.({
           kind: "phase",
+          runId,
           task: taskPreview,
           skillName,
           model: model2,
@@ -6568,6 +6629,7 @@ async function spawnSubagent(opts) {
 [\u2026truncated ${final.length - maxResultChars} chars; ask the subagent for a tighter summary if you need more.]` : final;
   sink?.current?.({
     kind: "end",
+    runId,
     task: taskPreview,
     skillName,
     model: model2,
@@ -7918,6 +7980,7 @@ function registerShellTools(registry, opts) {
     name: "job_output",
     description: "Read the latest output of a background job started with `run_background`. By default returns the tail of the buffer (last 80 lines). Pass `since` (the `byteLength` from a previous call) to stream only new content incrementally. Tells you whether the job is still running, so you can stop polling when it's done.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -7962,6 +8025,7 @@ function registerShellTools(registry, opts) {
     name: "list_jobs",
     description: "List every background job started this session \u2014 running and exited \u2014 with id, command, pid, status. Use when you've lost track of which job_id corresponds to which process, or to see what's still alive.",
     readOnly: true,
+    parallelSafe: true,
     parameters: { type: "object", properties: {} },
     fn: async () => {
       const all = jobs2.list();
@@ -8219,6 +8283,7 @@ function registerWebTools(registry, opts = {}) {
     name: "web_search",
     description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -8242,6 +8307,7 @@ function registerWebTools(registry, opts = {}) {
     name: "web_fetch",
     description: "Download a URL and return its visible text content (HTML pages get scripts/styles/nav stripped). Truncated at the tool-result cap. Use after web_search when a snippet isn't enough.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -15539,6 +15605,7 @@ async function registerSemanticSearchTool(registry, opts) {
     name: "semantic_search",
     description: "FIRST CHOICE for descriptive queries. Use this BEFORE search_content (grep) when the user describes WHAT code does ('where do we handle X', 'which file owns Y', 'how does Z work', 'find the logic that \u2026'). Returns ranked snippets ordered by semantic relevance \u2014 finds the right file even when your description shares no words with the code. Falls back to search_content / search_files only for: exact identifiers, regex patterns, or counting occurrences of a known token. If your first instinct is grep on a paraphrased question, you are wrong \u2014 try semantic_search first.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -16917,6 +16984,7 @@ function registerSkillTools(registry, opts = {}) {
     name: "run_skill",
     description: "Invoke a playbook from the Skills index pinned in the system prompt. Each entry is a self-contained instruction block. Pass `name` as the BARE skill identifier (e.g. 'explore'), NOT the `[\u{1F9EC} subagent]` tag that appears after it in the index. Entries tagged `[\u{1F9EC} subagent]` spawn an isolated subagent \u2014 only the final distilled answer comes back, the model's tool calls + reasoning during the run never enter your context. Plain skills are inlined: the body becomes a tool result you read and follow. For subagent skills, supply 'arguments' describing the concrete task \u2014 they'll be the only context the subagent has.",
     readOnly: true,
+    parallelSafe: true,
     parameters: {
       type: "object",
       properties: {
@@ -25085,9 +25153,7 @@ function subagentPhaseLabel(phase, iter, elapsedMs) {
   if (iter === 0) return "thinking\u2026";
   return "working through tools\u2026";
 }
-function SubagentRow({
-  activity
-}) {
+function SubagentRow({ activity }) {
   useTick();
   const seconds = (activity.elapsedMs / 1e3).toFixed(1);
   const phase = subagentPhaseLabel(activity.phase, activity.iter, activity.elapsedMs);
@@ -25108,6 +25174,46 @@ function SubagentRow({
     }
   ), /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, "task  ", /* @__PURE__ */ React58.createElement(Text2, { color: FG.sub }, activity.task)), /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, "last  ", last ? /* @__PURE__ */ React58.createElement(React58.Fragment, null, /* @__PURE__ */ React58.createElement(Text2, { color: last.color }, `${last.glyph} `), /* @__PURE__ */ React58.createElement(Text2, { color: FG.body }, last.label), last.meta ? /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, `   ${last.meta}`) : null) : /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, "queued\u2026")), /* @__PURE__ */ React58.createElement(Text2, { color: TONE.brand }, "\u25B6  ", phase));
 }
+function SubagentLiveStack({
+  activities,
+  max = 3
+}) {
+  const tick = useTick();
+  if (activities.length === 0) return null;
+  if (activities.length === 1) return /* @__PURE__ */ React58.createElement(SubagentRow, { activity: activities[0] });
+  const visible = activities.slice(0, max);
+  const overflow = activities.length - visible.length;
+  const summarising = activities.filter((a) => a.phase === "summarising").length;
+  const metaParts = [`${activities.length} running`];
+  if (summarising > 0) metaParts.push(`${summarising} summarising`);
+  return /* @__PURE__ */ React58.createElement(Card, { tone: CARD.subagent.color }, /* @__PURE__ */ React58.createElement(
+    CardHeader,
+    {
+      glyph: "\u232C",
+      tone: CARD.subagent.color,
+      title: "subagents",
+      titleColor: PILL_SECTION.plan.fg,
+      titleBg: PILL_SECTION.plan.bg,
+      subtitle: metaParts.join(" \xB7 "),
+      right: /* @__PURE__ */ React58.createElement(Spinner, { kind: "braille", color: CARD.subagent.color })
+    }
+  ), visible.map((a, i) => /* @__PURE__ */ React58.createElement(CompactSubagentLine, { key: a.runId, activity: a, tick, index: i })), overflow > 0 ? /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, `  +${overflow} more running\u2026`) : null);
+}
+function CompactSubagentLine({
+  activity,
+  tick,
+  index
+}) {
+  const summarising = activity.phase === "summarising";
+  const spinnerFrame = SPINNER_FRAMES[(tick + index) % SPINNER_FRAMES.length] ?? "\xB7";
+  const glyph = summarising ? "\u25B6" : spinnerFrame;
+  const glyphColor = summarising ? TONE.brand : CARD.subagent.color;
+  const seconds = (activity.elapsedMs / 1e3).toFixed(1).padStart(5);
+  const title = activity.skillName ?? truncate3(activity.task, 28);
+  const titlePadded = title.padEnd(28);
+  const last = activity.lastInner;
+  return /* @__PURE__ */ React58.createElement(Box2, { flexDirection: "row" }, /* @__PURE__ */ React58.createElement(Text2, { color: glyphColor, bold: true }, `  ${glyph} `), /* @__PURE__ */ React58.createElement(Text2, { color: FG.body }, titlePadded), /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, `  iter ${String(activity.iter).padStart(2)} \xB7 ${seconds}s \xB7 `), last ? /* @__PURE__ */ React58.createElement(React58.Fragment, null, /* @__PURE__ */ React58.createElement(Text2, { color: last.color }, `${last.glyph} `), /* @__PURE__ */ React58.createElement(Text2, { color: FG.body }, truncate3(last.label, 18)), last.meta ? /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, `  ${last.meta}`) : null) : /* @__PURE__ */ React58.createElement(Text2, { color: FG.faint }, "queued\u2026"));
+}
 function truncate3(text, max) {
   return text.length > max ? `${text.slice(0, max)}\u2026` : text;
 }
@@ -28960,7 +29066,7 @@ function useSubagent({
   log,
   getWalletCurrency
 }) {
-  const [activity, setActivity] = useState17(null);
+  const [activities, setActivities] = useState17([]);
   const sinkRef = useRef8({ current: null });
   const getWalletCurrencyRef = useRef8(getWalletCurrency);
   useEffect13(() => {
@@ -28969,24 +29075,11 @@ function useSubagent({
   useEffect13(() => {
     sinkRef.current.current = (ev) => {
       if (ev.kind === "start") {
-        setActivity({
-          task: ev.task,
-          iter: ev.iter ?? 0,
-          elapsedMs: ev.elapsedMs ?? 0,
-          skillName: ev.skillName,
-          model: ev.model,
-          phase: "exploring",
-          lastInner: null
-        });
-        return;
-      }
-      if (ev.kind === "progress") {
-        setActivity(
-          (prev) => prev ? {
-            ...prev,
-            iter: ev.iter ?? prev.iter,
-            elapsedMs: ev.elapsedMs ?? prev.elapsedMs
-          } : {
+        setActivities((prev) => {
+          if (prev.some((a) => a.runId === ev.runId)) return prev;
+          const next = {
+            runId: ev.runId,
+            startedAt: Date.now() - (ev.elapsedMs ?? 0),
             task: ev.task,
             iter: ev.iter ?? 0,
             elapsedMs: ev.elapsedMs ?? 0,
@@ -28994,45 +29087,59 @@ function useSubagent({
             model: ev.model,
             phase: "exploring",
             lastInner: null
-          }
-        );
-        return;
-      }
-      if (ev.kind === "phase") {
-        setActivity((prev) => prev ? { ...prev, phase: ev.phase } : prev);
+          };
+          return [...prev, next];
+        });
         return;
       }
-      if (ev.kind === "inner" && ev.inner) {
-        const summary2 = summariseInner(ev.inner);
-        if (!summary2) return;
-        setActivity((prev) => prev ? { ...prev, lastInner: summary2 } : prev);
+      if (ev.kind === "end") {
+        setActivities((prev) => prev.filter((a) => a.runId !== ev.runId));
+        const seconds = ((ev.elapsedMs ?? 0) / 1e3).toFixed(1);
+        const costTail = ev.costUsd !== void 0 && ev.costUsd > 0 ? ` \xB7 ${formatCost(ev.costUsd, getWalletCurrencyRef.current?.())}` : "";
+        const summary = ev.error ? `\u232C subagent "${ev.task}" failed after ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \u2014 ${ev.error}` : `\u232C subagent "${ev.task}" done in ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \xB7 ${ev.turns ?? 0} turn(s)${costTail}`;
+        log.pushInfo(summary);
+        if (!ev.error && ev.usage && ev.model) {
+          appendUsage({
+            session: session ?? null,
+            model: ev.model,
+            usage: ev.usage,
+            kind: "subagent",
+            subagent: {
+              skillName: ev.skillName,
+              taskPreview: ev.task.slice(0, 60),
+              toolIters: ev.iter ?? 0,
+              durationMs: ev.elapsedMs ?? 0
+            }
+          });
+        }
         return;
       }
-      setActivity(null);
-      const seconds = ((ev.elapsedMs ?? 0) / 1e3).toFixed(1);
-      const costTail = ev.costUsd !== void 0 && ev.costUsd > 0 ? ` \xB7 ${formatCost(ev.costUsd, getWalletCurrencyRef.current?.())}` : "";
-      const summary = ev.error ? `\u232C subagent "${ev.task}" failed after ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \u2014 ${ev.error}` : `\u232C subagent "${ev.task}" done in ${seconds}s \xB7 ${ev.iter ?? 0} tool call(s) \xB7 ${ev.turns ?? 0} turn(s)${costTail}`;
-      log.pushInfo(summary);
-      if (!ev.error && ev.usage && ev.model) {
-        appendUsage({
-          session: session ?? null,
-          model: ev.model,
-          usage: ev.usage,
-          kind: "subagent",
-          subagent: {
-            skillName: ev.skillName,
-            taskPreview: ev.task.slice(0, 60),
-            toolIters: ev.iter ?? 0,
-            durationMs: ev.elapsedMs ?? 0
+      setActivities(
+        (prev) => prev.map((a) => {
+          if (a.runId !== ev.runId) return a;
+          if (ev.kind === "progress") {
+            return {
+              ...a,
+              iter: ev.iter ?? a.iter,
+              elapsedMs: ev.elapsedMs ?? a.elapsedMs
+            };
           }
-        });
-      }
+          if (ev.kind === "phase") {
+            return { ...a, phase: ev.phase ?? a.phase };
+          }
+          if (ev.kind === "inner" && ev.inner) {
+            const summary = summariseInner(ev.inner);
+            return summary ? { ...a, lastInner: summary } : a;
+          }
+          return a;
+        })
+      );
     };
     return () => {
       sinkRef.current.current = null;
     };
   }, [session, log]);
-  return { activity, sinkRef };
+  return { activities, sinkRef };
 }
 
 // src/cli/ui/App.tsx
@@ -29130,7 +29237,7 @@ function AppInner({
     };
   }, [stdout4]);
   const walletCurrencyRef = useRef9(void 0);
-  const { activity: subagentActivity, sinkRef: subagentSinkRef } = useSubagent({
+  const { activities: subagentActivities, sinkRef: subagentSinkRef } = useSubagent({
     session,
     log,
     getWalletCurrency: () => walletCurrencyRef.current
@@ -30900,7 +31007,7 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
         dashboardUrl,
         languageVersion
       }
-    ) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && ongoingTool ? /* @__PURE__ */ React65.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && subagentActivity ? /* @__PURE__ */ React65.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && !ongoingTool && statusLine ? /* @__PURE__ */ React65.createElement(ThinkingRow, { text: statusLine }) : null, !PLAIN_UI && undoBanner && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && !pendingChoice && !stagedChoiceCustom && !pendingRevision && !stagedCheckpointRevise && !pendingCheckpoint ? /* @__PURE__ */ React65.createElement(UndoBanner, { banner: undoBanner }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && busy && !isStreaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React65.createElement(ThinkingRow, { text: "processing\u2026" }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview ? /* @__PURE__ */ React65.createElement(PlanLiveRow, null) : null, /* @__PURE__ */ React65.createElement(ToastRail, null)), stagedInput ? /* @__PURE__ */ React65.createElement(
+    ) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && ongoingTool ? /* @__PURE__ */ React65.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && subagentActivities.length > 0 ? /* @__PURE__ */ React65.createElement(SubagentLiveStack, { activities: subagentActivities, max: 3 }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && !ongoingTool && statusLine ? /* @__PURE__ */ React65.createElement(ThinkingRow, { text: statusLine }) : null, !PLAIN_UI && undoBanner && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && !pendingChoice && !stagedChoiceCustom && !pendingRevision && !stagedCheckpointRevise && !pendingCheckpoint ? /* @__PURE__ */ React65.createElement(UndoBanner, { banner: undoBanner }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview && busy && !isStreaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React65.createElement(ThinkingRow, { text: "processing\u2026" }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !pendingReviseEditor && !pendingSessionsPicker && !pendingMcpHub && !stagedInput && !pendingEditReview ? /* @__PURE__ */ React65.createElement(PlanLiveRow, null) : null, /* @__PURE__ */ React65.createElement(ToastRail, null)), stagedInput ? /* @__PURE__ */ React65.createElement(
       PlanRefineInput,
       {
         mode: stagedInput.mode,