natureco-cli 5.19.0 → 5.20.0

package/src/commands/code_v5.js

@@ -20,7 +20,17 @@ const readline = require("readline");
 const chalk = require("chalk");
 const tui = require("../utils/tui");
 const { getConfig } = require("../utils/config");
-const { loadToolDefinitions, executeTool } = require("../utils/tools");
+const { loadToolDefinitions, executeTool, toOpenAIFormat } = require("../utils/tools");
+const { checkPreHooks, runPostHooks, permissionSummary } = require("../utils/tool-hooks");
+const { checkPermission, isApproved, markApproved, formatPermissionPrompt } = require("../utils/permissions");
+const { getPlanMode } = require("../utils/plan-mode");
+const { getWorktree } = require("../utils/worktree");
+const { getLevel: getEffortLevel, getConfig: getEffortConfig } = require("../utils/effort-levels");
+const { getResponseFormat } = require("../utils/structured-output");
+const { getFallbackChain } = require("../utils/fallback-chain");
+const { getTaskManager } = require("../utils/tasks");
+const { buildTiers, assemble, discoverProjectRules } = require("../utils/system-prompt");
+const { buildSkillIndex } = require("../utils/skill-index");
 
 const IS_MAC = os.platform() === "darwin";
 const MAX_ITERATIONS = 10;
