nothumanallowed 9.0.5 → 9.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 **Your agents. Your machine. Your rules.**
 
-38 specialized AI agents + 50 productivity tools. Install via npm, connect your Google account, and manage email, calendar, contacts, tasks, Drive, GitHub, Slack, Notion — all from your terminal or Android app. 100% local. Zero data on our servers.
+38 specialized AI agents + 50 productivity tools + web search. Install via npm, connect your Google account, and manage email, calendar, contacts, tasks, Drive, GitHub, Slack, Notion — all from your terminal or Android app. Streaming responses, multi-conversation history, export. 100% local. Zero data on our servers.
 
 ## Install
 
@@ -28,13 +28,15 @@ nha chat
 
 ## What You Can Do
 
-### Chat with 50 Tools
+### Chat with 50 Tools + Web Search
 
 ```bash
 nha chat
 ```
 
-Ask naturally. The AI reads your email, manages your calendar, handles tasks — all through conversation:
+**Streaming responses** — tokens appear as they're generated. **Multi-conversation** — `/new`, `/list`, `/switch`, `/rename`, `/delete`. **Export** — `/export md`, `/export json`. **Web search** built in.
+
+Ask naturally. The AI reads your email, manages your calendar, searches the web, handles tasks — all through conversation:
 
 ```
 You: Read my latest emails
@@ -68,6 +70,7 @@ NHA: Available 60-min slots:
 | **GitHub** | Notifications, issues, PRs, create issues |
 | **Slack** | List channels, read messages, send messages |
 | **Notion** | Search pages/databases, read page content |
+| **Web** | Web search (DuckDuckGo), fetch URL content, deep search with page extraction |
 | **Other** | Maps directions, reminders, file reading |
 
 Every tool is called directly from your machine to the provider's API. NHA servers are never involved.
@@ -226,10 +229,35 @@ Your Machine                     Provider APIs
 
 Anthropic (Claude), OpenAI (GPT), Google (Gemini), DeepSeek, xAI (Grok), Mistral, Cohere.
 
+## Chat Commands
+
+Inside `nha chat`, use slash commands:
+
+```
+/new              Start a new conversation
+/list             List all conversations
+/switch <id>      Switch to a conversation
+/rename <title>   Rename current conversation
+/delete <id>      Delete a conversation
+/export           Export as Markdown (saved to ~/)
+/export json      Export as JSON (saved to ~/)
+/agents           List available agents
+/agent <name>     Switch to chatting with a specific agent
+/agent off        Return to NHA Chat
+/create-agent     Create a custom agent
+/tasks            Show today's tasks
+/plan             Run daily planner
+/clear            Clear current conversation
+/help             Show all commands
+/quit             Exit
+```
+
+Inline agent routing: `@saber audit this function for SQL injection`
+
 ## Commands
 
 ```bash
-# Chat (50 tools)
+# Chat (50 tools + web search, streaming)
 nha chat                          # Interactive chat with tools
 nha voice                         # Voice chat with TTS
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nothumanallowed",
-  "version": "9.0.5",
-  "description": "NotHumanAllowed — 38 AI agents + unified productivity suite. Gmail, Calendar, Drive, Contacts, Tasks, GitHub, Notion, Slack, voice chat, smart scheduler. Zero-dependency CLI.",
+  "version": "9.1.1",
+  "description": "NotHumanAllowed — 38 AI agents + 50 tools + web search. Streaming chat, multi-conversation, export. Gmail, Calendar, Drive, GitHub, Notion, Slack. Zero-dependency CLI.",
   "type": "module",
   "bin": {
     "nha": "./bin/nha.mjs",

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).
  *
@@ -13,11 +16,12 @@
 import readline from 'readline';
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import { loadConfig } from '../config.mjs';
 import { AGENTS_DIR, AGENTS } from '../constants.mjs';
-import { callLLM, parseAgentFile } from '../services/llm.mjs';
+import { callLLMStream, parseAgentFile } from '../services/llm.mjs';
 
