navada-edge-cli 4.0.0 → 4.2.0

package/lib/agent.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { execSync, execFileSync } = require('child_process');
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -9,24 +10,64 @@ const http = require('http');
 const navada = require('navada-edge-sdk');
 const ui = require('./ui');
 const config = require('./config');
+const memory = require('./memory');
 
 // ---------------------------------------------------------------------------
-// NAVADA Edge Agent — personality + tools + routing
+// Request helpers — auth, tracing, rate-limit headers
 // ---------------------------------------------------------------------------
+function generateRequestId() { return `nv_${crypto.randomUUID()}`; }
+
+function navadaAuthHeaders() {
+  const edgeKey = config.get('edgeKey') || '';
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Request-ID': generateRequestId(),
+    'X-Client-Version': require('../package.json').version,
+  };
+  if (edgeKey) headers['Authorization'] = `Bearer ${edgeKey}`;
+  return headers;
+}
 
-// Strip markdown formatting for clean terminal output
-function cleanOutput(text) {
-  if (typeof text !== 'string') return text;
-  return text
-    .replace(/\*\*(.+?)\*\*/g, '$1')   // **bold** → plain
-    .replace(/\*(.+?)\*/g, '$1')       // *italic* → plain
-    .replace(/__(.+?)__/g, '$1')       // __underline__ → plain
-    .replace(/^#{1,6}\s+/gm, '')       // ### headers → plain
-    .replace(/---+/g, '')              // horizontal rules → remove
-    .replace(/\s--\s/g, ' ')           // spaced -- → space
-    .replace(/--/g, ', ');             // remaining -- → comma
+// ---------------------------------------------------------------------------
+// Edge Gateway — authenticated requests to NAVADA Azure compute
+// ---------------------------------------------------------------------------
+const EDGE_GATEWAY = 'https://edge-compute.navada-edge-server.uk';
+
+async function navadaEdgeRequest(method, reqPath, body) {
+  const edgeKey = config.get('edgeKey');
+  if (!edgeKey) throw new Error('Not connected. /edge login <key>');
+
+  const url = new URL(EDGE_GATEWAY + reqPath);
+  const transport = url.protocol === 'https:' ? https : http;
+  const payload = body ? JSON.stringify(body) : '';
+
+  return new Promise((resolve, reject) => {
+    const headers = {
+      ...navadaAuthHeaders(),
+      'Authorization': `Bearer ${edgeKey}`,
+    };
+    if (payload) headers['Content-Length'] = Buffer.byteLength(payload);
+
+    const req = transport.request(url, { method, headers, timeout: 60000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        rateTracker.updateFromServer(res.headers);
+        try { resolve({ status: res.statusCode, data: JSON.parse(data), headers: res.headers }); }
+        catch { resolve({ status: res.statusCode, data, headers: res.headers }); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    if (payload) req.write(payload);
+    req.end();
+  });
 }
 
+// ---------------------------------------------------------------------------
+// NAVADA Edge Agent — personality + tools + routing
+// ---------------------------------------------------------------------------
+
 const IDENTITY = {
   name: 'NAVADA Edge',
   role: 'AI Infrastructure Agent',
@@ -34,22 +75,20 @@ const IDENTITY = {
 You are professional, technical, concise, and helpful. You speak with authority about distributed systems, Docker, AI, and cloud infrastructure.
 You have FULL ACCESS to the user's computer — you CAN and SHOULD use your tools to execute tasks:
   - shell: run ANY bash, PowerShell, or system command on the user's machine
-  - read_file / write_file / edit_file / delete_file / list_files: full filesystem CRUD — create, read, edit, delete any file
+  - read_file / write_file / list_files: full filesystem access — create, read, modify any file
   - python_exec / python_pip / python_script: run Python code directly
   - sandbox_run: run code with syntax-highlighted output
   - system_info: check CPU, RAM, disk, OS
-You also connect to the NAVADA Edge Network (4 nodes via Tailscale VPN):
-  - lucas_exec / lucas_ssh / lucas_docker: execute commands on remote nodes (EC2, HP, Oracle)
-  - mcp_call: access 18 MCP tools on the ASUS server
-  - docker_registry: manage the private Docker registry
-  - send_email / generate_image: communications and AI image generation
-  - founder_info: ALWAYS use this tool when asked about Lee Akpareva, his career, education, projects, or NAVADA's founder. It has his full CV. Never guess about Lee, always call this tool.
+You also connect to the NAVADA Edge Network cloud:
+  - automation_request: submit automation requests (emails, marketing, builds, schedules)
+  - web_search: search the web for information
+  - save_memory / recall_memory: persistent memory across sessions
+  - screenshot / describe_image: visual perception tools
+  - founder_info: information about Lee Akpareva, the creator of NAVADA
 When users ask you to DO something — DO IT. Use write_file to create files. Use shell to run commands. Never say "I can't" when you have a tool for it.
 When asked to generate diagrams — use write_file to create Mermaid (.mmd), SVG, or HTML files. You can also use python_exec with matplotlib/graphviz for complex diagrams.
 When asked to create, edit, or delete files — use the file tools directly. You are a terminal agent with FULL access.
-PLATFORM: This machine runs ` + (process.platform === 'win32' ? `Windows. Use Windows paths. Desktop = ${fs.existsSync(path.join(os.homedir(), 'OneDrive', 'Desktop')) ? path.join(os.homedir(), 'OneDrive', 'Desktop') : path.join(os.homedir(), 'Desktop')}. Home = ${os.homedir()}.` : `${process.platform}. Home = ${os.homedir()}.`) + `
-Keep responses short. Code blocks when needed. No fluff.
-FORMATTING: Never use markdown formatting like **bold**, *italic*, ### headers, or -- dashes. Write plain text only. This is a terminal, not a web page.`,
+Keep responses short. Code blocks when needed. No fluff.`,
   founder: {
     name: 'Leslie (Lee) Akpareva',
     title: 'Principal AI Consultant & Founder, NAVADA Edge Network',
@@ -91,15 +130,6 @@ function getSystemPrompt() {
     } catch {}
   }
 
-  // Load user's agent.md customisation if it exists
-  const agentMdPath = path.join(config.CONFIG_DIR, 'agent.md');
-  let userPrompt = '';
-  try {
-    if (fs.existsSync(agentMdPath)) {
-      userPrompt = fs.readFileSync(agentMdPath, 'utf-8').trim();
-    }
-  } catch {}
-
   // Load active sub-agent if selected
   if (sessionState.subAgent) {
     const subPath = path.join(config.CONFIG_DIR, 'agents', `${sessionState.subAgent}.md`);
@@ -110,11 +140,51 @@ function getSystemPrompt() {
     } catch {}
   }
 
-  // Combine: base personality + user customisation
-  if (userPrompt) {
-    return `${IDENTITY.personality}\n\n--- USER CUSTOMISATION (from agent.md) ---\n${userPrompt}`;
+  let prompt = IDENTITY.personality;
+
+  // Load soul.md — user identity and preferences
+  const soulPath = path.join(config.CONFIG_DIR, 'soul.md');
+  try {
+    if (fs.existsSync(soulPath)) {
+      const soul = fs.readFileSync(soulPath, 'utf-8').trim();
+      if (soul) prompt += `\n\n--- USER IDENTITY (from soul.md) ---\n${soul}`;
+    }
+  } catch {}
+
+  // Load guardrail.md — safety boundaries
+  const guardrailPath = path.join(config.CONFIG_DIR, 'guardrail.md');
+  try {
+    if (fs.existsSync(guardrailPath)) {
+      const guardrail = fs.readFileSync(guardrailPath, 'utf-8').trim();
+      if (guardrail) prompt += `\n\n--- GUARDRAILS (from guardrail.md) ---\n${guardrail}`;
+    }
+  } catch {}
+
+  // Load agent.md — legacy customisation (backwards compat)
+  const agentMdPath = path.join(config.CONFIG_DIR, 'agent.md');
+  try {
+    if (fs.existsSync(agentMdPath)) {
+      const userPrompt = fs.readFileSync(agentMdPath, 'utf-8').trim();
+      if (userPrompt) prompt += `\n\n--- AGENT CUSTOMISATION (from agent.md) ---\n${userPrompt}`;
+    }
+  } catch {}
+
+  // Inject memory context (Tier 2 episodes + Tier 3 knowledge)
+  const memoryContext = memory.manager.loadSessionContext();
+  if (memoryContext) {
+    prompt += `\n\n--- MEMORY (auto-loaded) ---\n${memoryContext}`;
   }
-  return IDENTITY.personality;
+
+  // Inject user skills (so agent knows what skills are available)
+  try {
+    const skills = require('./skills');
+    const skillsPrompt = skills.getSkillsPrompt();
+    if (skillsPrompt) {
+      prompt += `\n\n--- USER SKILLS ---\n${skillsPrompt}`;
+    }
+  } catch {}
+
+  return prompt;
 }
 
 function listSubAgents() {
@@ -135,27 +205,33 @@ const sessionState = {
   cost: 0,
   messages: 0,
   startTime: Date.now(),
-  learningMode: null,  // 'python' | 'csharp' | 'node' | null
-  subAgent: null,      // active sub-agent name (loads from ~/.navada/agents/<name>.md)
-  history: [],         // conversation history for context continuity
+  learningMode: null,
+  subAgent: null,
+  get history() { return memory.working.recentMessages; },
 };
 
-// Conversation history management
+// Conversation history — powered by 3-tier memory system
 function addToHistory(role, content) {
-  sessionState.history.push({ role, content });
-  // Keep last 40 turns to avoid token overflow
-  if (sessionState.history.length > 40) {
-    sessionState.history = sessionState.history.slice(-40);
-  }
+  memory.working.add(role, content);
   sessionState.messages++;
+
+  // Auto-extract knowledge from user messages (Tier 3)
+  if (role === 'user') {
+    const lastAssistant = memory.working.recentMessages
+      .filter(m => m.role === 'assistant')
+      .pop();
+    memory.manager.autoExtract(content, lastAssistant?.content || '');
+  }
 }
 
 function getConversationHistory() {
-  return sessionState.history;
+  return memory.working.getContextMessages();
 }
 
 function clearHistory() {
-  sessionState.history = [];
+  // Save episode before clearing (Tier 2)
+  memory.manager.saveSessionEpisode();
+  memory.working.clear();
   sessionState.messages = 0;
   sessionState.tokens = { input: 0, output: 0, total: 0 };
   sessionState.cost = 0;
@@ -182,6 +258,7 @@ const rateTracker = {
 
   remaining() {
     this.cleanup();
+    if (this.serverRemaining !== null && this.serverRemaining !== undefined) return this.serverRemaining;
     return Math.max(0, this.limit - this.requests.length);
   },
 
@@ -189,6 +266,18 @@ const rateTracker = {
     this.cleanup();
     return this.requests.length;
   },
+
+  updateFromServer(headers) {
+    const limit = parseInt(headers['x-ratelimit-limit']);
+    const remaining = parseInt(headers['x-ratelimit-remaining']);
+    const reset = headers['x-ratelimit-reset'];
+    if (!isNaN(limit)) this.limit = limit;
+    this.serverRemaining = isNaN(remaining) ? null : remaining;
+    this.serverReset = reset || null;
+  },
+
+  serverRemaining: null,
+  serverReset: null,
 };
 
 // ---------------------------------------------------------------------------
@@ -239,36 +328,6 @@ const localTools = {
     },
   },
 
-  editFile: {
-    description: 'Edit a file by replacing a search string with new content',
-    execute: (filePath, search, replace) => {
-      try {
-        const resolved = path.resolve(filePath);
-        const content = fs.readFileSync(resolved, 'utf-8');
-        if (!content.includes(search)) return `Error: search string not found in ${resolved}`;
-        const updated = content.replace(search, replace);
-        fs.writeFileSync(resolved, updated);
-        return `Edited: ${resolved} (replaced ${search.length} chars)`;
-      } catch (e) { return `Error: ${e.message}`; }
-    },
-  },
-
-  deleteFile: {
-    description: 'Delete a file or empty directory from this machine',
-    execute: (filePath) => {
-      try {
-        const resolved = path.resolve(filePath);
-        const stat = fs.statSync(resolved);
-        if (stat.isDirectory()) {
-          fs.rmdirSync(resolved);
-        } else {
-          fs.unlinkSync(resolved);
-        }
-        return `Deleted: ${resolved}`;
-      } catch (e) { return `Error: ${e.message}`; }
-    },
-  },
-
   systemInfo: {
     description: 'Get system information',
     execute: () => {
@@ -342,21 +401,8 @@ const localTools = {
   },
 
   founderInfo: {
-    description: 'Answer questions about Lee Akpareva, founder of NAVADA Edge, using his full CV and career history',
-    execute: (question) => {
-      try {
-        const knowledgePath = path.join(__dirname, 'knowledge.py');
-        const py = process.platform === 'win32' ? 'python' : 'python3';
-        const openaiKey = config.get('openaiKey') || process.env.OPENAI_API_KEY || '';
-        const output = execFileSync(py, [knowledgePath, question || 'Who is Lee Akpareva?'], {
-          timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
-          env: { ...process.env, OPENAI_API_KEY: openaiKey },
-        });
-        return output.trim();
-      } catch (e) {
-        return `Error: ${e.stderr?.trim() || e.message}`;
-      }
-    },
+    description: 'Get information about the NAVADA Edge founder',
+    execute: () => JSON.stringify(IDENTITY.founder, null, 2),
   },
 };
 
@@ -377,6 +423,7 @@ async function callFreeTier(messages, stream = false) {
       const r = await navada.request(endpoint, {
         method: 'POST',
         body: { messages },
+        headers: navadaAuthHeaders(),
         timeout: endpoint.includes('navada-edge-server.uk') ? 30000 : 5000,
       });
 
@@ -426,11 +473,13 @@ function streamFreeTier(endpoint, messages) {
     const transport = url.protocol === 'https:' ? https : http;
     const body = JSON.stringify({ messages, stream: true });
 
+    const authHeaders = navadaAuthHeaders();
     const req = transport.request(url, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      headers: { ...authHeaders, 'Content-Length': Buffer.byteLength(body) },
       timeout: endpoint.includes('navada-edge-server.uk') ? 120000 : 10000,
     }, (res) => {
+      rateTracker.updateFromServer(res.headers);
       // If server doesn't support streaming, collect full response
       if (!res.headers['content-type']?.includes('text/event-stream')) {
         let data = '';
@@ -470,7 +519,7 @@ function streamFreeTier(endpoint, messages) {
             const delta = parsed.choices?.[0]?.delta;
             // Grok-3-mini streams reasoning_content first, then content — skip reasoning
             if (delta?.reasoning_content && !delta?.content) continue;
-            const text = cleanOutput(delta?.content || '');
+            const text = delta?.content || '';
             if (text) {
               process.stdout.write(text);
               fullContent += text;
@@ -481,7 +530,6 @@ function streamFreeTier(endpoint, messages) {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
-        sessionState._lastStreamed = true;
         resolve({ content: fullContent, isRateLimit: false, streamed: true });
       });
     });
@@ -550,9 +598,8 @@ function streamAnthropic(key, messages, tools, system) {
 
               case 'content_block_delta':
                 if (event.delta?.type === 'text_delta') {
-                  const clean = cleanOutput(event.delta.text);
-                  process.stdout.write(clean);
-                  currentText += clean;
+                  process.stdout.write(event.delta.text);
+                  currentText += event.delta.text;
                 } else if (event.delta?.type === 'input_json_delta') {
                   const last = contentBlocks[contentBlocks.length - 1];
                   if (last?.type === 'tool_use') last.input += event.delta.partial_json;
@@ -581,7 +628,6 @@ function streamAnthropic(key, messages, tools, system) {
 
       res.on('end', () => {
         if (contentBlocks.some(b => b.type === 'text')) process.stdout.write('\n');
-        sessionState._lastStreamed = true;
         resolve({ content: contentBlocks, stop_reason: stopReason });
       });
     });
@@ -644,9 +690,8 @@ function streamOpenAI(key, messages, model = 'gpt-4o') {
             if (finish) finishReason = finish;
 
             if (delta?.content) {
-              const clean = cleanOutput(delta.content);
-              process.stdout.write(clean);
-              fullContent += clean;
+              process.stdout.write(delta.content);
+              fullContent += delta.content;
             }
 
             // Accumulate tool calls
@@ -668,7 +713,6 @@ function streamOpenAI(key, messages, model = 'gpt-4o') {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
-        sessionState._lastStreamed = true;
         toolCalls = toolCalls.filter(Boolean);
         resolve({ content: fullContent, tool_calls: toolCalls, finish_reason: finishReason });
       });
@@ -684,7 +728,7 @@ function streamOpenAI(key, messages, model = 'gpt-4o') {
 // ---------------------------------------------------------------------------
 // Streaming — Google Gemini API (gemini-2.0-flash)
 // ---------------------------------------------------------------------------
-function streamGemini(key, messages, model = 'gemini-2.0-flash') {
+function streamGemini(key, messages, model = 'gemini-2.0-flash', systemPrompt = null) {
   return new Promise((resolve, reject) => {
     const contents = messages.map(m => ({
       role: m.role === 'assistant' ? 'model' : 'user',
@@ -694,7 +738,7 @@ function streamGemini(key, messages, model = 'gemini-2.0-flash') {
     const body = JSON.stringify({
       contents,
       generationConfig: { maxOutputTokens: 4096 },
-      systemInstruction: { parts: [{ text: getSystemPrompt() }] },
+      systemInstruction: { parts: [{ text: systemPrompt || getSystemPrompt() }] },
     });
 
     const url = new URL(`https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${key}`);
@@ -725,7 +769,7 @@ function streamGemini(key, messages, model = 'gemini-2.0-flash') {
           if (!data) continue;
           try {
             const parsed = JSON.parse(data);
-            const text = cleanOutput(parsed.candidates?.[0]?.content?.parts?.[0]?.text || '');
+            const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text || '';
             if (text) {
               process.stdout.write(text);
               fullContent += text;
@@ -736,7 +780,6 @@ function streamGemini(key, messages, model = 'gemini-2.0-flash') {
 
       res.on('end', () => {
         if (fullContent) process.stdout.write('\n');
-        sessionState._lastStreamed = true;
         resolve({ content: fullContent });
       });
     });
@@ -754,14 +797,18 @@ function openAITools() {
     { name: 'read_file', description: 'Read the contents of a file on the user\'s machine.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Absolute or relative file path' } }, required: ['path'] } },
     { name: 'write_file', description: 'Write content to a file. Creates parent directories if needed. Use for creating new files, scripts, configs, diagrams (Mermaid, SVG, HTML), code files.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path to write' }, content: { type: 'string', description: 'Full content to write to the file' } }, required: ['path', 'content'] } },
     { name: 'list_files', description: 'List files and directories.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } } },
-    { name: 'edit_file', description: 'Edit a file by finding and replacing text. Use for targeted edits.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, search: { type: 'string', description: 'Exact text to find' }, replace: { type: 'string', description: 'Replacement text' } }, required: ['path', 'search', 'replace'] } },
-    { name: 'delete_file', description: 'Delete a file or empty directory.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Path to delete' } }, required: ['path'] } },
     { name: 'system_info', description: 'Get local system information (CPU, RAM, disk, OS, hostname).', parameters: { type: 'object', properties: {} } },
     { name: 'python_exec', description: 'Execute Python code inline. Use for data analysis, calculations, generating content, processing files, ML tasks.', parameters: { type: 'object', properties: { code: { type: 'string', description: 'Python code to execute' } }, required: ['code'] } },
     { name: 'python_pip', description: 'Install a Python package via pip.', parameters: { type: 'object', properties: { package: { type: 'string', description: 'Package name' } }, required: ['package'] } },
     { name: 'python_script', description: 'Run a Python script file.', parameters: { type: 'object', properties: { path: { type: 'string', description: 'Path to .py file' } }, required: ['path'] } },
     { name: 'sandbox_run', description: 'Run code in an isolated sandbox with syntax highlighting. Supports javascript, python, typescript.', parameters: { type: 'object', properties: { code: { type: 'string' }, language: { type: 'string', description: 'javascript, python, or typescript' } }, required: ['code'] } },
-    { name: 'founder_info', description: 'Answer questions about Lee Akpareva (founder of NAVADA Edge) using his full CV and career history. Always use this tool when asked about Lee, his career, experience, education, or projects.', parameters: { type: 'object', properties: { question: { type: 'string', description: 'The question about Lee' } }, required: ['question'] } },
+    { name: 'automation_request', description: 'Submit automation request for review. Types: email, marketing, build, data, schedule.', parameters: { type: 'object', properties: { title: { type: 'string' }, description: { type: 'string' }, type: { type: 'string' }, schedule: { type: 'string' } }, required: ['title', 'description'] } },
+    { name: 'web_search', description: 'Search the web.', parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] } },
+    { name: 'save_memory', description: 'Save to persistent memory.', parameters: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } }, required: ['key', 'value'] } },
+    { name: 'recall_memory', description: 'Recall saved memories.', parameters: { type: 'object', properties: { key: { type: 'string' } } } },
+    { name: 'screenshot', description: 'Take a screenshot.', parameters: { type: 'object', properties: { output: { type: 'string' } } } },
+    { name: 'describe_image', description: 'Analyze an image with AI vision.', parameters: { type: 'object', properties: { path: { type: 'string' }, question: { type: 'string' } }, required: ['path'] } },
+    { name: 'founder_info', description: 'Get information about Lee Akpareva, founder of NAVADA Edge.', parameters: { type: 'object', properties: {} } },
   ];
   return defs.map(d => ({ type: 'function', function: d }));
 }
@@ -779,7 +826,10 @@ async function openAIChat(key, userMessage, conversationHistory = []) {
     response = await streamOpenAI(key, messages, model);
   } catch (e) {
     if (e.message.includes('401') || e.message.includes('429') || e.message.includes('billing')) {
-      sessionState._openaiWarned = true;
+      if (!sessionState._openaiWarned) {
+        console.log(ui.warn('OpenAI API unavailable, using Grok free tier. /login with a valid key to switch.'));
+        sessionState._openaiWarned = true;
+      }
       return grokChat(userMessage, conversationHistory);
     }
     throw e;
@@ -827,15 +877,65 @@ function detectIntent(message) {
 }
 
 // ---------------------------------------------------------------------------
-// Anthropic Claude API — conversational agent with tool use
+// Prompt-based tool calling for providers without native function calling
 // ---------------------------------------------------------------------------
-async function chat(userMessage, conversationHistory = []) {
-  // Local action interceptor — file/folder ops work on ALL tiers without LLM
-  const localResult = tryLocalAction(userMessage);
-  if (localResult) {
-    return `${localResult}\n\nWhat would you like to do next?`;
+const TOOL_PROMPT_SUFFIX = `
+
+You have access to these tools. To use a tool, respond with a JSON block:
+\`\`\`tool
+{"name": "tool_name", "input": {"param": "value"}}
+\`\`\`
+
+Available tools:
+- shell: Execute shell command. Input: {"command": "string"}
+- read_file: Read file. Input: {"path": "string"}
+- write_file: Write file. Input: {"path": "string", "content": "string"}
+- list_files: List directory. Input: {"path": "string"}
+- system_info: System info. Input: {}
+- python_exec: Run Python. Input: {"code": "string"}
+- python_pip: Install pip package. Input: {"package": "string"}
+- python_script: Run .py file. Input: {"path": "string"}
+- sandbox_run: Run code in sandbox. Input: {"code": "string", "language": "javascript|python|typescript"}
+- automation_request: Submit automation request. Input: {"title": "string", "description": "string", "type": "email|marketing|build|data|schedule|custom", "schedule": "daily|weekly|cron|on-demand"}
+- web_search: Web search. Input: {"query": "string"}
+- save_memory: Save memory. Input: {"key": "string", "value": "string"}
+- recall_memory: Recall memory. Input: {"key": "string"} (key optional)
+- screenshot: Screenshot. Input: {"output": "filepath"}
+- describe_image: Analyze image. Input: {"path": "string", "question": "string"}
+- founder_info: NAVADA founder info. Input: {}
+
+After receiving a tool result, continue your response. Use multiple tools in sequence if needed.
+If no tool needed, respond normally without the tool block.`;
+
+function getToolEnhancedSystemPrompt() {
+  return getSystemPrompt() + TOOL_PROMPT_SUFFIX;
+}
+
+async function parseAndExecuteTools(content) {
+  const toolPattern = /```tool\s*\n?([\s\S]*?)\n?```/g;
+  let match;
+  let hasTools = false;
+  const toolResults = [];
+
+  while ((match = toolPattern.exec(content)) !== null) {
+    hasTools = true;
+    try {
+      const toolCall = JSON.parse(match[1].trim());
+      console.log(ui.dim(`  [${toolCall.name}] ${JSON.stringify(toolCall.input || {}).slice(0, 80)}`));
+      const result = await executeTool(toolCall.name, toolCall.input || {});
+      toolResults.push({ name: toolCall.name, result: typeof result === 'string' ? result : JSON.stringify(result) });
+    } catch (e) {
+      toolResults.push({ name: 'error', result: `Tool parse error: ${e.message}` });
+    }
   }
 
+  return { hasTools, toolResults };
+}
+
+// ---------------------------------------------------------------------------
+// Anthropic Claude API — conversational agent with tool use
+// ---------------------------------------------------------------------------
+async function chat(userMessage, conversationHistory = []) {
   const anthropicKey = config.get('anthropicKey') || process.env.ANTHROPIC_API_KEY || '';
   const openaiKey = config.get('openaiKey') || process.env.OPENAI_API_KEY || '';
   const nvidiaKey = config.get('nvidiaKey') || process.env.NVIDIA_API_KEY || '';
@@ -878,12 +978,29 @@ async function chat(userMessage, conversationHistory = []) {
       ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
       { role: 'user', content: userMessage },
     ];
+    process.stdout.write(ui.dim('  NAVADA > '));
     try {
-      process.stdout.write(ui.dim('  '));
-      const result = await streamGemini(effectiveGeminiKey, messages, geminiModel);
+      let result = await streamGemini(effectiveGeminiKey, messages, geminiModel, getToolEnhancedSystemPrompt());
+
+      // Prompt-based tool calling loop
+      let iterations = 0;
+      while (iterations < 5) {
+        const { hasTools, toolResults } = await parseAndExecuteTools(result.content);
+        if (!hasTools) break;
+        iterations++;
+        const toolResultText = toolResults.map(t => `Tool "${t.name}" returned:\n${t.result}`).join('\n\n');
+        messages.push({ role: 'assistant', content: result.content });
+        messages.push({ role: 'user', content: `Tool results:\n${toolResultText}\n\nContinue your response.` });
+        process.stdout.write(ui.dim('  NAVADA > '));
+        result = await streamGemini(effectiveGeminiKey, messages, geminiModel, getToolEnhancedSystemPrompt());
+      }
+
       return result.content;
     } catch (e) {
-      sessionState._geminiWarned = true;
+      if (!sessionState._geminiWarned) {
+        console.log(ui.warn('Gemini API unavailable, using Grok free tier.'));
+        sessionState._geminiWarned = true;
+      }
       return grokChat(userMessage, conversationHistory);
     }
   }
@@ -898,8 +1015,22 @@ async function chat(userMessage, conversationHistory = []) {
       ...conversationHistory.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) })),
       { role: 'user', content: userMessage },
     ];
-    process.stdout.write(ui.dim('  '));
-    const result = await streamNvidia(effectiveNvidiaKey, messages, nvidiaModel);
+    process.stdout.write(ui.dim('  NAVADA > '));
+    let result = await streamNvidia(effectiveNvidiaKey, messages, nvidiaModel, getToolEnhancedSystemPrompt());
+
+    // Prompt-based tool calling loop
+    let iterations = 0;
+    while (iterations < 5) {
+      const { hasTools, toolResults } = await parseAndExecuteTools(result.content);
+      if (!hasTools) break;
+      iterations++;
+      const toolResultText = toolResults.map(t => `Tool "${t.name}" returned:\n${t.result}`).join('\n\n');
+      messages.push({ role: 'assistant', content: result.content });
+      messages.push({ role: 'user', content: `Tool results:\n${toolResultText}\n\nContinue your response based on these results.` });
+      process.stdout.write(ui.dim('  NAVADA > '));
+      result = await streamNvidia(effectiveNvidiaKey, messages, nvidiaModel, getToolEnhancedSystemPrompt());
+    }
+
     return result.content;
   }
 
@@ -937,60 +1068,48 @@ async function chat(userMessage, conversationHistory = []) {
       description: 'List files and directories.',
       input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Directory path (default: current dir)' } } },
     },
-    {
-      name: 'edit_file',
-      description: 'Edit a file by finding and replacing text. Use for targeted edits without rewriting the whole file.',
-      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File path' }, search: { type: 'string', description: 'Exact text to find' }, replace: { type: 'string', description: 'Text to replace it with' } }, required: ['path', 'search', 'replace'] },
-    },
-    {
-      name: 'delete_file',
-      description: 'Delete a file or empty directory from the user\'s machine.',
-      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'File or directory path to delete' } }, required: ['path'] },
-    },
     {
       name: 'system_info',
       description: 'Get local system information (CPU, RAM, disk, OS, hostname).',
       input_schema: { type: 'object', properties: {} },
     },
