nothumanallowed 9.7.2 → 9.8.1

package/src/commands/chat.mjs

@@ -1,9 +1,12 @@
 /**
  * nha chat — Interactive conversational REPL for PAO (Personal Agent Ops).
  *
- * The user types natural language; an LLM interprets intent, optionally
- * invokes Gmail / Calendar / Tasks / GitHub / Notion / Slack APIs via a
- * structured JSON action protocol, and responds conversationally.
+ * Features:
+ * - Streaming responses (token-by-token display)
+ * - Multi-conversation management (/new, /list, /switch, /delete, /rename)
+ * - Export conversations (/export md, /export json)
+ * - @agent inline routing and /agent persistent mode
+ * - Tool execution with confirmation for destructive actions
  *
  * All tool definitions, parsing, and execution are in tool-executor.mjs (DRY).
  *
@@ -11,10 +14,15 @@
  */
 
 import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 import { loadConfig } from '../config.mjs';
-import { callLLM } from '../services/llm.mjs';
-import { loadChatHistory, saveChatHistory, extractMemory } from '../services/memory.mjs';
-import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+import { AGENTS_DIR, AGENTS } from '../constants.mjs';
+import { callLLMStream, parseAgentFile } from '../services/llm.mjs';
+
+import { extractMemory } from '../services/memory.mjs';
+import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, R, M } from '../ui.mjs';
 import {
   DESTRUCTIVE_ACTIONS,
   parseActions,
@@ -29,6 +37,20 @@ import {
   getUnreadImportant,
 } from '../services/mail-router.mjs';
 import { getTasks } from '../services/task-store.mjs';
+import {
+  createConversation,
+  loadConversation,
+  saveConversation,
+  deleteConversation,
+  listConversations,
+  getOrCreateActive,
+  setActiveId,
+  getHistory,
+  addMessages,
+  exportAsMarkdown,
+  exportAsJson,
+  migrateOldHistory,
+} from '../services/conversations.mjs';
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
@@ -115,9 +137,23 @@ async function fetchInitialContext(config) {
   return parts.join('\n\n');
 }
 
+// ── Relative Time ────────────────────────────────────────────────────────────
+
+function relativeTime(isoString) {
+  const ms = Date.now() - new Date(isoString).getTime();
+  const minutes = Math.floor(ms / 60000);
+  if (minutes < 1) return 'just now';
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+  return new Date(isoString).toLocaleDateString();
+}
+
 // ── Slash Command Handlers ───────────────────────────────────────────────────
 
-async function handleSlashCommand(input, config, history) {
+async function handleSlashCommand(input, config, conv, rl) {
   const trimmed = input.trim();
 
   if (trimmed === '/quit' || trimmed === '/exit' || trimmed === '/q') {
@@ -125,12 +161,106 @@ async function handleSlashCommand(input, config, history) {
     process.exit(0);
   }
 
+  // ── Multi-conversation commands ──────────────────────────────────────────
+
+  if (trimmed === '/new') {
+    const newConv = createConversation();
+    // Update the outer reference via return
+    console.log(`  ${G}New conversation started.${NC} ${D}(${newConv.id})${NC}`);
+    return { handled: true, switchTo: newConv };
+  }
+
+  if (trimmed === '/list' || trimmed === '/conversations') {
+    const convs = listConversations();
+    if (convs.length === 0) {
+      console.log(`  ${D}No conversations yet.${NC}`);
+    } else {
+      console.log(`\n  ${BOLD}Conversations${NC} (${convs.length})\n`);
+      for (const c of convs) {
+        const active = c.id === conv.id ? ` ${G}<- active${NC}` : '';
+        const turns = Math.floor(c.messageCount / 2);
+        console.log(`  ${C}${c.id}${NC}  ${c.title}  ${D}(${turns} turns, ${relativeTime(c.updatedAt)})${NC}${active}`);
+      }
+      console.log(`\n  ${D}Switch: /switch <id> | New: /new | Delete: /delete <id>${NC}`);
+    }
+    return { handled: true };
+  }
+
+  if (trimmed.startsWith('/switch ')) {
+    const targetId = trimmed.slice(8).trim();
+    const target = loadConversation(targetId);
+    if (!target) {
+      console.log(`  ${R}Conversation "${targetId}" not found. Use /list to see all.${NC}`);
+      return { handled: true };
+    }
+    setActiveId(targetId);
+    const turns = Math.floor(target.messages.length / 2);
+    console.log(`  ${G}Switched to:${NC} ${target.title} ${D}(${turns} turns)${NC}`);
+    return { handled: true, switchTo: target };
+  }
+
+  if (trimmed.startsWith('/delete ')) {
+    const targetId = trimmed.slice(8).trim();
+    if (targetId === conv.id) {
+      console.log(`  ${R}Cannot delete active conversation. Switch to another first.${NC}`);
+      return { handled: true };
+    }
+    if (deleteConversation(targetId)) {
+      console.log(`  ${G}Deleted conversation ${targetId}.${NC}`);
+    } else {
+      console.log(`  ${R}Conversation "${targetId}" not found.${NC}`);
+    }
+    return { handled: true };
+  }
+
+  if (trimmed.startsWith('/rename ')) {
+    const newTitle = trimmed.slice(8).trim();
+    if (!newTitle) {
+      console.log(`  ${R}Usage: /rename <new title>${NC}`);
+      return { handled: true };
+    }
+    conv.title = newTitle;
+    saveConversation(conv);
+    console.log(`  ${G}Renamed to:${NC} ${newTitle}`);
+    return { handled: true };
+  }
+
+  // ── Export commands ──────────────────────────────────────────────────────
+
+  if (trimmed === '/export' || trimmed === '/export md' || trimmed === '/export markdown') {
+    if (conv.messages.length === 0) {
+      console.log(`  ${D}Nothing to export — conversation is empty.${NC}`);
+      return { handled: true };
+    }
+    const md = exportAsMarkdown(conv);
+    const filename = `nha-chat-${conv.id}.md`;
+    const filePath = path.join(os.homedir(), filename);
+    fs.writeFileSync(filePath, md, 'utf-8');
+    console.log(`  ${G}Exported as Markdown:${NC} ~/${filename}`);
+    return { handled: true };
+  }
+
+  if (trimmed === '/export json') {
+    if (conv.messages.length === 0) {
+      console.log(`  ${D}Nothing to export — conversation is empty.${NC}`);
+      return { handled: true };
+    }
+    const json = exportAsJson(conv);
+    const filename = `nha-chat-${conv.id}.json`;
+    const filePath = path.join(os.homedir(), filename);
+    fs.writeFileSync(filePath, json, 'utf-8');
+    console.log(`  ${G}Exported as JSON:${NC} ~/${filename}`);
+    return { handled: true };
+  }
+
+  // ── Original commands ────────────────────────────────────────────────────
+
   if (trimmed === '/clear') {
-    history.length = 0;
-    try { saveChatHistory([]); } catch { /* non-critical */ }
+    conv.messages.length = 0;
+    saveConversation(conv);
     console.clear();
-    console.log(`  ${G}Conversation cleared (memory preserved, chat history reset).${NC}`);
-    return true;
+    console.log(`  ${G}Conversation cleared (memory preserved).${NC}`);
+    return { handled: true };
   }
 
   if (trimmed === '/tasks') {
@@ -147,7 +277,7 @@ async function handleSlashCommand(input, config, history) {
     } catch (err) {
       console.log(`  ${R}Could not load tasks: ${err.message}${NC}`);
     }
-    return true;
+    return { handled: true };
   }
 
   if (trimmed === '/plan') {
@@ -157,27 +287,282 @@ async function handleSlashCommand(input, config, history) {
     } catch (err) {
       console.log(`  ${R}Plan error: ${err.message}${NC}`);
     }
-    return true;
+    return { handled: true };
+  }
+
+  // /agent <name> — switch to talking with a specific agent
+  if (trimmed.startsWith('/agent ')) {
+    const agentName = trimmed.slice(7).trim().toLowerCase();
+
+    if (agentName === 'off' || agentName === 'reset') {
+      delete config._chatAgent;
+      console.log(`  ${G}Switched back to NHA Chat.${NC}`);
+      return { handled: true };
+    }
+
+    const agentFile = path.join(AGENTS_DIR, `${agentName}.mjs`);
+    if (!fs.existsSync(agentFile)) {
+      console.log(`  ${R}Agent "${agentName}" not found. Available: ${AGENTS.join(', ')}${NC}`);
+      return { handled: true };
+    }
+    const agentSource = fs.readFileSync(agentFile, 'utf-8');
+    const { card, systemPrompt: agentSysPrompt } = parseAgentFile(agentSource, agentName);
+    if (agentSysPrompt) {
+      config._chatAgent = { name: agentName, systemPrompt: agentSysPrompt, card };
+      console.log(`  ${G}Now chatting with ${BOLD}${card?.displayName || agentName.toUpperCase()}${NC}${G} (${card?.tagline || 'agent'})${NC}`);
+      console.log(`  ${D}Type /agent off to return to NHA Chat${NC}`);
+    } else {
+      console.log(`  ${R}Agent "${agentName}" has no system prompt.${NC}`);
+    }
+    return { handled: true };
+  }
+
+  // /create-agent <name> "<tagline>" "<system prompt>"
+  if (trimmed === '/create-agent' || trimmed.startsWith('/create-agent ')) {
+    const parts = trimmed.slice(14).trim();
+    if (!parts) {
+      console.log(`\n  ${BOLD}${Y}Create Custom Agent${NC}`);
+      console.log(`  Usage: ${C}/create-agent mybot "Short description" "You are an expert in..."${NC}`);
+      console.log(`  Example: ${D}/create-agent chef "Italian cooking expert" "You are a master Italian chef. Always suggest authentic recipes with step-by-step instructions."${NC}\n`);
+      return { handled: true };
+    }
+    const nameMatch = parts.match(/^(\S+)\s+(.+)/);
+    if (!nameMatch) {
+      console.log(`  ${R}Usage: /create-agent <name> "<tagline>" "<system prompt>"${NC}`);
+      return { handled: true };
+    }
+    const name = nameMatch[1].toLowerCase().replace(/[^a-z0-9_-]/g, '');
+    const rest = nameMatch[2];
+    const quoteParts = rest.match(/"([^"]*)"/g);
+    let tagline = '', sysPrompt = '';
+    if (quoteParts && quoteParts.length >= 2) {
+      tagline = quoteParts[0].replace(/"/g, '');
+      sysPrompt = quoteParts[1].replace(/"/g, '');
+    } else {
+      const firstDot = rest.indexOf('.');
+      if (firstDot > 0) {
+        tagline = rest.slice(0, firstDot).replace(/"/g, '').trim();
+        sysPrompt = rest.slice(firstDot + 1).replace(/"/g, '').trim();
+      } else {
+        tagline = rest.replace(/"/g, '').trim();
+        sysPrompt = tagline;
+      }
+    }
+
+    if (!name || !tagline || !sysPrompt) {
+      console.log(`  ${R}All fields required. Usage: /create-agent name "tagline" "system prompt"${NC}`);
+      return { handled: true };
+    }
+
+    const agentFile = path.join(AGENTS_DIR, `${name}.mjs`);
+    if (fs.existsSync(agentFile)) {
+      console.log(`  ${R}Agent "${name}" already exists.${NC}`);
+      return { handled: true };
+    }
+
+    const content = `// NHA Custom Agent: ${name}\n// Created: ${new Date().toISOString()}\n\nexport const CARD = {\n  name: '${name}',\n  displayName: '${name.toUpperCase()}',\n  category: 'custom',\n  tagline: '${tagline.replace(/'/g, "\\'")}',\n};\n\nexport const SYSTEM_PROMPT = \`${sysPrompt.replace(/`/g, '\\`')}\`;\n`;
+    if (!fs.existsSync(AGENTS_DIR)) fs.mkdirSync(AGENTS_DIR, { recursive: true });
+    fs.writeFileSync(agentFile, content, 'utf-8');
+    console.log(`  ${G}Agent "${name}" created!${NC}`);
+    console.log(`  ${D}Switch to it: /agent ${name}${NC}`);
+    return { handled: true };
+  }
+
+  // /agents — list available agents
+  if (trimmed === '/agents') {
+    const available = [];
+    if (fs.existsSync(AGENTS_DIR)) {
+      for (const f of fs.readdirSync(AGENTS_DIR)) {
+        if (f.endsWith('.mjs')) available.push(f.replace('.mjs', ''));
+      }
+    }
+    console.log(`  ${BOLD}Available Agents${NC} (${available.length})`);
+    for (const a of available) {
+      console.log(`  ${C}${a}${NC}`);
+    }
+    console.log(`\n  ${D}Switch: /agent <name> | Create: /create-agent${NC}`);
+    return { handled: true };
   }
 
   if (trimmed === '/help') {
     console.log(`
   ${BOLD}Chat Commands${NC}
 
-  ${C}/tasks${NC}    Show today's tasks
-  ${C}/plan${NC}     Run daily planner
-  ${C}/clear${NC}    Clear conversation history
-  ${C}/help${NC}     Show this help
-  ${C}/quit${NC}     Exit chat
-
-  ${D}Otherwise, just type naturally — the AI understands
-  requests like "show my unread emails", "add a task to review PR #42",
-  "what's on my calendar tomorrow?", "list GitHub issues", etc.${NC}
+  ${BOLD}Conversations${NC}
+  ${C}/new${NC}            Start a new conversation
+  ${C}/list${NC}           List all conversations
+  ${C}/switch <id>${NC}    Switch to a conversation
+  ${C}/rename <title>${NC} Rename current conversation
+  ${C}/delete <id>${NC}    Delete a conversation
+  ${C}/export${NC}         Export as Markdown (~/)
+  ${C}/export json${NC}    Export as JSON (~/)
+
+  ${BOLD}Agents${NC}
+  ${C}/agents${NC}         List available agents
+  ${C}/agent <name>${NC}   Switch to chatting with a specific agent
+  ${C}/agent off${NC}      Return to NHA Chat
+  ${C}/create-agent${NC}   Create a new custom agent
+
+  ${BOLD}Tools${NC}
+  ${C}/tasks${NC}          Show today's tasks
+  ${C}/plan${NC}           Run daily planner
+  ${C}/clear${NC}          Clear current conversation
+  ${C}/help${NC}           Show this help
+  ${C}/quit${NC}           Exit chat
+
+  ${D}Tip: Type @agent in any message to route it inline.
+  Example: "@saber audit this function for SQL injection"
+
+  Type naturally — "show my unread emails", "add a task",
+  "what's on my calendar tomorrow?", "list GitHub issues"${NC}
 `);
-    return true;
+    return { handled: true };
   }
 
-  return false;
+  return { handled: false };
+}
+
+// ── Tool Indicators ──────────────────────────────────────────────────────────
+
+/**
+ * Format a user-visible label while a tool is executing.
+ */
+function formatToolLabel(action, params) {
+  switch (action) {
+    case 'web_search':
+      return `Searching the web for "${params.query || '...'}"...`;
+    case 'fetch_url':
+      return `Fetching ${params.url || 'URL'}...`;
+    case 'browser_open':
+      return `Opening ${params.url || 'page'} in browser...`;
+    case 'browser_screenshot':
+      return `Taking screenshot...`;
+    case 'browser_click':
+      return `Clicking ${params.selector || `(${params.x}, ${params.y})`}...`;
+    case 'browser_type':
+      return `Typing into ${params.selector || 'field'}...`;
+    case 'browser_extract':
+      return `Extracting content from ${params.selector || 'page'}...`;
+    case 'browser_js':
+      return `Executing JavaScript...`;
+    case 'browser_wait':
+      return `Waiting for ${params.selector || 'element'}...`;
+    case 'browser_scroll':
+      return `Scrolling ${params.direction || 'down'}...`;
+    case 'browser_key':
+      return `Pressing ${params.key || 'key'}...`;
+    case 'browser_close':
+      return `Closing browser...`;
+    case 'gmail_list':
+      return `Searching emails...`;
+    case 'gmail_read':
+      return `Reading email...`;
+    case 'gmail_send':
+    case 'gmail_send_attach':
+      return `Sending email to ${params.to || '...'}...`;
+    case 'gmail_reply':
+      return `Sending reply...`;
+    case 'calendar_create':
+      return `Creating event "${params.summary || '...'}"...`;
+    case 'calendar_today':
+    case 'calendar_tomorrow':
+    case 'calendar_upcoming':
+    case 'calendar_week':
+      return `Loading calendar...`;
+    case 'github_issues':
+    case 'github_prs':
+      return `Fetching from GitHub...`;
+    case 'notion_search':
+      return `Searching Notion...`;
+    case 'slack_messages':
+    case 'slack_channels':
+      return `Loading Slack...`;
+    default:
+      return `Executing ${action}...`;
+  }
+}
+
+/**
+ * Format a result header with visual indicator based on tool type.
+ */
+function formatToolResult(action, params, result) {
+  switch (action) {
+    case 'web_search': {
+      const count = (result.match(/\d+\. /g) || []).length;
+      const deep = params.deep ? ', deep mode' : '';
+      return `${C}[Web Search: ${count} results${deep}]${NC}`;
+    }
+    case 'fetch_url': {
+      const domain = (params.url || '').replace(/^https?:\/\//, '').split('/')[0];
+      return `${C}[Fetched: ${domain}]${NC}`;
+    }
+    case 'browser_open': {
+      const domain = (params.url || '').replace(/^https?:\/\//, '').split('/')[0];
+      return `${M}[Browser: ${domain}]${NC}`;
+    }
+    case 'browser_screenshot':
+      return `${M}[Screenshot]${NC}`;
+    case 'browser_click':
+      return `${M}[Click: ${params.selector || `(${params.x}, ${params.y})`}]${NC}`;
+    case 'browser_type':
+      return `${M}[Typed: ${(params.text || '').slice(0, 30)}${(params.text || '').length > 30 ? '...' : ''}]${NC}`;
+    case 'browser_extract':
+      return `${M}[Extracted: ${params.selector || 'page'}]${NC}`;
+    case 'browser_js':
+      return `${M}[JS executed]${NC}`;
+    case 'browser_wait':
+      return `${M}[Found: ${params.selector}]${NC}`;
+    case 'browser_scroll':
+      return `${M}[Scrolled ${params.direction || 'down'}]${NC}`;
+    case 'browser_key':
+      return `${M}[Key: ${params.key}]${NC}`;
+    case 'browser_close':
+      return `${M}[Browser closed]${NC}`;
+    case 'gmail_list':
+    case 'gmail_read':
+    case 'gmail_send':
+    case 'gmail_send_attach':
+    case 'gmail_reply':
+    case 'gmail_draft':
+    case 'gmail_mark_read':
+    case 'gmail_mark_unread':
+    case 'gmail_archive':
+    case 'gmail_delete':
+      return `${G}[Email]${NC}`;
+    case 'calendar_today':
+    case 'calendar_tomorrow':
+    case 'calendar_upcoming':
+    case 'calendar_week':
+    case 'calendar_create':
+    case 'calendar_move':
+    case 'calendar_find':
+    case 'calendar_update':
+    case 'schedule_meeting':
+    case 'schedule_draft_email':
+      return `${G}[Calendar]${NC}`;
+    case 'task_list':
+    case 'task_add':
+    case 'task_done':
+    case 'task_move':
+    case 'task_delete':
+    case 'task_clear':
+    case 'task_edit':
+      return `${G}[Tasks]${NC}`;
+    case 'github_issues':
+    case 'github_prs':
+    case 'github_notifications':
+    case 'github_create_issue':
+      return `${G}[GitHub]${NC}`;
+    case 'notion_search':
+    case 'notion_page':
+      return `${G}[Notion]${NC}`;
+    case 'slack_channels':
+    case 'slack_messages':
+    case 'slack_send':
+      return `${G}[Slack]${NC}`;
+    default:
+      return `${G}[${action}]${NC}`;
+  }
 }
 
 // ── Main REPL ────────────────────────────────────────────────────────────────
@@ -190,12 +575,26 @@ export async function cmdChat(args) {
     process.exit(1);
   }
 
+  // Migrate old single-file chat history on first run
+  migrateOldHistory();
+
+  // Load or create active conversation
+  let conv = getOrCreateActive();
+
   console.log(`
   ${BOLD}${C}NHA Chat${NC}  ${D}— Personal Operations Assistant${NC}
   ${D}Type naturally to manage emails, calendar, tasks, GitHub, Notion, Slack.${NC}
-  ${D}Commands: /tasks /plan /clear /help /quit${NC}
+  ${D}Commands: /new /list /export /help /quit${NC}
 `);
 
+  // Show active conversation info
+  const turns = Math.floor(conv.messages.length / 2);
+  if (turns > 0) {
+    ok(`Conversation: "${conv.title}" (${turns} turns)`);
+  } else {
+    info(`New conversation started. (${conv.id})`);
+  }
+
   info('Loading today\'s context...');
   let initialContext = '';
   try {
@@ -214,10 +613,6 @@ export async function cmdChat(args) {
     terminal: true,
   });
 
-  const history = loadChatHistory();
-  if (history.length > 0) {
-    ok(`Loaded ${Math.floor(history.length / 2)} previous conversation turns from memory.`);
-  }
   const systemPrompt = buildSystemPrompt('NHA Chat', CHAT_PERSONA, config, initialContext);
 
   rl.on('close', () => {
@@ -248,26 +643,59 @@ export async function cmdChat(args) {
     }
 
     if (input.startsWith('/')) {
-      const handled = await handleSlashCommand(input, config, history);
-      if (handled) {
+      const result = await handleSlashCommand(input, config, conv, rl);
+      if (result.handled) {
+        // Handle conversation switch
+        if (result.switchTo) {
+          conv = result.switchTo;
+        }
         rl.prompt();
         continue;
       }
     }
 
     try {
-      const userMessage = serializeHistory(history, input);
+      // Handle @agent inline routing
+      let effectiveSystemPrompt = systemPrompt;
+      let effectiveInput = input;
+      const atMatch = input.match(/^@(\w+)\s+(.*)/s);
+      if (atMatch) {
+        const inlineAgent = atMatch[1].toLowerCase();
+        const inlinePrompt = atMatch[2];
+        const agentFile = path.join(AGENTS_DIR, `${inlineAgent}.mjs`);
+        if (fs.existsSync(agentFile)) {
+          const agentSource = fs.readFileSync(agentFile, 'utf-8');
+          const { card, systemPrompt: agentSysPrompt } = parseAgentFile(agentSource, inlineAgent);
+          if (agentSysPrompt) {
+            effectiveSystemPrompt = agentSysPrompt;
+            effectiveInput = inlinePrompt;
+            process.stdout.write(`  ${D}Routing to ${card?.displayName || inlineAgent.toUpperCase()}...${NC}\n`);
+          }
+        }
+      } else if (config._chatAgent) {
+        effectiveSystemPrompt = config._chatAgent.systemPrompt;
+      }
+
+      const history = getHistory(conv, MAX_HISTORY);
+      const userMessage = serializeHistory(history, effectiveInput);
 
       process.stdout.write(`\n  ${D}Thinking...${NC}`);
-      const response = await callLLM(config, systemPrompt, userMessage);
-      process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      let firstToken = true;
+      const response = await callLLMStream(config, effectiveSystemPrompt, userMessage, (chunk) => {
+        if (firstToken) {
+          process.stdout.write('\r' + ' '.repeat(40) + '\r\n  ');
+          firstToken = false;
+        }
+        process.stdout.write(chunk);
+      });
+      if (firstToken) {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      } else {
+        process.stdout.write('\n');
+      }
 
       const { textParts, actions } = parseActions(response);
-
-      if (textParts.length > 0) {
-        const text = textParts.join('\n\n');
-        console.log(`\n  ${W}${text}${NC}\n`);
-      }
+      console.log('');
 
       for (const { action, params } of actions) {
         const isDestructive = DESTRUCTIVE_ACTIONS.has(action);
@@ -278,45 +706,35 @@ export async function cmdChat(args) {
 
           if (!confirmed) {
             console.log(`  ${D}Cancelled.${NC}\n`);
-            history.push({ role: 'user', content: input });
-            history.push({ role: 'assistant', content: response + '\n[User cancelled this action]' });
+            addMessages(conv, input, response + '\n[User cancelled this action]');
             continue;
           }
         }
 
         try {
-          process.stdout.write(`  ${D}Executing ${action}...${NC}`);
+          // Show action-specific indicator
+          const toolLabel = formatToolLabel(action, params);
+          process.stdout.write(`  ${D}${toolLabel}${NC}`);
           const result = await executeTool(action, params, config);
-          process.stdout.write('\r' + ' '.repeat(60) + '\r');
-          console.log(`  ${G}Result:${NC}\n  ${result.split('\n').join('\n  ')}\n`);
-
-          history.push({ role: 'user', content: input });
-          history.push({
-            role: 'assistant',
-            content: response + `\n\n[Tool ${action} executed. Result: ${result}]`,
-          });
+          process.stdout.write('\r' + ' '.repeat(80) + '\r');
+
+          // Show action-specific result header
+          const resultHeader = formatToolResult(action, params, result);
+          console.log(`  ${resultHeader}`);
+          console.log(`  ${result.split('\n').join('\n  ')}\n`);
+
+          addMessages(conv, input, response + `\n\n[Tool ${action} executed. Result: ${result}]`);
         } catch (err) {
-          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          process.stdout.write('\r' + ' '.repeat(80) + '\r');
           console.log(`  ${R}Error executing ${action}: ${err.message}${NC}\n`);
-          history.push({ role: 'user', content: input });
-          history.push({
-            role: 'assistant',
-            content: response + `\n\n[Tool ${action} failed: ${err.message}]`,
-          });
+          addMessages(conv, input, response + `\n\n[Tool ${action} failed: ${err.message}]`);
         }
       }
 
       if (actions.length === 0) {
-        history.push({ role: 'user', content: input });
-        history.push({ role: 'assistant', content: response });
-      }
-
-      while (history.length > MAX_HISTORY * 2) {
-        history.shift();
-        history.shift();
+        addMessages(conv, input, response);
       }
 
-      try { saveChatHistory(history); } catch { /* non-critical */ }
       try { extractMemory('chat', input, response); } catch { /* non-critical */ }
     } catch (err) {
       process.stdout.write('\r' + ' '.repeat(40) + '\r');