-import { loadChatHistory, saveChatHistory, extractMemory } from '../services/memory.mjs';
+import { extractMemory } from '../services/memory.mjs';
 import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
 import {
   DESTRUCTIVE_ACTIONS,
@@ -33,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 ────────────────────────────────────────────────────────────────
 
@@ -119,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') {
@@ -129,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') {
@@ -151,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') {
@@ -161,34 +287,34 @@ 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 true;
+      return { handled: true };
     }
     const agentSource = fs.readFileSync(agentFile, 'utf-8');
     const { card, systemPrompt: agentSysPrompt } = parseAgentFile(agentSource, agentName);
     if (agentSysPrompt) {
-      // Store agent context for subsequent messages
       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 true;
-  }
-
-  if (trimmed === '/agent off' || trimmed === '/agent reset') {
-    delete config._chatAgent;
-    console.log(`  ${G}Switched back to NHA Chat.${NC}`);
-    return true;
+    return { handled: true };
   }
 
   // /create-agent <name> "<tagline>" "<system prompt>"
@@ -198,24 +324,21 @@ async function handleSlashCommand(input, config, history) {
       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 true;
+      return { handled: true };
     }
-    // Parse: name "tagline" "system prompt"
     const nameMatch = parts.match(/^(\S+)\s+(.+)/);
     if (!nameMatch) {
       console.log(`  ${R}Usage: /create-agent <name> "<tagline>" "<system prompt>"${NC}`);
-      return true;
+      return { handled: true };
     }
     const name = nameMatch[1].toLowerCase().replace(/[^a-z0-9_-]/g, '');
     const rest = nameMatch[2];
-    // Split remaining by quotes
     const quoteParts = rest.match(/"([^"]*)"/g);
     let tagline = '', sysPrompt = '';
     if (quoteParts && quoteParts.length >= 2) {
       tagline = quoteParts[0].replace(/"/g, '');
       sysPrompt = quoteParts[1].replace(/"/g, '');
     } else {
-      // Fallback: first sentence is tagline, rest is prompt
       const firstDot = rest.indexOf('.');
       if (firstDot > 0) {
         tagline = rest.slice(0, firstDot).replace(/"/g, '').trim();
@@ -228,13 +351,13 @@ async function handleSlashCommand(input, config, history) {
 
     if (!name || !tagline || !sysPrompt) {
       console.log(`  ${R}All fields required. Usage: /create-agent name "tagline" "system prompt"${NC}`);
-      return true;
+      return { handled: true };
     }
 
     const agentFile = path.join(AGENTS_DIR, `${name}.mjs`);
     if (fs.existsSync(agentFile)) {
       console.log(`  ${R}Agent "${name}" already exists.${NC}`);
-      return true;
+      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`;
@@ -242,7 +365,7 @@ async function handleSlashCommand(input, config, history) {
     fs.writeFileSync(agentFile, content, 'utf-8');
     console.log(`  ${G}Agent "${name}" created!${NC}`);
     console.log(`  ${D}Switch to it: /agent ${name}${NC}`);
-    return true;
+    return { handled: true };
   }
 
   // /agents — list available agents
@@ -258,34 +381,146 @@ async function handleSlashCommand(input, config, history) {
       console.log(`  ${C}${a}${NC}`);
     }
     console.log(`\n  ${D}Switch: /agent <name> | Create: /create-agent${NC}`);
-    return true;
+    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
+  ${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 interactively
-  ${C}/clear${NC}          Clear conversation history
+  ${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}You can also type @agent in any message to route it to that agent.
+  ${D}Tip: Type @agent in any message to route it inline.
   Example: "@saber audit this function for SQL injection"
 
-  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}
+  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 '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 '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 ────────────────────────────────────────────────────────────────
@@ -298,12 +533,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 {
@@ -322,10 +571,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', () => {
@@ -356,8 +601,12 @@ 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;
       }
@@ -382,22 +631,29 @@ export async function cmdChat(args) {
           }
         }
       } else if (config._chatAgent) {
-        // Persistent agent mode via /agent <name>
         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, effectiveSystemPrompt, 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);
@@ -408,45 +664,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');