+    // ── Automation Pipeline ──
     {
-      name: 'network_status',
-      description: 'Ping all NAVADA Edge Network nodes and cloud services.',
-      input_schema: { type: 'object', properties: {} },
-    },
-    {
-      name: 'lucas_exec',
-      description: 'Run a bash command on EC2 via Lucas CTO agent.',
-      input_schema: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] },
-    },
-    {
-      name: 'lucas_ssh',
-      description: 'SSH to a NAVADA Edge node (hp, ec2, oracle) and run a command via Lucas CTO.',
-      input_schema: { type: 'object', properties: { node: { type: 'string' }, command: { type: 'string' } }, required: ['node', 'command'] },
+      name: 'automation_request',
+      description: 'Submit an automation request to the NAVADA Edge team. Requests are queued for review and setup. Use for: scheduled emails, marketing campaigns, recurring tasks, app builds, data pipelines.',
+      input_schema: { type: 'object', properties: {
+        title: { type: 'string', description: 'Short title for the automation' },
+        description: { type: 'string', description: 'Detailed description of what to automate' },
+        type: { type: 'string', description: 'Type: email, marketing, build, data, schedule, custom' },
+        schedule: { type: 'string', description: 'When/how often: daily, weekly, cron expression, one-time' },
+      }, required: ['title', 'description'] },
     },
     {
-      name: 'lucas_docker',
-      description: 'Run a command inside a Docker container on EC2 via Lucas CTO.',
-      input_schema: { type: 'object', properties: { container: { type: 'string' }, command: { type: 'string' } }, required: ['container', 'command'] },
+      name: 'web_search',
+      description: 'Search the web for information.',
+      input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Search query' } }, required: ['query'] },
     },
