whale-code 6.5.4 → 6.5.6

package/dist/cli/chat/hooks/useAgentLoop.js

@@ -3,385 +3,499 @@
  *
  * All consumers should import from ChatApp (re-export facade).
  */
-import { useCallback, useRef } from "react";
+
+import { useRef } from "react";
 import { runAgentLoop } from "../../services/agent-loop.js";
 import { AgentEventEmitter } from "../../services/agent-events.js";
 import { listBackups } from "../../services/file-history.js";
 export function useAgentLoop(deps) {
-    const { isStreaming, thinkingEnabled, conversationRef, abortRef, accTextRef, lastContentUpdateRef, thinkingChunksRef, thinkingDoneRef, rewindManagerRef, turnIndexRef, setMessages, setStreamingText, setIsStreaming, setActiveTools, setSubagentActivity, setCompletedSubagents, setTeamState, } = deps;
-    // Single ref for the unified flush timer — survives across handleSend calls for cleanup
-    const flushTimerRef = useRef(null);
-    const handleSend = useCallback(async (userMessage, images) => {
-        if (isStreaming)
-            return;
-        setMessages((prev) => [...prev, {
-                role: "user",
-                text: userMessage,
-                images: images?.map(img => img.name),
-            }]);
-        setStreamingText("");
-        setActiveTools([]);
-        setSubagentActivity(new Map());
-        setCompletedSubagents([]);
-        setTeamState(null);
-        setIsStreaming(true);
-        thinkingChunksRef.current = 0;
-        thinkingDoneRef.current = false;
-        const abort = new AbortController();
-        abortRef.current = abort;
-        accTextRef.current = "";
-        const toolCalls = [];
-        let usage;
-        // ── Unified render batching ──
-        // All events accumulate in local state; ONE 100ms timer flushes all dirty fields.
-        // This replaces 3 separate timers (text: 150ms, tool_output: 250ms, team: 200ms)
-        // and adds batching for previously-unbatched subagent events.
-        const dirty = { text: false, tools: false, team: false, subagents: false };
-        const subagentMap = new Map();
-        const pendingCompleted = [];
-        function markDirty(field) {
-            dirty[field] = true;
-            if (!flushTimerRef.current) {
-                flushTimerRef.current = setTimeout(flushAll, 100);
-            }
+  const {
+    isStreaming,
+    thinkingEnabled,
+    conversationRef,
+    abortRef,
+    accTextRef,
+    lastContentUpdateRef,
+    thinkingChunksRef,
+    thinkingDoneRef,
+    rewindManagerRef,
+    turnIndexRef,
+    setMessages,
+    setStreamingText,
+    setIsStreaming,
+    setActiveTools,
+    setSubagentActivity,
+    setCompletedSubagents,
+    setTeamState
+  } = deps;
+
+  // Single ref for the unified flush timer — survives across handleSend calls for cleanup
+  const flushTimerRef = useRef(null);
+  const handleSend = async (userMessage, images) => {
+    if (isStreaming) return;
+    setMessages(prev => [...prev, {
+      role: "user",
+      text: userMessage,
+      images: images?.map(img => img.name)
+    }]);
+    setStreamingText("");
+    setActiveTools([]);
+    setSubagentActivity(new Map());
+    setCompletedSubagents([]);
+    setTeamState(null);
+    setIsStreaming(true);
+    thinkingChunksRef.current = 0;
+    thinkingDoneRef.current = false;
+    const abort = new AbortController();
+    abortRef.current = abort;
+    accTextRef.current = "";
+    const toolCalls = [];
+    let usage;
+
+    // ── Unified render batching ──
+    // All events accumulate in local state; ONE 100ms timer flushes all dirty fields.
+    // This replaces 3 separate timers (text: 150ms, tool_output: 250ms, team: 200ms)
+    // and adds batching for previously-unbatched subagent events.
+    const dirty = {
+      text: false,
+      tools: false,
+      team: false,
+      subagents: false,
+      messages: false
+    };
+    const subagentMap = new Map();
+    const pendingCompleted = [];
+    const pendingToolMsgs = [];
+    function markDirty(field) {
+      dirty[field] = true;
+      if (!flushTimerRef.current) {
+        flushTimerRef.current = setTimeout(flushAll, 200);
+      }
+    }
+    function cancelFlush() {
+      if (flushTimerRef.current) {
+        clearTimeout(flushTimerRef.current);
+        flushTimerRef.current = null;
+      }
+    }
+    function flushAll() {
+      flushTimerRef.current = null;
+      if (dirty.text) {
+        setStreamingText(accTextRef.current);
+        dirty.text = false;
+      }
+      if (dirty.tools) {
+        setActiveTools([...toolCalls]);
+        dirty.tools = false;
+      }
+      if (dirty.team) {
+        setTeamState({
+          name: teamName,
+          tasksCompleted: teamCompleted,
+          tasksTotal: teamTotal,
+          teammates: new Map(teammateStatus)
+        });
+        dirty.team = false;
+      }
+      if (dirty.subagents) {
+        setSubagentActivity(new Map(subagentMap));
+        if (pendingCompleted.length > 0) {
+          const batch = pendingCompleted.splice(0);
+          setCompletedSubagents(prev_0 => [...prev_0, ...batch]);
         }
-        function cancelFlush() {
-            if (flushTimerRef.current) {
-                clearTimeout(flushTimerRef.current);
-                flushTimerRef.current = null;
-            }
+        dirty.subagents = false;
+      }
+      if (dirty.messages) {
+        const batch_0 = pendingToolMsgs.splice(0);
+        if (batch_0.length > 0) {
+          setMessages(prev_1 => [...prev_1, ...batch_0]);
         }
-        function flushAll() {
-            flushTimerRef.current = null;
-            if (dirty.text) {
-                setStreamingText(accTextRef.current);
-                dirty.text = false;
+        dirty.messages = false;
+      }
+      lastContentUpdateRef.current = Date.now();
+    }
+    const flushText = () => {
+      const text = accTextRef.current;
+      if (text.trim()) {
+        setMessages(prev_2 => [...prev_2, {
+          role: "assistant",
+          text
+        }]);
+      }
+      accTextRef.current = "";
+      dirty.text = false;
+      setStreamingText("");
+    };
+    const emitter = new AgentEventEmitter();
+
+    // Team tracking
+    let teamName = "";
+    let teamTotal = 0;
+    let teamCompleted = 0;
+    const teammateStatus = new Map();
+    const unsub = emitter.onEvent(event => {
+      switch (event.type) {
+        case "thinking":
+          thinkingChunksRef.current = event.chunkCount;
+          markDirty("text");
+          break;
+        case "text":
+          if (thinkingChunksRef.current > 0 && !thinkingDoneRef.current) {
+            thinkingDoneRef.current = true;
+            markDirty("text");
+          }
+          accTextRef.current += event.text;
+          markDirty("text");
+          break;
+        case "tool_output":
+          {
+            const idx_0 = toolCalls.findIndex(t_0 => t_0.name === event.toolName && t_0.status === "running");
+            if (idx_0 >= 0) {
+              const prev_3 = toolCalls[idx_0].result || "";
+              const lines = (prev_3 + "\n" + event.line).split("\n");
+              toolCalls[idx_0].result = lines.slice(-4).join("\n").trim();
+              markDirty("tools");
+            }
+            break;
+          }
+        case "tool_progress":
+          {
+            const idx = toolCalls.findIndex(t => t.name === event.toolName && t.status === "running");
+            if (idx >= 0) {
+              toolCalls[idx].progress = event.progress;
+              markDirty("tools");
             }
-            if (dirty.tools) {
-                setActiveTools([...toolCalls]);
-                dirty.tools = false;
+            break;
+          }
+        case "team_start":
+          teamName = event.name;
+          teamTotal = event.taskCount;
+          teamCompleted = 0;
+          teammateStatus.clear();
+          markDirty("team");
+          break;
+        case "team_task":
+          if (event.status === "started") {
+            const existing_4 = teammateStatus.get(event.teammateId);
+            teammateStatus.set(event.teammateId, {
+              name: existing_4?.name || event.teammateId,
+              status: event.taskDescription.slice(0, 50),
+              startTime: existing_4?.startTime || Date.now()
+            });
+          } else if (event.status === "completed") {
+            teamCompleted++;
+            const existing_5 = teammateStatus.get(event.teammateId);
+            teammateStatus.set(event.teammateId, {
+              name: existing_5?.name || event.teammateId,
+              status: "done",
+              startTime: existing_5?.startTime || Date.now()
+            });
+          } else if (event.status === "failed") {
+            // Task failed, but teammate is still alive — show the failure briefly
+            // as progress, don't permanently mark the teammate as "failed".
+            // The teammate will claim the next task or send "done" when finished.
+            const existing_6 = teammateStatus.get(event.teammateId);
+            teammateStatus.set(event.teammateId, {
+              name: existing_6?.name || event.teammateId,
+              status: "retrying…",
+              startTime: existing_6?.startTime || Date.now()
+            });
+          }
+          markDirty("team");
+          break;
+        case "team_progress":
+          {
+            const existing_3 = teammateStatus.get(event.teammateId);
+            teammateStatus.set(event.teammateId, {
+              name: event.teammateName || event.teammateId,
+              status: event.message.slice(0, 50),
+              startTime: existing_3?.startTime || Date.now()
+            });
+            markDirty("team");
+            break;
+          }
+        case "team_done":
+          cancelFlush();
+          setTeamState(null);
+          accTextRef.current = "";
+          setStreamingText("");
+          break;
+        case "subagent_start":
+          subagentMap.set(event.id, {
+            type: event.agentType,
+            model: event.model,
+            description: event.description,
+            turn: 0,
+            message: "starting\u2026",
+            tools: [],
+            startTime: Date.now()
+          });
+          markDirty("subagents");
+          break;
+        case "subagent_progress":
+          {
+            const existing_2 = subagentMap.get(event.id);
+            if (existing_2) {
+              subagentMap.set(event.id, {
+                ...existing_2,
+                turn: event.turn || existing_2.turn,
+                message: event.message
+              });
+              markDirty("subagents");
             }
-            if (dirty.team) {
-                setTeamState({
-                    name: teamName, tasksCompleted: teamCompleted,
-                    tasksTotal: teamTotal, teammates: new Map(teammateStatus),
-                });
-                dirty.team = false;
+            break;
+          }
+        case "subagent_tool_start":
+          {
+            const existing_1 = subagentMap.get(event.agentId);
+            if (existing_1) {
+              subagentMap.set(event.agentId, {
+                ...existing_1,
+                tools: [...existing_1.tools, {
+                  name: event.toolName,
+                  status: "running",
+                  input: event.toolInput
+                }]
+              });
+              markDirty("subagents");
             }
-            if (dirty.subagents) {
-                setSubagentActivity(new Map(subagentMap));
-                if (pendingCompleted.length > 0) {
-                    const batch = pendingCompleted.splice(0);
-                    setCompletedSubagents(prev => [...prev, ...batch]);
+            break;
+          }
+        case "subagent_tool_end":
+          {
+            const existing_0 = subagentMap.get(event.agentId);
+            if (existing_0) {
+              const tools = [...existing_0.tools];
+              for (let i = tools.length - 1; i >= 0; i--) {
+                if (tools[i].name === event.toolName && tools[i].status === "running") {
+                  tools[i] = {
+                    ...tools[i],
+                    status: event.success ? "success" : "error",
+                    durationMs: event.durationMs
+                  };
+                  break;
                 }
-                dirty.subagents = false;
+              }
+              subagentMap.set(event.agentId, {
+                ...existing_0,
+                tools
+              });
+              markDirty("subagents");
             }
-            lastContentUpdateRef.current = Date.now();
-        }
-        const flushText = () => {
-            const text = accTextRef.current;
-            if (text.trim()) {
-                setMessages(prev => [...prev, { role: "assistant", text }]);
+            break;
+          }
+        case "subagent_done":
+          {
+            const existing = subagentMap.get(event.id);
+            subagentMap.delete(event.id);
+            if (existing) {
+              pendingCompleted.push({
+                id: event.id,
+                type: event.agentType,
+                description: existing.description || "",
+                toolCount: event.tools.length,
+                tokens: event.tokens,
+                durationMs: event.durationMs,
+                success: event.success
+              });
             }
-            accTextRef.current = "";
-            dirty.text = false;
-            setStreamingText("");
-        };
-        const emitter = new AgentEventEmitter();
-        // Team tracking
-        let teamName = "";
-        let teamTotal = 0;
-        let teamCompleted = 0;
-        const teammateStatus = new Map();
-        const unsub = emitter.onEvent((event) => {
-            switch (event.type) {
-                case "thinking":
-                    thinkingChunksRef.current = event.chunkCount;
-                    markDirty("text");
-                    break;
-                case "text":
-                    if (thinkingChunksRef.current > 0 && !thinkingDoneRef.current) {
-                        thinkingDoneRef.current = true;
-                        markDirty("text");
-                    }
-                    accTextRef.current += event.text;
-                    markDirty("text");
-                    break;
-                case "tool_output": {
-                    const idx = toolCalls.findIndex(t => t.name === event.toolName && t.status === "running");
-                    if (idx >= 0) {
-                        const prev = toolCalls[idx].result || "";
-                        const lines = (prev + "\n" + event.line).split("\n");
-                        toolCalls[idx].result = lines.slice(-4).join("\n").trim();
-                        markDirty("tools");
-                    }
-                    break;
-                }
-                case "tool_progress": {
-                    const idx = toolCalls.findIndex(t => t.name === event.toolName && t.status === "running");
-                    if (idx >= 0) {
-                        toolCalls[idx].progress = event.progress;
-                        markDirty("tools");
-                    }
-                    break;
-                }
-                case "team_start":
-                    teamName = event.name;
-                    teamTotal = event.taskCount;
-                    teamCompleted = 0;
-                    teammateStatus.clear();
-                    markDirty("team");
-                    break;
-                case "team_task":
-                    if (event.status === "started") {
-                        const existing = teammateStatus.get(event.teammateId);
-                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: event.taskDescription.slice(0, 50) });
-                    }
-                    else if (event.status === "completed") {
-                        teamCompleted++;
-                        const existing = teammateStatus.get(event.teammateId);
-                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: "done" });
-                    }
-                    else if (event.status === "failed") {
-                        // Task failed, but teammate is still alive — show the failure briefly
-                        // as progress, don't permanently mark the teammate as "failed".
-                        // The teammate will claim the next task or send "done" when finished.
-                        const existing = teammateStatus.get(event.teammateId);
-                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: "retrying…" });
-                    }
-                    markDirty("team");
-                    break;
-                case "team_progress":
-                    teammateStatus.set(event.teammateId, { name: event.teammateName || event.teammateId, status: event.message.slice(0, 50) });
-                    markDirty("team");
-                    break;
-                case "team_done":
-                    cancelFlush();
-                    setTeamState(null);
-                    accTextRef.current = "";
-                    setStreamingText("");
-                    break;
-                case "subagent_start":
-                    subagentMap.set(event.id, {
-                        type: event.agentType,
-                        model: event.model,
-                        description: event.description,
-                        turn: 0,
-                        message: "starting\u2026",
-                        tools: [],
-                        startTime: Date.now(),
-                    });
-                    markDirty("subagents");
-                    break;
-                case "subagent_progress": {
-                    const existing = subagentMap.get(event.id);
-                    if (existing) {
-                        subagentMap.set(event.id, {
-                            ...existing,
-                            turn: event.turn || existing.turn,
-                            message: event.message,
-                        });
-                        markDirty("subagents");
-                    }
-                    break;
-                }
-                case "subagent_tool_start": {
-                    const existing = subagentMap.get(event.agentId);
-                    if (existing) {
-                        subagentMap.set(event.agentId, {
-                            ...existing,
-                            tools: [...existing.tools, {
-                                    name: event.toolName,
-                                    status: "running",
-                                    input: event.toolInput,
-                                }],
-                        });
-                        markDirty("subagents");
-                    }
-                    break;
-                }
-                case "subagent_tool_end": {
-                    const existing = subagentMap.get(event.agentId);
-                    if (existing) {
-                        const tools = [...existing.tools];
-                        for (let i = tools.length - 1; i >= 0; i--) {
-                            if (tools[i].name === event.toolName && tools[i].status === "running") {
-                                tools[i] = { ...tools[i], status: event.success ? "success" : "error", durationMs: event.durationMs };
-                                break;
-                            }
-                        }
-                        subagentMap.set(event.agentId, { ...existing, tools });
-                        markDirty("subagents");
-                    }
-                    break;
-                }
-                case "subagent_done": {
-                    const existing = subagentMap.get(event.id);
-                    subagentMap.delete(event.id);
-                    if (existing) {
-                        pendingCompleted.push({
-                            id: event.id,
-                            type: event.agentType,
-                            description: existing.description || "",
-                            toolCount: event.tools.length,
-                            tokens: event.tokens,
-                            durationMs: event.durationMs,
-                            success: event.success,
-                        });
-                    }
-                    markDirty("subagents");
-                    break;
+            markDirty("subagents");
+            break;
+          }
+        case "done":
+          cancelFlush();
+          accTextRef.current = event.text;
+          break;
+      }
+    });
+    await runAgentLoop({
+      message: userMessage,
+      images: images?.map(img_0 => ({
+        base64: img_0.base64,
+        mediaType: img_0.mediaType
+      })),
+      conversationHistory: conversationRef.current,
+      abortSignal: abort.signal,
+      emitter,
+      thinking: thinkingEnabled,
+      callbacks: {
+        onText: () => {},
+        onToolStart: (name, input) => {
+          if (input) {
+            // Update existing running tool with input, or create it if missing
+            const idx_1 = toolCalls.findIndex(t_1 => t_1.name === name && t_1.status === "running" && !t_1.input);
+            if (idx_1 >= 0) {
+              toolCalls[idx_1].input = input;
+            } else {
+              // dispatchTools.onStart fires with input directly — add the tool now.
+              // Don't flushText() here — text was already flushed by the streaming
+              // parser's tool_use transition before dispatchTools executes.
+              toolCalls.push({
+                name,
+                status: "running",
+                input
+              });
+            }
+            setActiveTools([...toolCalls]);
+            lastContentUpdateRef.current = Date.now();
+            return;
+          }
+          flushText();
+          toolCalls.push({
+            name,
+            status: "running"
+          });
+          setActiveTools([...toolCalls]);
+          lastContentUpdateRef.current = Date.now();
+        },
+        onToolResult: (name_0, success, result, input_0, durationMs) => {
+          dirty.tools = false;
+          const completedTool = {
+            name: name_0,
+            status: success ? "success" : "error",
+            result: typeof result === "string" ? result : JSON.stringify(result),
+            input: input_0,
+            durationMs
+          };
+          const idx_2 = toolCalls.findIndex(t_2 => t_2.name === name_0 && t_2.status === "running");
+          if (idx_2 >= 0) toolCalls.splice(idx_2, 1);
+
+          // Track file changes for rewind
+          if (success && input_0) {
+            const FILE_TOOLS = ["write_file", "edit_file", "multi_edit"];
+            if (FILE_TOOLS.includes(name_0)) {
+              try {
+                const filePath = input_0.file_path;
+                if (filePath) {
+                  // Find the most recent backup for this file from file-history
+                  const backups = listBackups();
+                  const fileName = filePath.split("/").pop() || "";
+                  const backup = backups.find(b => b.name.endsWith(`-${fileName}`));
+                  const isNewFile = !backup; // No backup means file didn't exist before
+                  const op = name_0 === "write_file" ? "write" : name_0 === "edit_file" ? "edit" : "multi_edit";
+                  rewindManagerRef.current.trackFileChange({
+                    filePath,
+                    backupPath: backup?.path || "",
+                    operation: op,
+                    isNewFile
+                  });
                 }
-                case "done":
-                    cancelFlush();
-                    accTextRef.current = event.text;
-                    break;
+              } catch {
+                // Best effort — don't fail the actual operation
+              }
             }
-        });
-        await runAgentLoop({
-            message: userMessage,
-            images: images?.map(img => ({ base64: img.base64, mediaType: img.mediaType })),
-            conversationHistory: conversationRef.current,
-            abortSignal: abort.signal,
-            emitter,
-            thinking: thinkingEnabled,
-            callbacks: {
-                onText: () => { },
-                onToolStart: (name, input) => {
-                    if (input) {
-                        const idx = toolCalls.findIndex(t => t.name === name && t.status === "running" && !t.input);
-                        if (idx >= 0) {
-                            toolCalls[idx].input = input;
-                            setActiveTools([...toolCalls]);
-                            lastContentUpdateRef.current = Date.now();
-                        }
-                        return;
-                    }
-                    flushText();
-                    toolCalls.push({ name, status: "running" });
-                    setActiveTools([...toolCalls]);
-                    lastContentUpdateRef.current = Date.now();
-                },
-                onToolResult: (name, success, result, input, durationMs) => {
-                    cancelFlush();
-                    dirty.tools = false;
-                    const completedTool = {
-                        name,
-                        status: success ? "success" : "error",
-                        result: typeof result === "string" ? result : JSON.stringify(result),
-                        input,
-                        durationMs,
-                    };
-                    const idx = toolCalls.findIndex((t) => t.name === name && t.status === "running");
-                    if (idx >= 0)
-                        toolCalls.splice(idx, 1);
-                    // Track file changes for rewind
-                    if (success && input) {
-                        const FILE_TOOLS = ["write_file", "edit_file", "multi_edit"];
-                        if (FILE_TOOLS.includes(name)) {
-                            try {
-                                const filePath = input.file_path;
-                                if (filePath) {
-                                    // Find the most recent backup for this file from file-history
-                                    const backups = listBackups();
-                                    const fileName = filePath.split("/").pop() || "";
-                                    const backup = backups.find(b => b.name.endsWith(`-${fileName}`));
-                                    const isNewFile = !backup; // No backup means file didn't exist before
-                                    const op = name === "write_file" ? "write"
-                                        : name === "edit_file" ? "edit"
-                                            : "multi_edit";
-                                    rewindManagerRef.current.trackFileChange({
-                                        filePath,
-                                        backupPath: backup?.path || "",
-                                        operation: op,
-                                        isNewFile,
-                                    });
-                                }
-                            }
-                            catch {
-                                // Best effort — don't fail the actual operation
-                            }
-                        }
-                    }
-                    // Each tool result is its own message — goes to Static immediately.
-                    // (Don't batch into the last message — Static can't re-render updated items.)
-                    setMessages(prev => [...prev, { role: "assistant", text: "", toolCalls: [completedTool] }]);
-                    setActiveTools([...toolCalls]);
-                    accTextRef.current = "";
-                    setStreamingText("");
-                    lastContentUpdateRef.current = Date.now();
-                },
-                onUsage: (input_tokens, output_tokens, thinking_tokens, model, costUsd, cacheReadTokens, cacheCreationTokens) => {
-                    usage = { input_tokens, output_tokens, thinking_tokens, model, costUsd, cache_read_tokens: cacheReadTokens, cache_creation_tokens: cacheCreationTokens };
-                },
-                onAutoCompact: (before, after, tokensSaved) => {
-                    setMessages((prev) => [...prev, {
-                            role: "assistant",
-                            text: `  Context auto-compacted: ${before} messages -> ${after} messages (~${(tokensSaved / 1000).toFixed(0)}K tokens freed)`,
-                        }]);
-                },
-                onDone: (finalMessages) => {
-                    unsub();
-                    emitter.destroy();
-                    cancelFlush();
-                    setStreamingText("");
-                    setCompletedSubagents(prevCompleted => {
-                        // Include any pending completed subagents from the batch
-                        const all = [...prevCompleted, ...pendingCompleted.splice(0)];
-                        if (all.length > 0) {
-                            setMessages(prev => [...prev, {
-                                    role: "assistant",
-                                    text: "",
-                                    completedSubagents: all,
-                                }]);
-                        }
-                        return [];
-                    });
-                    const finalText = accTextRef.current;
-                    if (finalText.trim() || usage) {
-                        setMessages((prev) => [...prev, {
-                                role: "assistant",
-                                text: finalText,
-                                usage,
-                            }]);
-                    }
-                    // Record rewind checkpoint for this turn
-                    setMessages(prev => {
-                        const fileChanges = rewindManagerRef.current.getCurrentFileChanges();
-                        const summary = finalText.trim() || "(tool-only turn)";
-                        rewindManagerRef.current.addCheckpoint(turnIndexRef.current, prev.length, summary, fileChanges);
-                        rewindManagerRef.current.commitTurn();
-                        turnIndexRef.current++;
-                        return prev;
-                    });
-                    setStreamingText("");
-                    setActiveTools([]);
-                    setSubagentActivity(new Map());
-                    setTeamState(null);
-                    setIsStreaming(false);
-                    abortRef.current = null;
-                    conversationRef.current = finalMessages;
-                },
-                onError: (err, partialMessages) => {
-                    unsub();
-                    emitter.destroy();
-                    cancelFlush();
-                    if (err !== "Cancelled") {
-                        setMessages((prev) => [...prev, { role: "assistant", text: `\x1b[31m\u2718 Error: ${err}\x1b[0m` }]);
-                    }
-                    setStreamingText("");
-                    setActiveTools([]);
-                    setSubagentActivity(new Map());
-                    setCompletedSubagents([]);
-                    setTeamState(null);
-                    setIsStreaming(false);
-                    abortRef.current = null;
-                    if (partialMessages && partialMessages.length > 0) {
-                        conversationRef.current = partialMessages;
-                    }
-                },
-            },
-        });
-    }, [isStreaming, thinkingEnabled]);
-    return { handleSend };
+          }
+
+          // Batch tool result messages — flushed via the 100ms dirty timer.
+          // This prevents 9 parallel failures from causing 9 separate Ink render
+          // cycles, which triggers fullscreen repaints and flickering.
+          pendingToolMsgs.push({
+            role: "assistant",
+            text: "",
+            toolCalls: [completedTool]
+          });
+          markDirty("messages");
+          setActiveTools([...toolCalls]);
+          accTextRef.current = "";
+          setStreamingText("");
+          lastContentUpdateRef.current = Date.now();
+        },
+        onUsage: (input_tokens, output_tokens, thinking_tokens, model, costUsd, cacheReadTokens, cacheCreationTokens) => {
+          usage = {
+            input_tokens,
+            output_tokens,
+            thinking_tokens,
+            model,
+            costUsd,
+            cache_read_tokens: cacheReadTokens,
+            cache_creation_tokens: cacheCreationTokens
+          };
+        },
+        onAutoCompact: (before, after, tokensSaved) => {
+          setMessages(prev_4 => [...prev_4, {
+            role: "assistant",
+            text: `  Context auto-compacted: ${before} messages -> ${after} messages (~${(tokensSaved / 1000).toFixed(0)}K tokens freed)`
+          }]);
+        },
+        onDone: finalMessages => {
+          unsub();
+          emitter.destroy();
+          cancelFlush();
+          // Flush any batched tool result messages before final message
+          if (pendingToolMsgs.length > 0) {
+            const batch_1 = pendingToolMsgs.splice(0);
+            setMessages(prev_5 => [...prev_5, ...batch_1]);
+          }
+          setStreamingText("");
+          setCompletedSubagents(prevCompleted => {
+            // Include any pending completed subagents from the batch
+            const all = [...prevCompleted, ...pendingCompleted.splice(0)];
+            if (all.length > 0) {
+              setMessages(prev_6 => [...prev_6, {
+                role: "assistant",
+                text: "",
+                completedSubagents: all
+              }]);
+            }
+            return [];
+          });
+          const finalText = accTextRef.current;
+          if (finalText.trim() || usage) {
+            setMessages(prev_7 => [...prev_7, {
+              role: "assistant",
+              text: finalText,
+              usage
+            }]);
+          }
+
+          // Record rewind checkpoint for this turn
+          setMessages(prev_8 => {
+            const fileChanges = rewindManagerRef.current.getCurrentFileChanges();
+            const summary = finalText.trim() || "(tool-only turn)";
+            rewindManagerRef.current.addCheckpoint(turnIndexRef.current, prev_8.length, summary, fileChanges);
+            rewindManagerRef.current.commitTurn();
+            turnIndexRef.current++;
+            return prev_8;
+          });
+          setStreamingText("");
+          setActiveTools([]);
+          setSubagentActivity(new Map());
+          setTeamState(null);
+          setIsStreaming(false);
+          abortRef.current = null;
+          conversationRef.current = finalMessages;
+        },
+        onError: (err, partialMessages) => {
+          unsub();
+          emitter.destroy();
+          cancelFlush();
+          // Flush any batched tool result messages before error message
+          if (pendingToolMsgs.length > 0) {
+            const batch_2 = pendingToolMsgs.splice(0);
+            setMessages(prev_9 => [...prev_9, ...batch_2]);
+          }
+          if (err !== "Cancelled") {
+            setMessages(prev_10 => [...prev_10, {
+              role: "assistant",
+              text: `\x1b[31m\u2718 Error: ${err}\x1b[0m`
+            }]);
+          }
+          setStreamingText("");
+          setActiveTools([]);
+          setSubagentActivity(new Map());
+          setCompletedSubagents([]);
+          setTeamState(null);
+          setIsStreaming(false);
+          abortRef.current = null;
+          if (partialMessages && partialMessages.length > 0) {
+            conversationRef.current = partialMessages;
+          }
+        }
+      }
+    });
+  };
+  return {
+    handleSend
+  };
 }
+//# sourceMappingURL=useAgentLoop.js.map