create-walle 0.1.0

package/template/wall-e/chat.js

@@ -0,0 +1,778 @@
+'use strict';
+const Anthropic = require('@anthropic-ai/sdk');
+const brain = require('./brain');
+const { buildClientOpts } = require('./extraction/knowledge-extractor');
+const { executeLocalTool, LOCAL_TOOL_DEFINITIONS } = require('./tools/local-tools');
+const slackMcp = require('./tools/slack-mcp');
+
+/**
+ * Core "talk to WALL-E" handler.
+ * Builds a system prompt from brain context and calls Claude.
+ */
+function ensureBrainInit() {
+  try { brain.getDb(); } catch {
+    brain.initDb();
+  }
+}
+
+async function chat(message, opts = {}) {
+  ensureBrainInit();
+  const ownerName = brain.getOwnerName() || 'Owner';
+  const channel = opts.channel || 'ctm';
+
+  // Build brain context — pull ALL available data so WALL-E can answer directly
+  const knowledge = brain.findKnowledge({ status: 'active' });
+  const recentMemories = brain.listMemories({ limit: 20 });
+  const people = brain.listPeople({});
+  const stats = brain.getBrainStats();
+  const pendingQuestions = brain.listQuestions({ status: 'pending', limit: 5 });
+  const skills = brain.listSkills({});
+  let domainConfidences = [];
+  try { domainConfidences = brain.getDb().prepare('SELECT * FROM domain_confidence').all(); } catch {}
+
+  // Pull a diverse sample of Slack messages to give WALL-E personality/style context
+  let slackSample = '';
+  try {
+    const db = brain.getDb();
+    // Get a spread of Slack messages across time — owner's outbound messages reveal personality
+    const slackMsgs = db.prepare(`
+      SELECT content, source_channel, timestamp FROM memories
+      WHERE source = 'slack' AND direction = 'outbound' AND length(content) > 20
+      ORDER BY RANDOM() LIMIT 20
+    `).all();
+    if (slackMsgs.length > 0) {
+      slackSample = slackMsgs.map(m => {
+        const date = m.timestamp ? m.timestamp.slice(0, 10) : '';
+        return `[${date} #${m.source_channel || '?'}] ${(m.content || '').slice(0, 200)}`;
+      }).join('\n');
+    }
+  } catch {}
+
+  // Load available MCP servers so WALL-E knows what it can connect to
+  let mcpServerList = '';
+  try {
+    const { loadMcpConfigs } = require('./skills/mcp-client');
+    const configs = loadMcpConfigs();
+    mcpServerList = Object.entries(configs).map(([name, cfg]) => {
+      const hasAuth = cfg.oauth?.accessToken ? 'authenticated' : 'needs auth';
+      return `- ${name}: ${cfg.type || 'stdio'} (${cfg.url || cfg.command || 'local'}) [${hasAuth}]`;
+    }).join('\n');
+  } catch {}
+
+  // Build knowledge summary
+  const knowledgeSummary = knowledge.slice(0, 50).map(k =>
+    `- ${k.subject} ${k.predicate} ${k.object} (${Math.round((k.confidence || 0.5) * 100)}%)`
+  ).join('\n');
+
+  // Recent memories summary — prefer Slack over CTM tool calls
+  const slackRecent = brain.getDb().prepare(`
+    SELECT content, timestamp, source_channel FROM memories
+    WHERE source = 'slack' AND direction = 'outbound' AND length(content) > 20
+    ORDER BY timestamp DESC LIMIT 10
+  `).all();
+  const memorySummary = slackRecent.map(m =>
+    `[${m.timestamp?.slice(0, 10)} ${m.source_channel || 'DM'}] ${m.content?.slice(0, 200)}`
+  ).join('\n');
+
+  // Load pre-computed metadata for richer context
+  let peopleMeta = '', topicMeta = '', slackCoverage = '';
+  try {
+    const getMeta = brain.getDb().prepare('SELECT value FROM brain_metadata WHERE key = ?');
+    peopleMeta = getMeta.get('people_interaction_summary')?.value || '';
+    topicMeta = getMeta.get('topic_frequency')?.value || '';
+    slackCoverage = getMeta.get('slack_coverage')?.value || '';
+  } catch {}
+
+  // People summary
+  const peopleSummary = people.map(p =>
+    `- ${p.name}: ${p.relationship || 'unknown'} (trust: ${p.trust_level || 0.5})`
+  ).join('\n');
+
+  // Pending questions
+  const questionsSummary = pendingQuestions.map(q =>
+    `- [${q.question_type}] ${q.question}`
+  ).join('\n');
+
+  // Skills summary
+  const skillsSummary = skills.map(s => {
+    const rate = (s.success_count + s.failure_count) > 0
+      ? Math.round(s.success_count / (s.success_count + s.failure_count) * 100) + '%' : 'not run yet';
+    return `- ${s.name}: ${s.description || 'no description'} (${s.enabled ? 'enabled' : 'disabled'}, success rate: ${rate})`;
+  }).join('\n');
+
+  // Memory source breakdown
+  let sourceBreakdown = '';
+  try {
+    const sources = brain.getDb().prepare('SELECT source, count(*) as c FROM memories GROUP BY source ORDER BY c DESC').all();
+    sourceBreakdown = sources.map(s => `- ${s.source}: ${s.c} memories`).join('\n');
+  } catch {}
+
+  // Domain confidence summary
+  const tierNames = { 1: 'Observe', 2: 'Draft', 3: 'Guarded', 4: 'Autonomous' };
+  const confidenceSummary = domainConfidences.map(dc =>
+    `- ${dc.domain}: Tier ${dc.current_tier} (${tierNames[dc.current_tier] || '?'}), ${dc.approved_actions}/${dc.total_actions} approved`
+  ).join('\n');
+
+  const systemPrompt = `You are WALL-E, ${ownerName}'s personal digital twin. You know ${ownerName} deeply through ${stats.memory_count} memories including ${slackCoverage || '1500+ Slack messages'}.
+
+## ${ownerName}'s Key Relationships (by message volume)
+${peopleMeta || peopleSummary || 'No people data yet.'}
+
+## Topics ${ownerName} Cares About (by frequency in conversations)
+${topicMeta || 'No topic data yet.'}
+
+## Knowledge Base
+${knowledgeSummary || 'Still learning...'}
+
+## Recent Slack Messages (${ownerName}'s actual words)
+${memorySummary || 'No recent activity.'}
+
+${slackSample ? `## ${ownerName}'s Voice — Random Sample\n${slackSample}` : ''}
+
+## Memory Sources
+${sourceBreakdown || 'No breakdown available'}
+
+## Skills & Tools
+${skillsSummary || 'No skills configured yet.'}
+MCP Servers: ${mcpServerList || 'None'}
+
+${pendingQuestions.length > 0 ? `## Questions Pending\n${questionsSummary}` : ''}
+
+## How to Reason and Respond
+
+### Step 1: SEARCH — gather evidence (call ALL searches in ONE turn)
+For ANY question beyond small talk, call search_memories MULTIPLE TIMES IN THE SAME TURN. Do NOT do one search per turn — batch them all together.
+Example: if asked about leadership, call these ALL AT ONCE in one response:
+- search_memories({query: "leadership coaching feedback"})
+- search_memories({query: "团队 管理 反馈", source: "slack"})
+- search_memories({query: "Danni Mengyang Zohaib"})
+
+### Step 2: THINK — reason through the evidence (same turn as search results if possible)
+After gathering evidence, ALWAYS use the **think** tool before responding. This is your internal scratchpad — ${ownerName} won't see it. Use it to:
+
+**Analyze patterns, not just surface content:**
+- What does the evidence ACTUALLY show vs what it SEEMS to show?
+- Am I attributing behavior correctly? (Is this ${ownerName}'s gap, or someone else's?)
+- What's the counterargument? What evidence contradicts my initial take?
+- Are there multiple interpretations of the same message?
+
+**Challenge your own conclusions:**
+- If I'm about to say "${ownerName} does X poorly" — do I have 3+ examples? Or am I over-generalizing from one message?
+- Could this behavior be DELIBERATE and STRATEGIC rather than a gap?
+- What's the full context? Who was ${ownerName} talking to, and why?
+
+**Think about nuance:**
+- ${ownerName} is a director managing 60+ engineers. What looks like "venting" might be calculated information sharing.
+- What looks like "brevity" might be appropriate trust-based communication with close reports.
+- What looks like "delegating the hard conversation" might be empowering direct reports.
+
+### Step 3: RESPOND — with depth and nuance
+- Use **bold** for key names, dates, and decisions
+- Use > blockquotes when quoting actual Slack messages
+- Use ### headers to organize multi-part answers
+- Include dates and people: "On **2024-12-12**, you told **Zohaib**: ..."
+- **Bilingual-aware**: Translate Chinese quotes — they contain the most candid opinions
+- Present BOTH sides before drawing conclusions
+- Acknowledge where the evidence is thin or ambiguous
+
+### What makes a DEEP answer vs a SHALLOW one
+**SHALLOW** (bad): "You sometimes vent in group DMs" → no examples, no analysis of WHY
+**DEEP** (good): "You coached Xiao Bai on venting technique (Dec 2023), but in your own group DMs you do X, Y, Z — however, this may be intentional because your audience (Sonic, Mengyang) is your inner circle where candor is valued"
+
+### Tool usage
+- **think**: Internal reasoning scratchpad. Use BEFORE every substantive response. ${ownerName} won't see this.
+- **search_memories**: Full-text search with BM25 ranking. Use source:"slack" for Slack only.
+- remember_fact: Store new knowledge the user teaches you.
+- run_skill, mcp_call, list_mcp_tools: For actions and external services.
+
+### Local Machine Tools (macOS)
+- **web_fetch**: Fetch any URL — weather, news, APIs, documentation. Use for ALL real-time data requests.
+- **run_shell**: Execute shell commands (git, node, grep, mdfind, open, etc.). Destructive commands blocked.
+- **read_file / write_file**: Read or write local files (under $HOME).
+- **search_files**: Spotlight search (mdfind) for fast file discovery.
+- **clipboard_read / clipboard_write**: System clipboard access.
+- **open_url / open_app**: Open URLs in browser or launch macOS apps.
+- **notification**: Show macOS notification banner.
+- **applescript**: Run AppleScript for deep macOS automation (Finder, Mail, etc.).
+- **calendar_events / calendar_create**: Read/create events in macOS Calendar.
+- **reminder_create**: Create reminders in macOS Reminders app.
+- **screenshot**: Capture screen to file.
+- **system_info**: Get macOS version, uptime, disk space.
+
+**IMPORTANT**: You are an AGENT, not just a chatbot. NEVER say "I can't access that" or "I don't have access to real-time data." You have tools — USE THEM.
+
+**Location awareness**: When ${ownerName} asks location-dependent questions (weather, "where am I", local time, nearby places), FIRST determine their current location by:
+1. Check calendar_events for travel/meetings that reveal location
+2. Search memories for recent travel plans or location mentions
+3. Only after determining location, fetch the relevant data
+
+**Weather**: Use web_fetch with Open-Meteo API (free, no key needed):
+\`https://api.open-meteo.com/v1/forecast?latitude=LAT&longitude=LON&current=temperature_2m,apparent_temperature,weather_code,wind_speed_10m,relative_humidity_2m&timezone=auto\`
+Common coords: Seattle(47.61,-122.33), London(51.51,-0.13), Helsinki(60.17,24.94), San Francisco(37.77,-122.42), Beijing(39.90,116.40)
+Weather codes: 0=clear, 1-3=partly cloudy, 45-48=fog, 51-55=drizzle, 61-65=rain, 71-77=snow, 80-82=showers, 95-99=thunderstorm
+
+When ${ownerName} asks you to DO something (create a file, set a reminder, search for a document, etc.), use these tools directly.
+- Channel: ${channel}${channel === 'imessage' ? ' (keep responses brief)' : ''}`;
+
+  // Use injected client (for testing) or build one from env
+  const client = _clientOverride || getClientForChat();
+
+  // Per-turn abort controller — each API call gets its own 2-min timeout.
+  // This prevents long multi-turn tasks (e.g., Morning Briefing) from aborting
+  // as long as each individual turn completes within the timeout.
+  let controller = new AbortController();
+  let timeout = null;
+  function resetTurnTimeout() {
+    if (timeout) clearTimeout(timeout);
+    controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), 120000); // 2 min per turn
+  }
+
+  // Define internal tools WALL-E can use during chat
+  const chatTools = [
+    {
+      name: 'think',
+      description: 'Internal reasoning scratchpad. Use this BEFORE every substantive response to analyze evidence, challenge assumptions, consider counterarguments, and build a nuanced take. The user will NOT see this output — it is purely for your reasoning process. Think like a thoughtful advisor, not a search engine.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          reasoning: {
+            type: 'string',
+            description: 'Your internal analysis: What does the evidence show? What are the counterarguments? What nuance am I missing? Is my conclusion actually supported?'
+          }
+        },
+        required: ['reasoning']
+      },
+    },
+    {
+      name: 'run_skill',
+      description: 'Run one of my skills to fetch data or perform an action. Use this when the user asks me to do something actionable.',
+      input_schema: { type: 'object', properties: { skill_name: { type: 'string', description: 'Name of the skill to run' } }, required: ['skill_name'] },
+    },
+    {
+      name: 'search_memories',
+      description: 'Full-text search with BM25 relevance ranking. Call MULTIPLE searches in ONE turn to batch them. Supports: multi-word (auto-OR), prefix ("lead*"), phrases, source filtering.',
+      input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Search query. Multi-word = OR. Prefix: "lead*". Phrase: quoted.' }, source: { type: 'string', description: 'Filter: slack, ctm, wall-e-chat' }, limit: { type: 'number', default: 15 } }, required: ['query'] },
+    },
+    {
+      name: 'lookup_person',
+      description: 'Get detailed info about a person I know.',
+      input_schema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+    },
+    {
+      name: 'remember_fact',
+      description: 'Store a new fact the user tells me as knowledge.',
+      input_schema: { type: 'object', properties: { subject: { type: 'string' }, predicate: { type: 'string' }, object: { type: 'string' }, category: { type: 'string', enum: ['technical', 'preference', 'relationship', 'work', 'personal', 'world'] } }, required: ['subject', 'predicate', 'object', 'category'] },
+    },
+    {
+      name: 'mcp_call',
+      description: 'Call a tool on an MCP server (e.g., search Slack, send email). Use list_mcp_tools first to see available tools.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          server: { type: 'string', description: 'MCP server name' },
+          tool: { type: 'string', description: 'Tool name' },
+          arguments: { type: 'object', description: 'Tool arguments' },
+        },
+        required: ['server', 'tool'],
+      },
+    },
+    {
+      name: 'list_mcp_tools',
+      description: 'List available MCP tools from all connected servers.',
+      input_schema: { type: 'object', properties: {} },
+    },
+    // Direct Slack access (auto-authenticates on first use)
+    {
+      name: 'pull_slack',
+      description: 'Pull Slack messages into WALL-E\'s brain. mode="incremental" (default) only fetches new messages. mode="full" does a complete month-by-month backfill from 2022 to now. Both modes skip duplicates.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          mode: { type: 'string', enum: ['incremental', 'full'], description: 'incremental (only new) or full (all history month by month)' },
+        },
+      },
+    },
+    {
+      name: 'slack_connect',
+      description: 'Connect WALL-E to Slack. Opens browser for OAuth login. Only needed if Slack tools fail with auth errors.',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'slack_search',
+      description: 'Search Slack messages in real-time. Auto-connects if not authenticated. Use for finding recent conversations, mentions, or topics.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query (supports Slack search syntax: from:user, in:channel, before:date, etc.)' },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'slack_read_channel',
+      description: 'Read recent messages from a Slack channel or DM. Auto-connects if not authenticated.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel_name: { type: 'string', description: 'Channel name (without #) or user name for DMs' },
+          limit: { type: 'number', description: 'Number of messages (default 20)' },
+        },
+        required: ['channel_name'],
+      },
+    },
+    {
+      name: 'slack_send_message',
+      description: 'Send a message to a Slack channel or DM. Use only when explicitly asked to send. Auto-connects if not authenticated.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel_name: { type: 'string', description: 'Channel name (without #) or user name for DMs' },
+          message: { type: 'string', description: 'Message text (supports Slack mrkdwn)' },
+        },
+        required: ['channel_name', 'message'],
+      },
+    },
+    // Task management
+    {
+      name: 'create_task',
+      description: 'Create a background task for WALL-E to work on. Tasks run asynchronously — results appear in the Tasks tab. Use for: research, monitoring, scheduled actions, anything that takes time.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'Short task title' },
+          description: { type: 'string', description: 'Detailed instructions for what to do' },
+          priority: { type: 'string', enum: ['urgent', 'high', 'normal', 'low'] },
+          due_at: { type: 'string', description: 'When to execute (ISO datetime). Omit for immediate.' },
+          type: { type: 'string', enum: ['once', 'recurring'] },
+          schedule: { type: 'string', description: 'For recurring: "hourly", "daily", "weekly", or "every 2h"' },
+        },
+        required: ['title', 'description'],
+      },
+    },
+    {
+      name: 'list_tasks',
+      description: 'List current tasks and their status.',
+      input_schema: {
+        type: 'object',
+        properties: { status: { type: 'string', enum: ['pending', 'running', 'completed', 'failed'] } },
+      },
+    },
+    // Local machine tools — file ops, shell, macOS automation, calendar, etc.
+    ...LOCAL_TOOL_DEFINITIONS,
+  ];
+
+  const onProgress = opts.onProgress || (() => {});
+
+  // Execute a chat tool call
+  async function executeChatTool(name, input) {
+    if (name === 'think') {
+      // Internal reasoning tool — just acknowledge it. The reasoning is in the tool call itself
+      // which becomes part of the conversation context for Claude's next response.
+      console.log('[chat] Think tool used:', (input.reasoning || '').slice(0, 200));
+      return { acknowledged: true };
+    }
+    if (name === 'run_skill') {
+      const skill = brain.getSkillByName(input.skill_name);
+      if (!skill) return { error: `Skill "${input.skill_name}" not found` };
+      try {
+        const { runSkill } = require('./skills/skill-executor');
+        const result = await runSkill(skill);
+        return { success: true, memories_created: result.memoriesCreated, tool_calls: result.toolCalls, duration_ms: result.duration };
+      } catch (err) {
+        return { error: err.message };
+      }
+    }
+    if (name === 'search_memories') {
+      // FTS5 full-text search with BM25 ranking
+      console.log('[chat] search_memories called with input:', JSON.stringify(input));
+      const db = brain.getDb();
+      const limit = input.limit || 30;
+      let results = [];
+
+      // Check if FTS5 table exists
+      const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+
+      if (hasFts && input.query) {
+        try {
+          // Build FTS5 MATCH query
+          let terms = input.query.split('|').map(t => t.trim()).filter(Boolean);
+          if (terms.length === 1 && terms[0].includes(' ')) {
+            terms = terms[0].split(/\s+/).filter(t => t.length >= 2);
+          }
+          // FTS5 OR query: "word1 OR word2 OR word3"
+          let ftsQuery = terms.map(t => t.replace(/['"]/g, '')).join(' OR ');
+          // Add source filter if specified
+          if (input.source) {
+            ftsQuery = `source:${input.source} AND (${ftsQuery})`;
+          }
+
+          console.log('[chat] FTS5 query:', ftsQuery);
+          results = db.prepare(`
+            SELECT m.*, bm25(memories_fts) as relevance_score
+            FROM memories_fts f
+            JOIN memories m ON m.rowid = f.rowid
+            WHERE memories_fts MATCH ?
+            ORDER BY bm25(memories_fts)
+            LIMIT ?
+          `).all(ftsQuery, limit);
+          console.log('[chat] FTS5 returned', results.length, 'results (ranked by relevance)');
+        } catch (ftsErr) {
+          console.log('[chat] FTS5 error, falling back to LIKE:', ftsErr.message);
+          results = []; // fall through to LIKE
+        }
+      }
+
+      // Fallback to LIKE search if FTS5 unavailable or failed
+      if (results.length === 0 && input.query) {
+        let terms = input.query.split('|').map(t => t.trim()).filter(Boolean);
+        if (terms.length === 1 && terms[0].includes(' ')) {
+          terms = terms[0].split(/\s+/).filter(t => t.length >= 2);
+        }
+        let sql = 'SELECT * FROM memories WHERE 1=1';
+        const params = [];
+        if (input.source) { sql += ' AND source = ?'; params.push(input.source); }
+        if (terms.length > 1) {
+          sql += ' AND (' + terms.map(() => 'content LIKE ?').join(' OR ') + ')';
+          terms.forEach(t => params.push('%' + t + '%'));
+        } else if (terms.length === 1) {
+          sql += ' AND content LIKE ?';
+          params.push('%' + terms[0] + '%');
+        }
+        sql += ' ORDER BY timestamp DESC LIMIT ?';
+        params.push(limit);
+        results = db.prepare(sql).all(...params);
+        console.log('[chat] LIKE fallback returned', results.length, 'results');
+      }
+
+      const totalSlack = db.prepare('SELECT count(*) as c FROM memories WHERE source = ?').get('slack').c;
+      return {
+        count: results.length,
+        total_memories: db.prepare('SELECT count(*) as c FROM memories').get().c,
+        total_slack: totalSlack,
+        search_method: results[0]?.relevance_score !== undefined ? 'fts5_bm25' : 'like',
+        memories: results.map(m => ({
+          source: m.source,
+          channel: m.source_channel,
+          participants: m.participants,
+          content: m.content?.slice(0, 300),
+          timestamp: m.timestamp,
+          direction: m.direction,
+          relevance: m.relevance_score ? Math.round(m.relevance_score * -100) / 100 : undefined,
+        })),
+      };
+    }
+    if (name === 'lookup_person') {
+      const people = brain.listPeople({});
+      const person = people.find(p => p.name && p.name.toLowerCase().includes(input.name.toLowerCase()));
+      if (!person) return { error: `Person "${input.name}" not found` };
+      let persona = null;
+      try { persona = brain.getPersonaForPerson(person.id); } catch {}
+      return { ...person, persona };
+    }
+    if (name === 'remember_fact') {
+      brain.insertKnowledge({ category: input.category, subject: input.subject, predicate: input.predicate, object: input.object, confidence: 0.95, source_memory_ids: '[]' });
+      return { stored: true };
+    }
+    if (name === 'mcp_call') {
+      try {
+        const { callMcpTool } = require('./skills/mcp-client');
+        const result = await callMcpTool(input.server, input.tool, input.arguments || {});
+        if (result && result.content) {
+          const texts = result.content.filter(c => c.type === 'text').map(c => c.text);
+          return texts.join('\n').slice(0, 10000);
+        }
+        return result;
+      } catch (err) {
+        return { error: err.message };
+      }
+    }
+    if (name === 'list_mcp_tools') {
+      try {
+        const { listAllTools } = require('./skills/mcp-client');
+        const tools = await listAllTools();
+        return tools.map(t => ({ server: t.server, name: t.name, description: (t.description || '').slice(0, 150) }));
+      } catch (err) {
+        return { error: err.message };
+      }
+    }
+    if (name === 'pull_slack') {
+      try {
+        const { pullNewSlackMessages, pullAllSlackMessages } = require('./skills/slack-pull-live');
+        const logs = [];
+        const progressCb = (msg) => { logs.push(msg); onProgress({ type: 'tool_call', tool: 'pull_slack', summary: msg }); };
+        const pullFn = input.mode === 'full' ? pullAllSlackMessages : pullNewSlackMessages;
+        const result = await pullFn({ onProgress: progressCb });
+        return { ...result, logs };
+      } catch (err) {
+        return { error: err.message };
+      }
+    }
+    if (name === 'slack_connect') {
+      try {
+        console.log('[chat] Starting Slack OAuth flow...');
+        onProgress({ type: 'tool_call', tool: 'slack_connect', summary: 'Opening browser for Slack login...' });
+        const token = await slackMcp.authenticate();
+        return { connected: true, message: 'Slack connected! I can now search and read your Slack messages.' };
+      } catch (err) {
+        return { error: 'Slack auth failed: ' + err.message + '. Please try again.' };
+      }
+    }
+    if (name === 'slack_search' || name === 'slack_read_channel' || name === 'slack_send_message') {
+      // Auto-auth: if not authenticated, trigger OAuth flow automatically
+      if (!slackMcp.isAuthenticated()) {
+        try {
+          console.log('[chat] Slack not authenticated — triggering auto-auth...');
+          onProgress({ type: 'tool_call', tool: 'slack_connect', summary: 'Slack not connected — opening browser for login...' });
+          await slackMcp.authenticate();
+          onProgress({ type: 'tool_done', tool: 'slack_connect', summary: 'Slack connected!' });
+        } catch (authErr) {
+          return { error: 'Slack not connected. Auth failed: ' + authErr.message };
+        }
+      }
+      try {
+        let toolName, toolArgs;
+        if (name === 'slack_search') {
+          toolName = 'slack_search_public_and_private';
+          toolArgs = { query: input.query };
+        } else if (name === 'slack_read_channel') {
+          toolName = 'slack_read_channel';
+          toolArgs = { channel_name: input.channel_name, limit: input.limit || 20 };
+        } else {
+          toolName = 'slack_send_message';
+          toolArgs = { channel_name: input.channel_name, message: input.message };
+        }
+        const result = await slackMcp.callSlackMcp(toolName, toolArgs);
+        const texts = (result?.content || []).filter(c => c.type === 'text').map(c => c.text);
+        const combined = texts.join('\n').slice(0, 10000);
+        if (name === 'slack_send_message') return { sent: true, response: combined.slice(0, 2000) };
+        return name === 'slack_search' ? { results: combined } : { messages: combined };
+      } catch (err) {
+        // If auth error, clear token and suggest re-auth
+        if (err.message.includes('401') || err.message.includes('expired') || err.message.includes('invalid_auth')) {
+          slackMcp.clearToken();
+          return { error: 'Slack token expired. I\'ll reconnect on the next attempt — please try again.' };
+        }
+        return { error: err.message };
+      }
+    }
+    if (name === 'create_task') {
+      const result = brain.insertTask({
+        title: input.title,
+        description: input.description,
+        priority: input.priority,
+        type: input.type,
+        schedule: input.schedule,
+        due_at: input.due_at,
+      });
+      return { created: true, id: result.id, title: input.title, status: 'pending', due_at: input.due_at || 'immediate' };
+    }
+    if (name === 'list_tasks') {
+      const tasks = brain.listTasks({ status: input.status, limit: 20 });
+      return { count: tasks.length, tasks: tasks.map(t => ({ id: t.id, title: t.title, status: t.status, priority: t.priority, due_at: t.due_at, created_at: t.created_at, result: t.result?.slice(0, 200) })) };
+    }
+    // Try local tools (shell, files, macOS automation, calendar, etc.)
+    try {
+      const localResult = await executeLocalTool(name, input);
+      if (localResult !== null) return localResult;
+    } catch (err) {
+      return { error: err.message };
+    }
+    return { error: 'Unknown tool' };
+  }
+
+  try {
+    // Save user message FIRST (before calling Claude) so it gets an earlier timestamp
+    const sessionId = opts.session_id || 'default';
+    brain.insertChatMessage({ role: 'user', content: message, channel, session_id: sessionId });
+    brain.insertMemory({
+      source: 'wall-e-chat',
+      source_id: `chat-${Date.now()}`,
+      memory_type: 'message_received',
+      direction: 'inbound',
+      content: message,
+      timestamp: new Date().toISOString(),
+      metadata: JSON.stringify({ channel }),
+    });
+
+    // Load recent chat history — limit to last 10 messages to reduce input tokens
+    // (20 messages was ~5K tokens; 10 is ~2.5K — saves ~2s per turn)
+    const chatSessionId = sessionId;
+    const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 10 });
+    const historyMessages = recentChat.map(m => ({ role: m.role, content: m.content }));
+    // Agentic chat loop — history already includes the new user message
+    const messages = [...historyMessages];
+    let finalText = '';
+    const MAX_TURNS = 8; // search(2-3) + think(1) + response(1) + possible follow-up tools
+
+    const chatStart = Date.now();
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+      const turnStart = Date.now();
+      onProgress({ type: 'thinking', turn });
+      resetTurnTimeout();
+      const response = await client.messages.create({
+        model: opts.model || 'claude-sonnet-4-6',
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages,
+        tools: chatTools,
+      }, { signal: controller.signal });
+
+      const textBlocks = response.content.filter(b => b.type === 'text');
+      const toolUseBlocks = response.content.filter(b => b.type === 'tool_use');
+
+      console.log('[chat] Turn', turn, 'took', Date.now() - turnStart, 'ms, tools:', toolUseBlocks.map(t => t.name).join(',') || 'none');
+
+      // If no tool calls, we have our final answer
+      if (toolUseBlocks.length === 0) {
+        finalText = textBlocks.map(b => b.text).join('');
+        console.log('[chat] Total time:', Date.now() - chatStart, 'ms across', turn + 1, 'turns');
+        break;
+      }
+
+      // Emit progress for each tool call before executing
+      for (const tu of toolUseBlocks) {
+        const summary = tu.name === 'search_memories'
+          ? `Searching: "${tu.input.query}"${tu.input.source ? ` (${tu.input.source})` : ''}`
+          : tu.name === 'think'
+          ? 'Analyzing evidence...'
+          : tu.name === 'lookup_person'
+          ? `Looking up: ${tu.input.name}`
+          : tu.name === 'mcp_call'
+          ? `Calling ${tu.input.server}.${tu.input.tool}`
+          : tu.name === 'run_skill'
+          ? `Running skill: ${tu.input.skill_name}`
+          : tu.name === 'run_shell'
+          ? `Running: ${tu.input.command} ${(tu.input.args || []).join(' ')}`.slice(0, 80)
+          : tu.name === 'read_file'
+          ? `Reading: ${tu.input.file_path}`
+          : tu.name === 'write_file'
+          ? `Writing: ${tu.input.file_path}`
+          : tu.name === 'search_files'
+          ? `Searching files: "${tu.input.query}"`
+          : tu.name === 'calendar_events'
+          ? 'Checking calendar...'
+          : tu.name === 'calendar_create'
+          ? `Creating event: ${tu.input.title}`
+          : tu.name === 'reminder_create'
+          ? `Creating reminder: ${tu.input.title}`
+          : tu.name === 'notification'
+          ? `Notification: ${tu.input.title}`
+          : tu.name === 'applescript'
+          ? 'Running AppleScript...'
+          : tu.name === 'open_url'
+          ? `Opening: ${tu.input.url}`
+          : tu.name === 'open_app'
+          ? `Opening: ${tu.input.app_name}`
+          : tu.name === 'web_fetch'
+          ? `Fetching: ${tu.input.url}`
+          : `Using tool: ${tu.name}`;
+        onProgress({ type: 'tool_call', tool: tu.name, summary });
+      }
+
+      // Execute tool calls in PARALLEL (searches are independent, no need to serialize)
+      const toolResults = await Promise.all(toolUseBlocks.map(async (tu) => {
+        const t0 = Date.now();
+        console.log('[chat] Tool call:', tu.name, JSON.stringify(tu.input).slice(0, 150));
+        const result = await executeChatTool(tu.name, tu.input);
+        const resultStr = JSON.stringify(result);
+        const elapsed = Date.now() - t0;
+        console.log('[chat] Tool', tu.name, 'done in', elapsed, 'ms, result:', resultStr.length, 'chars');
+        // Emit tool completion with result summary
+        const resultSummary = tu.name === 'search_memories'
+          ? `Found ${result.count || 0} results (${result.search_method || 'search'})`
+          : tu.name === 'think'
+          ? 'Done thinking'
+          : `Completed in ${elapsed}ms`;
+        onProgress({ type: 'tool_done', tool: tu.name, summary: resultSummary });
+        return { type: 'tool_result', tool_use_id: tu.id, content: resultStr };
+      }));
+
+      messages.push({ role: 'assistant', content: response.content });
+      messages.push({ role: 'user', content: toolResults });
+
+      // Accumulate any text from this turn
+      if (textBlocks.length > 0) {
+        finalText += textBlocks.map(b => b.text).join('');
+      }
+
+      // If Claude ended, we're done
+      if (response.stop_reason === 'end_turn') {
+        break;
+      }
+    }
+
+    // If no text was produced after tool calls, make one more call to get a summary
+    if (!finalText.trim() && messages.length > historyMessages.length + 1) {
+      try {
+        const summaryResponse = await client.messages.create({
+          model: opts.model || 'claude-sonnet-4-6',
+          max_tokens: 1024,
+          system: systemPrompt,
+          messages: [...messages, { role: 'user', content: 'Summarize what you just did and the results.' }],
+        }, { signal: controller.signal });
+        finalText = summaryResponse.content.filter(b => b.type === 'text').map(b => b.text).join('');
+      } catch {}
+    }
+
+    const text = finalText || 'I completed the action but couldn\'t generate a summary.';
+
+    // Save assistant response (user message was already saved before calling Claude)
+    brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
+
+    brain.insertMemory({
+      source: 'wall-e-chat',
+      source_id: `chat-reply-${Date.now()}`,
+      memory_type: 'message_sent',
+      direction: 'outbound',
+      content: text,
+      timestamp: new Date().toISOString(),
+      metadata: JSON.stringify({ channel }),
+    });
+
+    return { reply: text };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Build a client using the same Portkey-compatible approach as knowledge-extractor.
+ * getClient is not exported from knowledge-extractor, so we replicate the logic here.
+ */
+function getClientForChat() {
+  const opts = buildClientOpts();
+  const isPortkey = opts.defaultHeaders && opts.defaultHeaders['x-portkey-api-key'];
+
+  if (isPortkey) {
+    return {
+      messages: {
+        async create(params, fetchOpts) {
+          const headers = {
+            'content-type': 'application/json',
+            'anthropic-version': '2023-06-01',
+            ...opts.defaultHeaders,
+          };
+          const res = await fetch(opts.baseURL + '/messages', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(params),
+            signal: fetchOpts?.signal,
+          });
+          if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`${res.status} ${text}`);
+          }
+          return res.json();
+        }
+      }
+    };
+  }
+  return new Anthropic(opts);
+}
+
+// Allow injecting a custom client (for testing)
+let _clientOverride = null;
+function _setClient(client) { _clientOverride = client; }
+
+module.exports = { chat, getClientForChat, _setClient };