+    // ── Memory Tools ──
     {
-      name: 'mcp_call',
-      description: 'Call a tool on the NAVADA Edge MCP server (18 tools: docker, ssh, files, database, monitoring).',
-      input_schema: { type: 'object', properties: { tool: { type: 'string' }, args: { type: 'object' } }, required: ['tool'] },
+      name: 'save_memory',
+      description: 'Save information to persistent memory for future sessions. Use for important context, preferences, or facts the user wants remembered.',
+      input_schema: { type: 'object', properties: { key: { type: 'string', description: 'Memory key (e.g. "preferred_language", "project_name")' }, value: { type: 'string', description: 'The information to remember' } }, required: ['key', 'value'] },
     },
     {
-      name: 'docker_registry',
-      description: 'List images or tags in the NAVADA private Docker registry.',
-      input_schema: { type: 'object', properties: { image: { type: 'string', description: 'Image name for tags (optional — omit to list all)' } } },
+      name: 'recall_memory',
+      description: 'Recall previously saved memories. Use when user references past conversations or saved context.',
+      input_schema: { type: 'object', properties: { key: { type: 'string', description: 'Specific key to recall (optional — omit to list all)' } } },
     },
+    // ── Perception Tools ──
     {
-      name: 'send_email',
-      description: 'Send an email via the NAVADA Edge MCP email tool.',
-      input_schema: { type: 'object', properties: { to: { type: 'string' }, subject: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'subject', 'body'] },
+      name: 'screenshot',
+      description: 'Take a screenshot of the current screen and save it.',
+      input_schema: { type: 'object', properties: { output: { type: 'string', description: 'Output file path (default: screenshot.png)' } } },
     },
     {
-      name: 'generate_image',
-      description: 'Generate an image using Cloudflare Flux (FREE) or DALL-E.',
-      input_schema: { type: 'object', properties: { prompt: { type: 'string' }, provider: { type: 'string', description: 'flux (default, free) or dalle' } }, required: ['prompt'] },
+      name: 'describe_image',
+      description: 'Describe or analyze an image file using AI vision.',
+      input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Path to image file' }, question: { type: 'string', description: 'What to analyze about the image' } }, required: ['path'] },
     },
     {
       name: 'python_exec',
@@ -1014,8 +1133,8 @@ async function chat(userMessage, conversationHistory = []) {
     },
     {
       name: 'founder_info',
-      description: 'Answer questions about Lee Akpareva (founder of NAVADA Edge) using his full CV and career history. Always use this tool when asked about Lee, his career, experience, education, certifications, or projects.',
-      input_schema: { type: 'object', properties: { question: { type: 'string', description: 'The question about Lee' } }, required: ['question'] },
+      description: 'Get information about Lee Akpareva, founder of NAVADA Edge Network. Use when asked about the creator, founder, Lee, or who made NAVADA.',
+      input_schema: { type: 'object', properties: {} },
     },
   ];
 