@@ -59,23 +69,34 @@ async function apiRequest(url, key, body) {
 
 async function sendMessageWithTools(providerUrl, providerKey, model, messages, toolDefs) {
   const isMM = isMiniMax(providerUrl);
-  const tools = toolDefs.map(t => ({
-    type: "function",
-    function: { name: t.name, description: t.description, parameters: t.parameters },
-  }));
+  const effortLevel = getEffortLevel();
+  const effortCfg = getEffortConfig(effortLevel);
+  const fallbackChain = getFallbackChain();
+  const openaiTools = toOpenAIFormat(toolDefs);
   const body = {
-    model,
+    model: fallbackChain.current || model,
     messages,
-    temperature: 0.3,
-    max_tokens: 4096,
+    temperature: effortCfg.temperature,
+    max_tokens: effortCfg.maxTokens,
     stream: false,
   };
-  if (tools.length > 0) {
-    body.tools = tools;
+  if (openaiTools.length > 0) {
+    body.tools = openaiTools;
     body.tool_choice = "auto";
   }
-  const res = await apiRequest(providerUrl, providerKey, body);
-  return res.choices?.[0]?.message || {};
+  const respFmt = getResponseFormat({});
+  if (respFmt) body.response_format = respFmt;
+  try {
+    const res = await apiRequest(providerUrl, providerKey, body);
+    return res.choices?.[0]?.message || {};
+  } catch (err) {
+    const fb = fallbackChain.recordError(body.model, err);
+    if (fb.fallback) {
+      console.log(tui.C.yellow(`\n  ⚠ ${body.model} başarısız → ${fb.nextModel} deneniyor...\n`));
+      return sendMessageWithTools(providerUrl, providerKey, fb.nextModel, messages, toolDefs);
+    }
+    throw err;
+  }
 }
 
 function confirm(prompt) {
@@ -285,6 +306,126 @@ async function codeV5(targetPath) {
   const projectCtx = scanProject(cwd);
   const toolDefs = loadToolDefinitions();
 
+  // Inject virtual tools
+  const planMode = getPlanMode();
+  const wt = getWorktree();
+  const taskMgr = getTaskManager();
+
+  // File tracking for summary + snapshots
+  function trackFileChanges(toolName, args, result) {
+    if (toolName === 'write_file' || toolName === 'edit_file') {
+      const fp = args.filePath || args.path;
+      if (fp && result && result.success !== false) {
+        filesChanged++;
+        try {
+          const fh = require('../utils/file-history');
+          const content = fs.readFileSync(fp, 'utf8');
+          fh.snapshot(fp, content);
+        } catch {}
+      }
+    }
+    if (toolName === 'bash' || toolName === 'shell_command') commandsRun++;
+  }
+
+  function processToolCallsWithTracking(reply, config, toolDefs, messages) {
+    return processToolCalls(reply, config, toolDefs, messages, trackFileChanges);
+  }
+  const virtualTools = [
+    {
+      name: 'EnterPlanMode',
+      description: 'Switch to plan-only mode. Research and plan without making changes. Use ExitPlanMode when ready.',
+      parameters: { type: 'object', properties: {}, required: [] },
+      execute: async () => {
+        if (planMode.enter()) return { result: 'Plan mode activated. Use ExitPlanMode when your plan is ready.' };
+        return { result: 'Already in plan mode.' };
+      },
+    },
+    {
+      name: 'ExitPlanMode',
+      description: 'Exit plan mode and present your plan for review.',
+      parameters: { type: 'object', properties: { plan: { type: 'string' }, summary: { type: 'string' } }, required: ['plan'] },
+      execute: async (args) => {
+        const ok = planMode.exit(args.plan);
+        if (!ok) return { error: 'Not in plan mode.' };
+        console.log(tui.C.cyan('\n  📋 Plan sunuldu. Onay için /plan approve yazın, red için /plan reject.\n'));
+        return { result: `Plan submitted.\n\n${args.plan}` };
+      },
+    },
+    {
+      name: 'EnterWorktree',
+      description: 'Create an isolated worktree for experimental changes.',
+      parameters: { type: 'object', properties: { branch: { type: 'string' } } },
+      execute: async (args) => wt.enter(args),
+    },
+    {
+      name: 'ExitWorktree',
+      description: 'Exit the current worktree and merge changes back.',
+      parameters: { type: 'object', properties: { merge: { type: 'boolean' } } },
+      execute: async (args) => wt.exit(args),
+    },
+    {
+      name: 'CreateTask', description: 'Run a command in the background.',
+      parameters: { type: 'object', properties: { command: { type: 'string' }, timeout: { type: 'number' } }, required: ['command'] },
+      execute: async (args) => taskMgr.create(args.command, args),
+    },
+    {
+      name: 'ListTasks', description: 'List all background tasks.',
+      parameters: { type: 'object', properties: {} },
+      execute: async () => ({ tasks: taskMgr.list() }),
+    },
+    {
+      name: 'GetTaskResult', description: 'Get the full result of a task.',
+      parameters: { type: 'object', properties: { taskId: { type: 'string' } }, required: ['taskId'] },
+      execute: async (args) => { const t = taskMgr.get(args.taskId); return t || { error: 'Task not found' }; },
+    },
+    {
+      name: 'StopTask', description: 'Stop a running task.',
+      parameters: { type: 'object', properties: { taskId: { type: 'string' } }, required: ['taskId'] },
+      execute: async (args) => taskMgr.stop(args.taskId),
+    },
+    {
+      name: 'SearchSessions', description: 'Search past sessions.',
+      parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+      execute: async (args) => { const { search } = require('../utils/session-search'); return { results: search(args.query, 5) }; },
+    },
+    {
+      name: 'RestoreFile', description: 'Restore a file from snapshot history.',
+      parameters: { type: 'object', properties: { filePath: { type: 'string' }, timestamp: { type: 'number' } }, required: ['filePath'] },
+      execute: async (args) => { const fh = require('../utils/file-history'); const snaps = fh.getHistory(args.filePath); if (!snaps.length) return { error: 'No history' }; return fh.restore(args.filePath, args.timestamp || snaps[0].timestamp); },
+    },
+    {
+      name: 'FileHistory', description: 'List snapshot history for a file.',
+      parameters: { type: 'object', properties: { filePath: { type: 'string' } }, required: ['filePath'] },
+      execute: async (args) => { const fh = require('../utils/file-history'); return { snapshots: fh.getHistory(args.filePath) }; },
+    },
+    {
+      name: 'UltraReview', description: 'Multi-focus code review (security, style, logic, performance).',
+      parameters: { type: 'object', properties: { files: { type: 'array', items: { type: 'string' } }, diff: { type: 'string' } } },
+      execute: async (args) => {
+        const ur = require('../utils/ultra-review');
+        if (args.diff) return ur.reviewDiff(args.diff);
+        if (args.files) return { reviews: args.files.map(f => { try { return ur.reviewFile(f, fs.readFileSync(f, 'utf8')); } catch { return { file: f, error: 'Not found' }; } }) };
+        return { error: 'Specify files or diff' };
+      },
+    },
+    {
+      name: 'ScheduleTask', description: 'Schedule a recurring cron task.',
+      parameters: { type: 'object', properties: { schedule: { type: 'string' }, command: { type: 'string' }, description: { type: 'string' } }, required: ['schedule', 'command'] },
+      execute: async (args) => require('../utils/cron').addJob(args),
+    },
+    {
+      name: 'ListScheduledTasks', description: 'List cron tasks.',
+      parameters: { type: 'object', properties: {} },
+      execute: async () => ({ jobs: require('../utils/cron').loadJobs() }),
+    },
+    {
+      name: 'RemoveScheduledTask', description: 'Remove a cron task.',
+      parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+      execute: async (args) => { require('../utils/cron').removeJob(args.id); return { removed: true }; },
+    },
+  ];
+  toolDefs.push(...virtualTools);
+
   // Header / Welcome
   console.log("");
   console.log(tui.styled("  ╭" + "─".repeat(58) + "╮", { color: tui.PALETTE.primary }));
@@ -308,19 +449,26 @@ async function codeV5(targetPath) {
   }
 
   console.log("\n  " + tui.C.muted("Komutlar:"));
+  console.log("    " + tui.C.amber("/plan on|approve|reject|show") + tui.C.muted(" — Plan modu"));
   console.log("    " + tui.C.amber("/summary") + tui.C.muted(" — Oturum özeti"));
   console.log("    " + tui.C.amber("/done") + tui.C.muted("    — Özet + çıkış"));
   console.log("    " + tui.C.amber("Ctrl+C") + tui.C.muted("  — Çıkış"));
   console.log("");
 
-  // System prompt
-  const systemPrompt = [
-    "Sen NatureCo Code Agent v5'sin — Claude Code alternatifi bir terminal AI asistanısın.",
-    "47 tool'un var: dosya okuma/yazma, bash, Python, web search, macOS native, image generation, TTS, vs.",
-    "Kullanıcının isteğini analiz et, uygun tool'ları kullan, sonuçları özetle.",
-    "Türkçe cevap ver.",
-    "Kullanıcıdan onay almadan dosya yazma veya tehlikeli komut çalıştırma.",
-  ].join(" ");
+  // Three-tier system prompt (Hermes-style)
+  const skillsIndexBlock = buildSkillIndex();
+  const cfg = getConfig();
+  const projectRules = discoverProjectRules(cwd);
+  const promptOpts = {
+    botName: 'Code Agent',
+    userName: cfg.userName || 'kullanıcı',
+    skillsIndexBlock,
+    projectRules,
+    hasHistory: false,
+    userHome: os.homedir(),
+  };
+  const { stable, context, volatile } = buildTiers(promptOpts);
+  const systemPrompt = assemble(stable, context, volatile);
 
   let messages = [{ role: "system", content: systemPrompt }];
   let totalIn = 0, totalOut = 0;
@@ -337,83 +485,133 @@ async function codeV5(targetPath) {
       if (!input) { process.stdout.write("  " + tui.styled("You  ", { color: tui.PALETTE.primary, bold: true })); return ask(); }
       if (input === "/summary") {
         printSummary(filesChanged, commandsRun, messages.length - 1, startTime);
-        // v5.6.22: /summary sadece gosterir, cikmaz
         process.stdout.write("\n  " + tui.styled("You  ", { color: tui.PALETTE.primary, bold: true }));
         return ask();
       }
       if (input === "/done" || input === "exit" || input === "quit") {
-        // v5.6.22: /done cikinca summary goster
         printSummary(filesChanged, commandsRun, messages.length - 1, startTime);
         rl.close();
         return;
       }
+      if (input.startsWith("/plan ")) {
+        const arg = input.slice(6).trim();
+        const pm = getPlanMode();
+        if (arg === "on" || arg === "enter") {
+          if (pm.enter()) console.log(tui.C.cyan('\n  📋 Plan modu aktif.\n'));
+          else console.log(tui.C.yellow('  Zaten plan modunda.'));
+        } else if (arg === "approve") {
+          if (pm.inReview()) { pm.approve(); console.log(tui.C.green('  ✓ Plan onaylandı.\n')); }
+          else console.log(tui.C.yellow('  Onay bekleyen plan yok.'));
+        } else if (arg === "reject") {
+          if (pm.inReview()) { pm.reject(); console.log(tui.C.amber('  ⨯ Plan reddedildi.\n')); }
+          else console.log(tui.C.yellow('  Onay bekleyen plan yok.'));
+        } else if (arg === "show") {
+          if (pm.planHistory.length > 0) console.log(tui.C.cyan('\n  📋 Son Plan:\n  ' + pm.planHistory[pm.planHistory.length - 1].plan.replace(/\n/g, '\n  ') + '\n'));
+          else console.log(tui.C.yellow('  Henüz plan yok.'));
+        } else {
+          console.log(tui.C.yellow('  Kullanım: /plan on|approve|reject|show'));
+        }
+        process.stdout.write("\n  " + tui.styled("You  ", { color: tui.PALETTE.primary, bold: true }));
+        return ask();
+      }
+
+      // Workflow step — run before every request
+      process.stdout.write(tui.styled('\r  🔧 workflow...  ', { color: tui.PALETTE.muted }));
+      const wfResult = await executeTool('workflow', { action: 'run', task: input }, toolDefs);
+      const wf = wfResult?.result || {};
+      if (wf.success !== false) {
+        const loaded = wf.skillsLoaded && wf.skillsLoaded.length > 0 ? ` [skill: ${wf.skillsLoaded.join(', ')}]` : '';
+        process.stdout.write(tui.styled(`  ✓ workflow${loaded}\n`, { color: tui.PALETTE.success }));
+      } else {
+        process.stdout.write(tui.styled('  ✗ workflow\n', { color: tui.PALETTE.danger }));
+      }
 
       messages.push({ role: "user", content: input });
-      process.stdout.write("\n  " + tui.styled("AI   ", { color: tui.PALETTE.secondary, bold: true }));
 
-      // Multi-turn tool loop
-      let iter = 0;
-      while (iter < MAX_ITERATIONS) {
-        iter++;
+      if (wf.passthrough && wf.reply !== undefined && wf.reply !== null) {
+        // Simple chat — workflow handled it directly
+        const fullReply = String(wf.reply);
+        process.stdout.write('\n' + fullReply + '\n');
+        messages.push({ role: 'assistant', content: fullReply });
+        totalIn += Math.ceil(input.length / 4);
+        totalOut += Math.ceil(fullReply.length / 4);
+      } else if (wf.status === 'completed' || (wf.results && wf.results.length > 0)) {
+        // Complex task — inject workflow report as context, then LLM crafts final reply
+        const workflowSteps = wf.results || [];
+        const report = workflowSteps.map(r => {
+          const t = r.tool || r.name || '?';
+          const s = r.status === 'done' ? '✓' : '✗';
+          let summary = '';
+          if (r.result) {
+            try { summary = typeof r.result === 'string' ? r.result.slice(0, 400) : JSON.stringify(r.result).slice(0, 400); } catch {}
+          }
+          return `  ${s} ${t}: ${summary}`;
+        }).join('\n');
+        const skillInfo = wf.skillsLoaded && wf.skillsLoaded.length > 0
+          ? `\n\nKullanilan skill'ler: ${wf.skillsLoaded.join(', ')}`
+          : '';
+        const preWfLen = messages.length;
+        messages.push({
+          role: 'system',
+          content: `=== WORKFLOW SONUCLARI ===\nSu araclar calisti:\n${report}${skillInfo}\n\nKullaniciya bu sonuclari anlamli bir sekilde ozetle.\n=== SONUC BITTI ===`,
+        });
+
+        process.stdout.write("\n  " + tui.styled("AI   ", { color: tui.PALETTE.secondary, bold: true }));
+
+        // Single LLM call to summarize workflow results
+        let wfReply = null;
         try {
-          const reply = await sendMessageWithTools(
+          wfReply = await sendMessageWithTools(
             config.providerUrl, config.providerApiKey, config.providerModel,
             messages, toolDefs
           );
-          if (reply.content) {
-            process.stdout.write(reply.content);
-            messages.push({ role: "assistant", content: reply.content });
-            totalOut += Math.ceil(reply.content.length / 4);
+          // Remove workflow results after call
+          messages.splice(preWfLen, 1);
+          if (wfReply.content) {
+            process.stdout.write(wfReply.content);
+            messages.push({ role: "assistant", content: wfReply.content });
+            totalOut += Math.ceil(wfReply.content.length / 4);
+          }
+          // Handle any tool calls from the summary (rare but possible)
+          if (wfReply.tool_calls && wfReply.tool_calls.length > 0) {
+            await processToolCallsWithTracking(wfReply, config, toolDefs, messages);
           }
+        } catch (e) {
+          console.log("\n  " + tui.C.red("❌ " + e.message));
+        }
 
-          if (reply.tool_calls && reply.tool_calls.length > 0) {
-            // v5.6.21: Akıllı onay - sadece riskli işlemlerde onay iste
-            let approved = true;
-            for (const tc of reply.tool_calls) {
-              let args = {};
-              try { args = JSON.parse(tc.function.arguments || "{}"); } catch {}
-              const risk = assessRisk(tc.function.name, args);
-              if (risk.requiresApproval) {
-                process.stdout.write("\n");
-                approved = await confirm(
-                  `⚠ ${tc.function.name}: ${risk.reason}\n  Devam edilsin mi? (Y/n) `
-                );
-                if (!approved) break;
-              }
-            }
-            if (!approved) {
-              console.log("\n  " + tui.C.yellow("⚠ Kullanıcı onayı iptal etti, tool çalıştırılmadı."));
-              break;
+        totalIn += Math.ceil(((wfReply?.content || '') + report + skillInfo).length / 4) + Math.ceil(input.length / 4);
+      } else {
+        // Workflow failed or returned unexpected format — fallback to multi-turn LLM
+        process.stdout.write("\n  " + tui.styled("AI   ", { color: tui.PALETTE.secondary, bold: true }));
+        let iter = 0;
+        while (iter < MAX_ITERATIONS) {
+          iter++;
+          try {
+            const reply = await sendMessageWithTools(
+              config.providerUrl, config.providerApiKey, config.providerModel,
+              messages, toolDefs
+            );
+            if (reply.content) {
+              process.stdout.write(reply.content);
+              messages.push({ role: "assistant", content: reply.content });
+              totalOut += Math.ceil(reply.content.length / 4);
             }
 
-            messages.push({ role: "assistant", content: reply.content || null, tool_calls: reply.tool_calls });
-            for (const tc of reply.tool_calls) {
-              const name = tc.function.name;
-              let args = {};
-              try { args = JSON.parse(tc.function.arguments || "{}"); } catch {}
-              printToolCall(name, args);
-              if (name === "bash" || name === "shell_command") commandsRun++;
-              if (name === "write_file" || name === "edit_file") filesChanged++;
-              const result = await executeTool(name, args, toolDefs);
-              // v5.6.21: Sonuç gizleme - sadece status goster, yol/size gizle
-              printToolCallSafe(name, args, result);
-              const out = result.error
-                ? "ERROR: " + result.error
-                : (typeof result.result === "string" ? result.result : JSON.stringify(result.result));
-              messages.push({ role: "tool", tool_call_id: tc.id, content: (out || "(empty)").slice(0, 8000) });
-              totalIn += Math.ceil(out.length / 4);
+            if (reply.tool_calls && reply.tool_calls.length > 0) {
+              await processToolCallsWithTracking(reply, config, toolDefs, messages);
+              process.stdout.write("\n  " + tui.styled("AI   ", { color: tui.PALETTE.secondary, bold: true }));
+              continue;
             }
-            process.stdout.write("\n  " + tui.styled("AI   ", { color: tui.PALETTE.secondary, bold: true }));
-            continue;
+            break;
+          } catch (e) {
+            console.log("\n  " + tui.C.red("❌ " + e.message));
+            break;
           }
-          break;
-        } catch (e) {
-          console.log("\n  " + tui.C.red("❌ " + e.message));
-          break;
         }
+        totalIn += Math.ceil(input.length / 4);
       }
 
-      totalIn += Math.ceil(input.length / 4);
       process.stdout.write("\n\n  " + tui.styled("You  ", { color: tui.PALETTE.primary, bold: true }));
       ask();
     });
@@ -421,6 +619,112 @@ async function codeV5(targetPath) {
   ask();
 }
 
+const PARALLEL_SAFE_TOOLS = new Set(['read_file', 'file_search', 'grep_search', 'web_search', 'web_readability', 'duckduckgo_search', 'exa_search', 'searxng_search', 'firecrawl', 'memory_search', 'memory']);
+
+async function processToolCalls(reply, config, toolDefs, messages, onToolResult) {
+  for (const tc of reply.tool_calls) {
+    let args = {};
+    try { args = JSON.parse(tc.function.arguments || "{}"); } catch {}
+    const risk = assessRisk(tc.function.name, args);
+
+    // Built-in risk assessment
+    if (risk.requiresApproval) {
+      process.stdout.write("\n");
+      const approved = await confirm(
+        `⚠ ${tc.function.name}: ${risk.reason}\n  Devam edilsin mi? (Y/n) `
+      );
+      if (!approved) {
+        console.log("\n  " + tui.C.yellow("⚠ Kullanıcı onayı iptal etti, tool çalıştırılmadı."));
+        return;
+      }
+    }
+
+    // Plan mode check
+    const pm = getPlanMode();
+    const planCheck = pm.checkTool(tc.function.name, args);
+    if (!planCheck.allowed) {
+      console.log("\n  " + tui.C.red("⛔ Plan modunda engellendi: " + planCheck.reason));
+      return;
+    }
+    pm.recordTool(tc.function.name, args);
+
+    // Permission check
+    const perm = checkPermission(tc.function.name, args);
+    if (perm.action === 'deny') {
+      console.log("\n  " + tui.C.red("⛔ İzin engelledi: " + perm.reason));
+      return;
+    }
+    if (perm.action === 'ask') {
+      const permKey = `${perm.rule.raw}:${JSON.stringify(args)}`;
+      if (!isApproved(permKey)) {
+        process.stdout.write("\n");
+        const ok = await confirm(`İzin gerekli: ${formatPermissionPrompt(tc.function.name, args, perm.reason)}\n  İzin ver? [y=once, Y=session, p=persistent, n=no] `);
+        if (ok === 'persistent') markApproved(permKey, true);
+        else if (ok === 'session' || ok === true) markApproved(permKey, false);
+        else {
+          console.log("\n  " + tui.C.yellow("⛔ İzin reddedildi"));
+          return;
+        }
+      }
+    }
+
+    // Pre-hook check
+    const hook = checkPreHooks(tc.function.name, args);
+    if (hook.action === 'deny') {
+      console.log("\n  " + tui.C.red("⛔ Hook engelledi: " + hook.rule.raw));
+      return;
+    }
+    if (hook.action === 'ask') {
+      const ok = await confirm(`Hook onayı: ${permissionSummary(hook.rule, tc.function.name, args)}\n  İzin verilsin mi? (y/N) `);
+      if (!ok) {
+        console.log("\n  " + tui.C.yellow("⛔ Hook reddetti: " + hook.rule.raw));
+        return;
+      }
+    }
+  }
+
+  messages.push({ role: "assistant", content: reply.content || null, tool_calls: reply.tool_calls });
+
+  const parsed = reply.tool_calls.map(tc => {
+    let args = {};
+    try { args = JSON.parse(tc.function.arguments || "{}"); } catch {}
+    return { name: tc.function.name, args, id: tc.id };
+  });
+
+  const parallelSafe = parsed.filter(p => PARALLEL_SAFE_TOOLS.has(p.name));
+  const sequential = parsed.filter(p => !PARALLEL_SAFE_TOOLS.has(p.name));
+
+  // Print all tool calls
+  for (const p of parsed) printToolCall(p.name, p.args);
+
+  // Run parallel-safe tools concurrently
+  if (parallelSafe.length > 0) {
+    const results = await Promise.all(parallelSafe.map(async (p) => {
+      const result = runPostHooks(p.name, p.args, await executeTool(p.name, p.args, toolDefs));
+      printToolCallSafe(p.name, p.args, result);
+      if (onToolResult) onToolResult(p.name, p.args, result);
+      const out = result.error
+        ? "ERROR: " + result.error
+        : (typeof result.result === "string" ? result.result : JSON.stringify(result.result));
+      return { id: p.id, content: (out || "(empty)").slice(0, 8000) };
+    }));
+    for (const r of results) {
+      messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
+    }
+  }
+
+  // Run sequential tools one at a time
+  for (const p of sequential) {
+    const result = runPostHooks(p.name, p.args, await executeTool(p.name, p.args, toolDefs));
+    printToolCallSafe(p.name, p.args, result);
+    if (onToolResult) onToolResult(p.name, p.args, result);
+    const out = result.error
+      ? "ERROR: " + result.error
+      : (typeof result.result === "string" ? result.result : JSON.stringify(result.result));
+    messages.push({ role: "tool", tool_call_id: p.id, content: (out || "(empty)").slice(0, 8000) });
+  }
+}
+
 function printSummary(files, cmds, msgs, startTime) {
   const elapsed = Math.floor((Date.now() - startTime) / 1000);
   const min = Math.floor(elapsed / 60);