jinzd-ai-cli 0.4.186 → 0.4.188

package/dist/{run-tests-625NA546.js → run-tests-IJYP6BMT.js}

@@ -1,7 +1,7 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-7HMX2MTY.js";
+} from "./chunk-ODAAPNSL.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   executeTests,

package/dist/{run-tests-CRVIUT4O.js → run-tests-NS3SPH6S.js}

@@ -2,8 +2,8 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-2CLMIRKL.js";
-import "./chunk-MIXN7VBY.js";
+} from "./chunk-NRSAAMIF.js";
+import "./chunk-UK6E2563.js";
 import "./chunk-PDX44BCA.js";
 export {
   executeTests,

package/dist/{server-Q3A737OP.js → server-SVTSJ3PK.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   ToolRegistry
-} from "./chunk-JBTVDYJM.js";
+} from "./chunk-J3XSJCO5.js";
 import "./chunk-HDSKW7Q3.js";
 import "./chunk-ZWVIDFGY.js";
-import "./chunk-2CLMIRKL.js";
+import "./chunk-NRSAAMIF.js";
 import {
   runTool
-} from "./chunk-V7NTQ6UB.js";
+} from "./chunk-DFQSQQEU.js";
 import {
   getDangerLevel,
   schemaToJsonSchema
@@ -15,9 +15,9 @@ import {
 import "./chunk-TZQHYZKT.js";
 import {
   VERSION
-} from "./chunk-MIXN7VBY.js";
+} from "./chunk-UK6E2563.js";
 import "./chunk-4BKXL7SM.js";
-import "./chunk-MM3F43H6.js";
+import "./chunk-4UZE4ADL.js";
 import "./chunk-KHYD3WXE.js";
 import "./chunk-SLSWPBK3.js";
 import "./chunk-VNNYHW6N.js";

package/dist/{server-O6ZMNWNS.js → server-TZRMRT3O.js}

@@ -19,7 +19,7 @@ import {
   loadDevState,
   persistToolRound,
   setupProxy
-} from "./chunk-OFP5BE7H.js";
+} from "./chunk-VPTRE7IW.js";
 import {
   ToolExecutor,
   ToolRegistry,
@@ -37,10 +37,10 @@ import {
   spawnAgentContext,
   truncateOutput,
   undoStack
-} from "./chunk-JBTVDYJM.js";
+} from "./chunk-J3XSJCO5.js";
 import "./chunk-HDSKW7Q3.js";
 import "./chunk-ZWVIDFGY.js";
-import "./chunk-2CLMIRKL.js";
+import "./chunk-NRSAAMIF.js";
 import {
   SessionManager,
   getContentText
@@ -50,39 +50,28 @@ import {
   formatCost
 } from "./chunk-V37XOYOE.js";
 import {
-  BudgetWarner,
   CONTENT_ONLY_STREAM_REMINDER,
-  ContextPressureMonitor,
-  EmptyResponseGuard,
-  FreeRoundTracker,
-  HALLUCINATION_CORRECTION_MESSAGE,
   ProviderRegistry,
   TEE_FINAL_USER_NUDGE,
   TOOL_CALL_REMINDER,
-  accumulateUsage,
   buildRoundBudgetHint,
-  buildRoundsExhaustedPrompt,
-  buildUserStopMessage,
   consumeToolCallStream,
   detectMetaNarration,
   detectPseudoToolCalls,
-  detectsHallucinatedFileOp,
-  extractBashCommands,
-  hadPreviousWriteToolCalls,
   looksLikeDocumentBody,
+  runAgentLoop,
   stripPseudoToolCalls,
-  stripToolCallReminder,
-  summarizeRecentTools
-} from "./chunk-RADH6ECW.js";
+  stripToolCallReminder
+} from "./chunk-IQ7JE43O.js";
 import {
   runTool
-} from "./chunk-V7NTQ6UB.js";
+} from "./chunk-DFQSQQEU.js";
 import {
   getDangerLevel
 } from "./chunk-HIU2SH4V.js";
 import {
   ConfigManager
-} from "./chunk-KNGDSMMF.js";
+} from "./chunk-Q7SB3R25.js";
 import "./chunk-TZQHYZKT.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