@@ -1032,7 +1151,10 @@ async function chat(userMessage, conversationHistory = []) {
     const errMsg = e.message || '';
     // If billing/rate limit/auth error, fall back to free tier
     if (errMsg.includes('400') || errMsg.includes('401') || errMsg.includes('429') || errMsg.includes('usage limits')) {
-      sessionState._anthropicWarned = true;
+      if (!sessionState._anthropicWarned) {
+        console.log(ui.warn('Anthropic API unavailable, using Grok free tier. /login with a valid key to switch.'));
+        sessionState._anthropicWarned = true;
+      }
       return grokChat(userMessage, conversationHistory);
     }
     throw e;
@@ -1068,22 +1190,100 @@ async function executeTool(name, input) {
       case 'read_file': return localTools.readFile.execute(input.path);
       case 'write_file': return localTools.writeFile.execute(input.path, input.content);
       case 'list_files': return localTools.listFiles.execute(input.path);
-      case 'edit_file': return localTools.editFile.execute(input.path, input.search, input.replace);
-      case 'delete_file': return localTools.deleteFile.execute(input.path);
       case 'system_info': return localTools.systemInfo.execute();
-      case 'network_status': return JSON.stringify(await navada.network.ping());
-      case 'lucas_exec': return JSON.stringify(await navada.lucas.exec(input.command));
-      case 'lucas_ssh': return JSON.stringify(await navada.lucas.ssh(input.node, input.command));
-      case 'lucas_docker': return JSON.stringify(await navada.lucas.docker(input.container, input.command));
-      case 'mcp_call': return JSON.stringify(await navada.mcp.call(input.tool, input.args || {}));
-      case 'docker_registry':
-        if (input.image) return JSON.stringify(await navada.registry.tags(input.image));
-        return JSON.stringify(await navada.registry.catalog());
-      case 'send_email': return JSON.stringify(await navada.mcp.call('send-email', input));
-      case 'generate_image':
-        if (input.provider === 'dalle') return JSON.stringify(await navada.ai.openai.image(input.prompt));
-        const { size } = await navada.cloudflare.flux.generate(input.prompt, { savePath: `navada-${Date.now()}.png` });
-        return `Image generated: ${size} bytes`;
+      case 'automation_request': {
+        try {
+          const edgeKey = config.get('edgeKey');
+          const userId = config.get('edgeUserId') || 'anonymous';
+          const email = config.get('edgeEmail') || '';
+          const requestId = `req_${crypto.randomUUID().slice(0, 8)}`;
+          const request = {
+            id: requestId,
+            title: input.title,
+            description: input.description,
+            type: input.type || 'custom',
+            schedule: input.schedule || 'on-demand',
+            userId,
+            email,
+            status: 'pending',
+            submittedAt: new Date().toISOString(),
+          };
+          // Submit to NAVADA queue API
+          const r = await navadaEdgeRequest('POST', '/api/v1/queue/automation', request);
+          if (r.status === 201 || r.status === 200) {
+            return `Automation request submitted!\n  ID: ${requestId}\n  Title: ${input.title}\n  Status: Pending review\n\nYou'll receive an email once your automation is set up.`;
+          }
+          return `Request submitted locally (ID: ${requestId}). Server confirmation pending.`;
+        } catch (e) {
+          // Save locally if API unavailable
+          const reqDir = path.join(config.CONFIG_DIR, 'requests');
+          if (!fs.existsSync(reqDir)) fs.mkdirSync(reqDir, { recursive: true });
+          const requestId = `req_${Date.now()}`;
+          const request = { id: requestId, title: input.title, description: input.description, type: input.type || 'custom', schedule: input.schedule || 'on-demand', status: 'queued_locally', submittedAt: new Date().toISOString() };
+          fs.writeFileSync(path.join(reqDir, `${requestId}.json`), JSON.stringify(request, null, 2));
+          return `Request saved locally (ID: ${requestId}). Will sync when connected.\nCheck status: /requests`;
+        }
+      }
+      case 'web_search': {
+        try {
+          const r = await navadaEdgeRequest('POST', '/search', { query: input.query });
+          return r.data?.results ? JSON.stringify(r.data.results) : JSON.stringify(r.data);
+        } catch (e) { return `Search error: ${e.message}`; }
+      }
+      // ── Memory tools ──
+      case 'save_memory': {
+        // Tier 3 — save to semantic knowledge base
+        const category = input.key?.includes('pref') ? 'preferences'
+          : input.key?.includes('person') || input.key?.includes('name') ? 'people'
+          : input.key?.includes('decision') ? 'decisions'
+          : 'facts';
+        memory.knowledge.add(category, `${input.key}: ${input.value}`);
+        return `Remembered: "${input.key}" → "${input.value}"`;
+      }
+      case 'recall_memory': {
+        if (input.key) {
+          // Search across all knowledge
+          const results = memory.knowledge.search(input.key, 5);
+          if (results.length === 0) {
+            // Also check episodes
+            const episodes = memory.episodic.search(input.key);
+            if (episodes.length > 0) {
+              return episodes.map(e => `[${e.date}] ${e.summary}`).join('\n');
+            }
+            return `No memories found for: "${input.key}"`;
+          }
+          return results.map(r => `[${r.category}] ${r.content}`).join('\n');
+        }
+        // No key — return knowledge summary + episode count
+        const stats = memory.knowledge.stats();
+        const epCount = memory.episodic.count();
+        const summary = memory.knowledge.getSummary();
+        const statsLine = Object.entries(stats).map(([k, v]) => `${k}: ${v}`).join(', ');
+        return `Memory: ${statsLine}, episodes: ${epCount}\n${summary || 'No knowledge stored yet.'}`;
+      }
+      // ── Perception tools ──
+      case 'screenshot': {
+        try {
+          const outPath = path.resolve(input.output || 'screenshot.png');
+          const py = process.platform === 'win32' ? 'python' : 'python3';
+          execFileSync(py, ['-c', `from PIL import ImageGrab; img = ImageGrab.grab(); img.save(r'${outPath}')`], { timeout: 15000, encoding: 'utf-8' });
+          return `Screenshot saved: ${outPath}`;
+        } catch (e) { return `Screenshot failed: ${e.message}. Install Pillow: pip install Pillow`; }
+      }
+      case 'describe_image': {
+        try {
+          const imgPath = path.resolve(input.path);
+          if (!fs.existsSync(imgPath)) return `Image not found: ${imgPath}`;
+          const imgData = fs.readFileSync(imgPath).toString('base64');
+          const mimeType = imgPath.endsWith('.png') ? 'image/png' : 'image/jpeg';
+          const edgeKey = config.get('edgeKey');
+          if (edgeKey) {
+            const r = await navadaEdgeRequest('POST', '/vision', { image: imgData, mimeType, question: input.question || 'Describe this image.' });
+            if (r.status === 200) return r.data?.description || JSON.stringify(r.data);
+          }
+          return `Image loaded (${(imgData.length / 1024).toFixed(0)}KB). Vision API requires Edge connection (/edge login).`;
+        } catch (e) { return `Vision error: ${e.message}`; }
+      }
       case 'python_exec': return localTools.pythonExec.execute(input.code);
       case 'python_pip': return localTools.pythonPip.execute(input.package);
       case 'python_script': return localTools.pythonScript.execute(input.path);
@@ -1094,7 +1294,7 @@ async function executeTool(name, input) {
         displayOutput(result);
         return result.error ? `Error (exit ${result.exitCode}): ${result.error}` : result.output;
       }
-      case 'founder_info': return localTools.founderInfo.execute(input.question);
+      case 'founder_info': return localTools.founderInfo.execute();
       default: return `Unknown tool: ${name}`;
     }
   } catch (e) {
@@ -1102,110 +1302,6 @@ async function executeTool(name, input) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Local action interceptor — executes file/shell actions WITHOUT needing LLM tool use
-// This ensures free tier users can still create, read, edit, delete files
-// ---------------------------------------------------------------------------
-function tryLocalAction(userMessage) {
-  const msg = userMessage.trim();
-  const home = os.homedir();
-  // Windows OneDrive redirects Desktop — check OneDrive first
-  const oneDriveDesktop = path.join(home, 'OneDrive', 'Desktop');
-  const desktop = (process.platform === 'win32' && fs.existsSync(oneDriveDesktop)) ? oneDriveDesktop : path.join(home, 'Desktop');
-
-  // Resolve a location phrase to an absolute path (use ORIGINAL case, not lowered)
-  function resolveLocation(phrase) {
-    const p = phrase.trim().replace(/[""'.,!]/g, '');
-    const low = p.toLowerCase();
-    if (low === 'my desktop' || low === 'the desktop' || low === 'desktop') return desktop;
-    if (low === 'home' || low === 'my home' || low === 'home directory') return home;
-    if (p.startsWith('~')) return p.replace(/^~[/\\]?/, home + path.sep);
-    if (path.isAbsolute(p)) return p;
-    return path.join(process.cwd(), p);
-  }
-
-  // Extract the ORIGINAL-CASE name from the original message using a case-insensitive match
-  // We match on the original message to preserve casing
-  let m;
-
-  // ── Create folder/directory ──
-  // Pattern: "create a folder called NAME on my desktop"
-  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s+(?:on|at|in)\s+(.+?)$/i);
-  if (m) {
-    const name = m[1].trim();
-    const loc = resolveLocation(m[2]);
-    const resolved = path.join(loc, name);
-    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
-    catch (e) { return null; }
-  }
-
-  // Pattern: "create a folder on my desktop called NAME"
-  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:on|at|in)\s+(.+?)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
-  if (m) {
-    const loc = resolveLocation(m[1]);
-    const name = m[2].trim();
-    const resolved = path.join(loc, name);
-    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
-    catch (e) { return null; }
-  }
-
-  // Pattern: "create a folder called NAME" (no location — use cwd, or desktop if mentioned earlier)
-  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
-  if (m) {
-    const name = m[1].trim();
-    const loc = msg.toLowerCase().includes('desktop') ? desktop : process.cwd();
-    const resolved = path.join(loc, name);
-    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
-    catch (e) { return null; }
-  }
-
-  // Pattern: "create a new folder NAME on my desktop" (no "called/named")
-  m = msg.match(/(?:create|make|new)\s+(?:a\s+)?(?:new\s+)?(?:folder|directory|dir)\s+([A-Za-z0-9_\-. ]+?)\s+(?:on|at|in)\s+(.+?)$/i);
-  if (m) {
-    const name = m[1].trim();
-    const loc = resolveLocation(m[2]);
-    const resolved = path.join(loc, name);
-    try { fs.mkdirSync(resolved, { recursive: true }); return `Created folder: ${resolved}`; }
-    catch (e) { return null; }
-  }
-
-  // ── Create file ──
-  m = msg.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s+(?:on|at|in)\s+(.+?)$/i);
-  if (m) {
-    const resolved = path.join(resolveLocation(m[2]), m[1].trim());
-    return localTools.writeFile.execute(resolved, '');
-  }
-  m = msg.match(/(?:create|make|new|touch)\s+(?:a\s+)?(?:new\s+)?(?:file)\s+(?:called|named)\s+[""']?([^""']+?)[""']?\s*$/i);
-  if (m) {
-    const loc = msg.toLowerCase().includes('desktop') ? desktop : process.cwd();
-    return localTools.writeFile.execute(path.join(loc, m[1].trim()), '');
-  }
-
-  // ── Read file ──
-  m = msg.match(/(?:read|show|display|cat|open)\s+(?:the\s+)?(?:file\s+)?[""']?([^""']+\.\w{1,5})[""']?/i);
-  if (m) {
-    const p = m[1].trim();
-    const filePath = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
-    return localTools.readFile.execute(filePath);
-  }
-
-  // ── Delete file/folder ──
-  m = msg.match(/(?:delete|remove|rm)\s+(?:the\s+)?(?:file|folder|directory)\s+[""']?([^""']+?)[""']?\s*$/i);
-  if (m) {
-    const p = m[1].trim();
-    const filePath = path.isAbsolute(p) ? p : path.join(process.cwd(), p);
-    return localTools.deleteFile.execute(filePath);
-  }
-
-  // ── List files ──
-  m = msg.match(/(?:list|show|ls|dir)\s+(?:the\s+)?(?:files|contents|items)\s+(?:in|on|at|of)\s+(.+)/i);
-  if (m) {
-    return localTools.listFiles.execute(resolveLocation(m[1]));
-  }
-
-  return null;
-}
-
 async function grokChat(userMessage, conversationHistory = []) {
   const messages = [
     ...conversationHistory.slice(-20).map(m => ({
@@ -1225,6 +1321,7 @@ async function grokChat(userMessage, conversationHistory = []) {
     const r = await navada.request(endpoint, {
       method: 'POST',
       body: { messages, tools },
+      headers: navadaAuthHeaders(),
       timeout: 120000,
     });
 
@@ -1269,6 +1366,7 @@ async function grokChat(userMessage, conversationHistory = []) {
       const r = await navada.request(endpoint, {
         method: 'POST',
         body: { messages, tools },
+        headers: navadaAuthHeaders(),
         timeout: 120000,
       });
       if (r.status !== 200) break;
@@ -1279,7 +1377,8 @@ async function grokChat(userMessage, conversationHistory = []) {
 
   // Extract final text
   const content = response?.choices?.[0]?.message?.content || '';
-  return cleanOutput(content) || 'No response.';
+  if (content) console.log(`  ${content}`);
+  return content || 'No response.';
 }
 
 async function fallbackChat(msg) {
@@ -1310,6 +1409,14 @@ async function fallbackChat(msg) {
 // ---------------------------------------------------------------------------
 let _updateInfo = null;
 
+// Auto-save session episode on exit
+process.on('beforeExit', () => {
+  try { memory.manager.saveSessionEpisode(); } catch {}
+});
+process.on('SIGINT', () => {
+  try { memory.manager.saveSessionEpisode(); } catch {}
+});
+
 async function checkForUpdate() {
   try {
     const pkg = require('../package.json');
@@ -1335,6 +1442,7 @@ async function reportTelemetry(event, data = {}) {
     try {
       await navada.request(base + '/api/agent-heartbeat', {
         method: 'POST',
+        headers: navadaAuthHeaders(),
         body: {
           agent: 'navada-edge-cli',
           event,
@@ -1354,4 +1462,4 @@ async function reportTelemetry(event, data = {}) {
   }
 }
 
-module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker, sessionState, addToHistory, getConversationHistory, clearHistory, listSubAgents };
+module.exports = { IDENTITY, chat, localTools, reportTelemetry, fallbackChat, checkForUpdate, getUpdateInfo, rateTracker, sessionState, addToHistory, getConversationHistory, clearHistory, listSubAgents, memory };