@@ -102,14 +91,14 @@ import {
   SKILLS_DIR_NAME,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-MIXN7VBY.js";
+} from "./chunk-UK6E2563.js";
 import {
   formatGitContextForPrompt,
   getGitContext,
   getGitRoot
 } from "./chunk-HOSJZMQS.js";
 import "./chunk-4BKXL7SM.js";
-import "./chunk-MM3F43H6.js";
+import "./chunk-4UZE4ADL.js";
 import "./chunk-KHYD3WXE.js";
 import "./chunk-SLSWPBK3.js";
 import "./chunk-VNNYHW6N.js";
@@ -1007,7 +996,6 @@ var SessionHandler = class _SessionHandler {
   async handleChatWithTools(provider, messages, toolDefs, mcpBudgetNote) {
     const session = this.sessions.current;
     const apiMessages = [...messages];
-    const extraMessages = [];
     const maxToolRounds = this.config.get("maxToolRounds") ?? DEFAULT_MAX_TOOL_ROUNDS;
     const autoPauseIntervalRaw = this.config.get("autoPauseInterval");
     const autoPauseInterval = typeof autoPauseIntervalRaw === "number" ? autoPauseIntervalRaw : 50;
@@ -1018,37 +1006,113 @@ var SessionHandler = class _SessionHandler {
 ${mcpBudgetNote}` : "");
     const systemPromptVolatile = toolVolatile;
     const modelParams = this.getModelParams();
-    const roundUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+    const usage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
     const supportsStreamingTools = typeof provider.chatWithToolsStream === "function";
-    const roundToolHistory = [];
-    const budgetWarner = new BudgetWarner(maxToolRounds);
-    const emptyGuard = new EmptyResponseGuard();
-    const ctxMonitor = new ContextPressureMonitor();
-    const freeRounds = new FreeRoundTracker();
     const ac = new AbortController();
     this.abortController = ac;
     try {
-      for (let round = 0; round < maxToolRounds; round++) {
-        if (ac.signal.aborted) break;
-        this.toolExecutor.setRoundInfo(round + 1, maxToolRounds);
-        this.send({ type: "round_progress", current: round + 1, total: maxToolRounds });
-        const budgetWarning = budgetWarner.check(maxToolRounds - round);
-        if (budgetWarning) {
-          extraMessages.push({ role: "user", content: budgetWarning.injectMessage });
-          if (budgetWarning.displayMessage) {
-            this.send({ type: "info", message: budgetWarning.displayMessage });
-          }
-        }
-        if (this.userInterjection) {
+      const loopResult = await runAgentLoop({
+        maxToolRounds,
+        autoPauseInterval,
+        planMode: this.planMode,
+        providerId: this.currentProvider,
+        toolDefs,
+        signal: ac.signal,
+        usage,
+        callModel: async (_round, extraMessages) => {
+          const chatRequest = {
+            messages: apiMessages,
+            model: this.currentModel,
+            systemPrompt,
+            systemPromptVolatile,
+            stream: false,
+            temperature: modelParams.temperature,
+            maxTokens: modelParams.maxTokens,
+            timeout: modelParams.timeout,
+            thinking: modelParams.thinking,
+            thinkingBudget: modelParams.thinkingBudget,
+            signal: ac.signal,
+            ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+          };
+          try {
+            if (supportsStreamingTools) {
+              const streamGen = provider.chatWithToolsStream(chatRequest, toolDefs);
+              return await this.consumeToolStream(streamGen, ac);
+            }
+            const result = await provider.chatWithTools(chatRequest, toolDefs);
+            return result;
+          } catch (providerErr) {
+            const errMsg = providerErr instanceof Error ? providerErr.message : String(providerErr);
+            const isCtxLengthError = /maximum context length|context_length_exceeded|context window|too many tokens|reduce the length of the messages/i.test(errMsg);
+            if (isCtxLengthError) {
+              this.send({
+                type: "response_done",
+                content: `\u26A0 Context length exceeded \u2014 the conversation is too long for this model.
+
+Details: ${errMsg.split("\n")[0]}
+
+**Recovery options**:
+1. Run \`/compact\` to summarize old messages and free context
+2. Run \`/clear\` to start a fresh session
+3. Run \`/model\` to switch to a model with a larger context window`,
+                usage
+              });
+              return { stopLoop: true };
+            }
+            throw providerErr;
+          }
+        },
+        callSummary: async (summaryExtra) => {
+          const summaryResult = await provider.chatWithTools(
+            {
+              messages: apiMessages,
+              model: this.currentModel,
+              systemPrompt,
+              systemPromptVolatile,
+              stream: false,
+              temperature: modelParams.temperature,
+              maxTokens: modelParams.maxTokens,
+              timeout: modelParams.timeout,
+              _extraMessages: summaryExtra
+            },
+            []
+          );
+          return "content" in summaryResult ? { content: summaryResult.content, usage: summaryResult.usage } : { usage: summaryResult.usage };
+        },
+        executeTools: async (toolCalls) => {
+          googleSearchContext.configManager = this.config;
+          spawnAgentContext.provider = provider;
+          spawnAgentContext.model = this.currentModel;
+          spawnAgentContext.systemPrompt = systemPromptVolatile ? `${systemPrompt}
+
+---
+
+${systemPromptVolatile}` : systemPrompt;
+          spawnAgentContext.modelParams = modelParams;
+          spawnAgentContext.configManager = this.config;
+          ToolExecutor.currentMessageIndex = this.sessions.current?.messages.length ?? 0;
+          return this.toolExecutor.executeAll(toolCalls);
+        },
+        buildToolResultMessages: (toolCalls, results, reasoningContent) => provider.buildToolResultMessages(toolCalls, results, reasoningContent),
+        getContextWindow: () => this.getContextWindowSize(),
+        estimateRequestTokens: (extraMessages) => this.estimateRequestTokens(systemPrompt, extraMessages),
+        pollInterjection: () => {
+          if (!this.userInterjection) return null;
           const msg = this.userInterjection;
           this.userInterjection = null;
           this.send({ type: "info", message: `\u26A1 Interjection: "${msg}"` });
-          extraMessages.push({ role: "user", content: msg });
-        }
-        const ctxWindow = this.getContextWindowSize();
-        if (ctxWindow > 0) {
-          const reqTokens = this.estimateRequestTokens(systemPrompt, extraMessages);
-          const pressure = ctxMonitor.check(reqTokens, ctxWindow);
+          return msg;
+        },
+        onRoundStart: (round, total) => {
+          this.toolExecutor.setRoundInfo(round + 1, total);
+          this.send({ type: "round_progress", current: round + 1, total });
+        },
+        onBudgetWarning: (warning) => {
+          if (warning.displayMessage) {
+            this.send({ type: "info", message: warning.displayMessage });
+          }
+        },
+        onContextPressure: (pressure, ctxWindow) => {
           if (pressure.action === "abort") {
             this.send({
               type: "response_done",
@@ -1060,191 +1124,48 @@ Too much tool output accumulated this turn. Your work so far is preserved.
 1. Run \`/compact\` to shrink history, then ask the AI to continue
 2. Run \`/clear\` to start fresh
 3. Switch to a larger-context model`,
-              usage: roundUsage
+              usage
             });
-            this.addWebSessionUsage(roundUsage);
-            session.addTokenUsage(roundUsage);
-            return;
-          } else if (pressure.action === "warn") {
+          } else {
             this.send({
               type: "info",
               message: `\u26A0 Context at ${Math.round(pressure.ratio * 100)}% \u2014 asking AI to wrap up`
             });
-            extraMessages.push({ role: "user", content: pressure.injectMessage });
-          }
-        }
-        const chatRequest = {
-          messages: apiMessages,
-          model: this.currentModel,
-          systemPrompt,
-          systemPromptVolatile,
-          stream: false,
-          temperature: modelParams.temperature,
-          maxTokens: modelParams.maxTokens,
-          timeout: modelParams.timeout,
-          thinking: modelParams.thinking,
-          thinkingBudget: modelParams.thinkingBudget,
-          signal: ac.signal,
-          ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
-        };
-        let result;
-        try {
-          if (supportsStreamingTools) {
-            const streamGen = provider.chatWithToolsStream(chatRequest, toolDefs);
-            result = await this.consumeToolStream(streamGen, ac);
-          } else {
-            result = await provider.chatWithTools(chatRequest, toolDefs);
           }
-        } catch (providerErr) {
-          const errMsg = providerErr instanceof Error ? providerErr.message : String(providerErr);
-          const isCtxLengthError = /maximum context length|context_length_exceeded|context window|too many tokens|reduce the length of the messages/i.test(errMsg);
-          if (isCtxLengthError) {
-            this.send({
-              type: "response_done",
-              content: `\u26A0 Context length exceeded \u2014 the conversation is too long for this model.
-
-Details: ${errMsg.split("\n")[0]}
-
-**Recovery options**:
-1. Run \`/compact\` to summarize old messages and free context
-2. Run \`/clear\` to start a fresh session
-3. Run \`/model\` to switch to a model with a larger context window`,
-              usage: roundUsage
-            });
-            this.addWebSessionUsage(roundUsage);
-            session.addTokenUsage(roundUsage);
-            return;
-          }
-          throw providerErr;
-        }
-        if (ac.signal.aborted) break;
-        accumulateUsage(roundUsage, result.usage);
-        const hasToolCalls = !!(result.toolCalls && result.toolCalls.length > 0);
-        const contentBlank = !result.content || result.content.trim() === "";
-        if (!hasToolCalls && contentBlank) {
-          const decision = emptyGuard.onEmpty(round < maxToolRounds - 1, result.finishReason);
+        },
+        onHallucinationRetry: ({ phantomPaths }) => {
+          const detail = phantomPaths.length > 0 ? ` (phantom files: ${phantomPaths.join(", ")})` : "";
+          this.send({ type: "info", message: `\u26A0 Hallucinated completion detected, forcing retry...${detail}` });
+        },
+        onEmptyResponse: (decision) => {
           if (decision.action === "nudge") {
             this.send({ type: "info", message: decision.displayMessage });
-            extraMessages.push({ role: "user", content: decision.injectMessage });
-            continue;
-          }
-          this.send({
-            type: "response_done",
-            content: `${decision.displayMessage}
+          } else {
+            this.send({
+              type: "response_done",
+              content: `${decision.displayMessage}
 
 ${decision.hint}
 Try: /compact to reduce context, /clear to reset, or switch to a larger-context model.`,
-            usage: roundUsage
-          });
-          this.addWebSessionUsage(roundUsage);
-          session.addTokenUsage(roundUsage);
-          return;
-        }
-        emptyGuard.onNonEmpty();
-        if (result.content && !result.toolCalls) {
-          const hasWriteTools = toolDefs.some((t) => t.name === "write_file" || t.name === "edit_file");
-          const alreadyWrote = hadPreviousWriteToolCalls(extraMessages);
-          const bashRanThisTurn = extractBashCommands(extraMessages).length > 0;
-          if (hasWriteTools && !alreadyWrote && !bashRanThisTurn && detectsHallucinatedFileOp(result.content) && round < maxToolRounds - 1) {
-            this.send({ type: "info", message: "\u26A0 Hallucinated completion detected, forcing retry..." });
-            const reasoningField = result.reasoningContent ? { reasoning_content: result.reasoningContent } : this.currentProvider === "deepseek" ? { reasoning_content: "" } : {};
-            extraMessages.push(
-              { role: "assistant", content: result.content, ...reasoningField },
-              { role: "user", content: HALLUCINATION_CORRECTION_MESSAGE }
-            );
-            continue;
-          }
-          this.send({ type: "response_done", content: result.content, usage: roundUsage });
+              usage
+            });
+          }
+        },
+        onFinalContent: (content, { reasoningContent }) => {
+          this.send({ type: "response_done", content, usage });
           session.addMessage({
             role: "assistant",
-            content: result.content,
+            content,
             timestamp: /* @__PURE__ */ new Date(),
-            ...result.reasoningContent ? { reasoningContent: result.reasoningContent } : {}
+            ...reasoningContent ? { reasoningContent } : {}
           });
-          this.addWebSessionUsage(roundUsage);
-          session.addTokenUsage(roundUsage);
-          return;
-        }
-        if (result.toolCalls && result.toolCalls.length > 0) {
-          roundToolHistory.push({
-            round: round + 1,
-            tools: result.toolCalls.map((tc) => tc.name)
-          });
-          for (const tc of result.toolCalls) {
-            if (tc.name.startsWith("mcp__")) this.usedMcpToolNames.add(tc.name);
-          }
-          googleSearchContext.configManager = this.config;
-          spawnAgentContext.provider = provider;
-          spawnAgentContext.model = this.currentModel;
-          spawnAgentContext.systemPrompt = systemPromptVolatile ? `${systemPrompt}
-
----
-
-${systemPromptVolatile}` : systemPrompt;
-          spawnAgentContext.modelParams = modelParams;
-          spawnAgentContext.configManager = this.config;
-          ToolExecutor.currentMessageIndex = this.sessions.current?.messages.length ?? 0;
-          const saveLastResponseCall = result.toolCalls.find((tc) => tc.name === "save_last_response");
-          const saveLastResponsePath = saveLastResponseCall ? String(saveLastResponseCall.arguments["path"] ?? "") : "";
-          if (saveLastResponseCall && saveLastResponsePath) {
-            const teeResult = await this.runSaveLastResponseTee(
-              provider,
-              saveLastResponseCall,
-              saveLastResponsePath,
-              apiMessages,
-              extraMessages,
-              systemPrompt,
-              systemPromptVolatile,
-              modelParams,
-              ac,
-              roundUsage
-            );
-            const teeToolResults = result.toolCalls.map((tc) => {
-              if (tc.id === saveLastResponseCall.id) {
-                return {
-                  callId: tc.id,
-                  content: teeResult.summary,
-                  isError: teeResult.isError
-                };
-              }
-              return {
-                callId: tc.id,
-                content: "[skipped: file already saved by tee streaming]",
-                isError: false
-              };
-            });
-            const reasoningContent2 = result.reasoningContent;
-            const newMsgs2 = provider.buildToolResultMessages(result.toolCalls, teeToolResults, reasoningContent2);
-            extraMessages.push(...newMsgs2);
-            persistToolRound(session, result.toolCalls, teeToolResults, {
-              assistantContent: teeResult.content,
-              reasoningContent: reasoningContent2
-            });
-            freeRounds.apply(result.toolCalls.map((tc) => tc.name));
-            continue;
-          }
-          const toolResults = await this.toolExecutor.executeAll(result.toolCalls);
-          const reasoningContent = result.reasoningContent;
-          const newMsgs = provider.buildToolResultMessages(result.toolCalls, toolResults, reasoningContent);
-          extraMessages.push(...newMsgs);
-          persistToolRound(session, result.toolCalls, toolResults, {
-            assistantContent: result.content,
-            reasoningContent
-          });
-          if (freeRounds.apply(result.toolCalls.map((tc) => tc.name))) {
-            round--;
-          }
-          if (this.userInterjection) {
-            const msg = this.userInterjection;
-            this.userInterjection = null;
-            this.send({ type: "info", message: `\u26A1 Interjection: "${msg}"` });
-            extraMessages.push({ role: "user", content: msg });
-          }
-        }
-        const effectiveRound = round + 1;
-        const remaining = maxToolRounds - effectiveRound;
-        if (autoPauseInterval > 0 && effectiveRound > 0 && effectiveRound % autoPauseInterval === 0 && remaining > 0 && !ac.signal.aborted) {
-          const toolSummary = summarizeRecentTools(roundToolHistory, autoPauseInterval);
+        },
+        persistRound: (toolCalls, results, info) => {
+          persistToolRound(session, toolCalls, results, info);
+        },
+        // Track MCP tool usage for next-turn budget prioritization (C1)
+        onMcpToolUsed: (name) => this.usedMcpToolNames.add(name),
+        requestAutoPause: async ({ effectiveRound, maxToolRounds: totalRounds, toolSummary }) => {
           const requestId = `pause_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           const pauseResp = await new Promise((resolve3) => {
             this.pendingAutoPause.set(requestId, resolve3);
@@ -1252,58 +1173,85 @@ ${systemPromptVolatile}` : systemPrompt;
               type: "auto_pause_request",
               requestId,
               currentRound: effectiveRound,
-              totalRounds: maxToolRounds,
+              totalRounds,
               toolSummary
             });
           });
-          if (ac.signal.aborted) break;
           if (pauseResp.action === "stop") {
-            this.send({ type: "info", message: `\u23F8  Stopped by user at ${effectiveRound}/${maxToolRounds}` });
-            extraMessages.push({ role: "user", content: buildUserStopMessage(effectiveRound, maxToolRounds) });
-            break;
+            this.send({ type: "info", message: `\u23F8  Stopped by user at ${effectiveRound}/${totalRounds}` });
           } else if (pauseResp.action === "redirect" && pauseResp.message) {
             this.send({ type: "info", message: `\u26A1 Redirect: "${pauseResp.message}"` });
-            extraMessages.push({ role: "user", content: pauseResp.message });
           }
-        }
-      }
-      try {
-        const summaryExtra = [
-          ...extraMessages,
-          { role: "user", content: buildRoundsExhaustedPrompt(maxToolRounds) }
-        ];
-        const summaryResult = await provider.chatWithTools(
-          {
-            messages: apiMessages,
-            model: this.currentModel,
+          return pauseResp;
+        },
+        onRoundsExhausted: (summaryContent) => {
+          if (summaryContent !== null) {
+            this.send({
+              type: "response_done",
+              content: `\u26A0 Reached maximum tool call rounds (${maxToolRounds}).
+
+${summaryContent}`,
+              usage
+            });
+            session.addMessage({ role: "assistant", content: summaryContent, timestamp: /* @__PURE__ */ new Date() });
+          } else {
+            this.send({
+              type: "error",
+              message: `Reached maximum tool call rounds (${maxToolRounds}). You can continue by asking the AI to proceed.`
+            });
+          }
+        },
+        // ─── save_last_response tee-streaming（v0.4.102+）─────────────────
+        // AI 在 Web 模式下调用 save_last_response 时，复刻 REPL 的 tee 流式路径：
+        // 发起一次新的 chatStream → 实时通过 WS 推送文本 + 同步写盘 → 注入合成
+        // 工具结果。否则该工具会落到默认 executor，读到空的 lastResponseStore
+        // 直接报错；用户被迫退到 write_file，又因 tool_call arguments 截断
+        // (~2KB) 只能写出片段，再用 edit_file 反复 insert 才能补全（v0.4.101 报告）。
+        // 与 REPL 不同：Web 端 tee 成功后继续 agentic 循环（返回 'continue'），
+        // 让模型基于工具结果给出最终文本。
+        runSaveLastResponseTee: async ({ toolCalls, call, saveToFile, extraMessages, reasoningContent }) => {
+          const teeResult = await this.runSaveLastResponseTee(
+            provider,
+            call,
+            saveToFile,
+            apiMessages,
+            extraMessages,
             systemPrompt,
             systemPromptVolatile,
-            stream: false,
-            temperature: modelParams.temperature,
-            maxTokens: modelParams.maxTokens,
-            timeout: modelParams.timeout,
-            _extraMessages: summaryExtra
-          },
-          []
-        );
-        if ("content" in summaryResult && summaryResult.content) {
-          this.send({
-            type: "response_done",
-            content: `\u26A0 Reached maximum tool call rounds (${maxToolRounds}).
-
-${summaryResult.content}`,
-            usage: roundUsage
+            modelParams,
+            ac,
+            usage
+          );
+          const teeToolResults = toolCalls.map((tc) => {
+            if (tc.id === call.id) {
+              return {
+                callId: tc.id,
+                content: teeResult.summary,
+                isError: teeResult.isError
+              };
+            }
+            return {
+              callId: tc.id,
+              content: "[skipped: file already saved by tee streaming]",
+              isError: false
+            };
+          });
+          const newMsgs = provider.buildToolResultMessages(toolCalls, teeToolResults, reasoningContent);
+          extraMessages.push(...newMsgs);
+          persistToolRound(session, toolCalls, teeToolResults, {
+            assistantContent: teeResult.content,
+            reasoningContent
           });
-          session.addMessage({ role: "assistant", content: summaryResult.content, timestamp: /* @__PURE__ */ new Date() });
+          return "continue";
         }
-      } catch {
-        this.send({
-          type: "error",
-          message: `Reached maximum tool call rounds (${maxToolRounds}). You can continue by asking the AI to proceed.`
-        });
+      });
+      if (loopResult.reason !== "tee-stop") {
+        this.addWebSessionUsage(usage);
+        session.addTokenUsage(usage);
+      }
+      if (loopResult.reason === "aborted") {
+        this.send({ type: "info", message: "[interrupted]" });
       }
-      this.addWebSessionUsage(roundUsage);
-      session.addTokenUsage(roundUsage);
     } catch (err) {
       if (err.name === "AbortError") {
         this.send({ type: "info", message: "[interrupted]" });
@@ -2489,7 +2437,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-CRVIUT4O.js");
+          const { executeTests } = await import("./run-tests-NS3SPH6S.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -3013,7 +2961,7 @@ Add .md files to create commands.` });
       return;
     }
     try {
-      const { searchChatMemory, loadChatIndex } = await import("./chat-index-2I7ZHRE5.js");
+      const { searchChatMemory, loadChatIndex } = await import("./chat-index-JXTYDRCY.js");
       const loaded = loadChatIndex();
       if (!loaded || loaded.idx.chunks.length === 0) {
         this.send({ type: "memory_hits", query: q, hits: [], indexMissing: true });
@@ -3049,7 +2997,7 @@ Add .md files to create commands.` });
   }
   async handleMemoryStatus() {
     try {
-      const { getChatIndexStatus } = await import("./chat-index-2I7ZHRE5.js");
+      const { getChatIndexStatus } = await import("./chat-index-JXTYDRCY.js");
       const s = getChatIndexStatus();
       this.send({
         type: "memory_status",
@@ -3074,7 +3022,7 @@ Add .md files to create commands.` });
         type: "info",
         message: full ? "\u{1F9E0} Rebuilding chat memory index (this may take a while on first run \u2014 ~117 MB embedder)." : "\u{1F9E0} Refreshing chat memory index (incremental)\u2026"
       });
-      const { buildChatIndex } = await import("./chat-index-2I7ZHRE5.js");
+      const { buildChatIndex } = await import("./chat-index-JXTYDRCY.js");
       const stats = await buildChatIndex({
         full,
         onProgress: (p) => {