create-walle 0.9.0 → 0.9.3

package/template/wall-e/chat.js

@@ -4,10 +4,13 @@ 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');
+const { estimateTokens, estimateMessagesTokens } = require('./context/token-counter');
+const { shouldCompact, compactToolResult, compactMessages } = require('./context/compactor');
+const { buildSystemPrompt } = require('./context/context-builder');
 
 /**
  * Core "talk to WALL-E" handler.
- * Builds a system prompt from brain context and calls Claude.
+ * Uses dynamic context builder (Phase 3) instead of static system prompt.
  */
 function ensureBrainInit() {
   try { brain.getDb(); } catch {
@@ -17,214 +20,25 @@ function ensureBrainInit() {
 
 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 {}
+  // Build dynamic system prompt — selects relevant context based on the user's message
+  const sessionId = opts.session_id || 'default';
+  const existingSession = brain.getSession(sessionId);
+  const systemPrompt = buildSystemPrompt(message, channel, {
+    sessionSummary: existingSession?.summary || null,
+  });
 
-  // Load available MCP servers and their cached tools so WALL-E knows what it can do
-  let mcpServerList = '';
-  try {
-    const { loadMcpConfigs } = require('./skills/mcp-client');
-    const configs = loadMcpConfigs();
-    // Read cached tools from brain DB
-    let toolsByServer = {};
-    try {
-      const rows = brain.getDb().prepare('SELECT server, tool_name FROM mcp_tools_cache ORDER BY server').all();
-      for (const r of rows) {
-        if (!toolsByServer[r.server]) toolsByServer[r.server] = [];
-        toolsByServer[r.server].push(r.tool_name);
-      }
-    } catch {} // table may not exist yet
-    mcpServerList = Object.entries(configs).map(([name, cfg]) => {
-      const hasAuth = cfg.oauth?.accessToken ? 'authenticated' : 'needs auth';
-      const tools = toolsByServer[name];
-      const toolStr = tools ? ` — tools: ${tools.slice(0, 10).join(', ')}${tools.length > 10 ? ' +' + (tools.length - 10) + ' more' : ''}` : '';
-      return `- ${name}: ${cfg.type || 'stdio'} [${hasAuth}]${toolStr}`;
-    }).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 = '';
+  // Expire old sessions occasionally (at most once per hour)
   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.
-- When mcp_call returns auth_required, tell the user which MCP server needs authentication and suggest they connect it via Claude Code or the MCP tab in the dashboard.
-
-### 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)' : ''}`;
+    if (!chat._lastExpiry || Date.now() - chat._lastExpiry > 3600000) {
+      const expired = brain.expireSessions(24);
+      if (expired > 0) console.log(`[chat] Expired ${expired} old sessions`);
+      chat._lastExpiry = Date.now();
+    }
+  } catch (expErr) {
+    console.error('[chat] Session expiry check failed:', expErr.message);
+  }
 
   // Use injected client (for testing) or build one from env
   const client = _clientOverride || getClientForChat();
@@ -413,21 +227,29 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
             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
+          const ftsQuery = terms.map(t => t.replace(/['"]/g, '')).join(' OR ');
+
+          console.log('[chat] FTS5 query:', ftsQuery, input.source ? `(source: ${input.source})` : '');
+          // Use JOIN filter for source instead of FTS5 column filter (memories_fts may not have source column)
           if (input.source) {
-            ftsQuery = `source:${input.source} AND (${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 ? AND m.source = ?
+              ORDER BY bm25(memories_fts)
+              LIMIT ?
+            `).all(ftsQuery, input.source, limit);
+          } else {
+            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 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);
@@ -603,7 +425,6 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
 
   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',
@@ -615,20 +436,57 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
       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)
+    // Load recent chat history, resuming from compacted state if available
     const chatSessionId = sessionId;
-    const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 10 });
-    const historyMessages = recentChat.map(m => ({ role: m.role, content: m.content }));
+    let historyMessages;
+    if (existingSession?.compacted_messages) {
+      // Resume from compacted state + recent messages
+      try {
+        const compacted = JSON.parse(existingSession.compacted_messages);
+        const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 4 });
+        const recent = recentChat.map(m => ({ role: m.role, content: m.content }));
+        historyMessages = [...compacted, ...recent];
+      } catch {
+        // If parse fails, fall back to normal loading
+        const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 10 });
+        historyMessages = recentChat.map(m => ({ role: m.role, content: m.content }));
+      }
+    } else {
+      const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 10 });
+      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 = '';
+    let lastTurn = 0;
     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++) {
+      lastTurn = turn;
       const turnStart = Date.now();
       onProgress({ type: 'thinking', turn });
+
+      // Check if context needs compaction before calling Claude
+      const systemTokens = estimateTokens(systemPrompt);
+      if (shouldCompact(messages, systemTokens)) {
+        console.log('[chat] Context approaching limit — compacting...');
+        try {
+          const { messages: compacted, summary } = await compactMessages(messages, client);
+          messages.length = 0;
+          messages.push(...compacted);
+          brain.upsertSession({
+            id: sessionId, channel, summary,
+            compacted_messages: JSON.stringify(compacted),
+            turn_count: turn,
+            token_estimate: estimateMessagesTokens(compacted),
+          });
+          console.log('[chat] Compaction complete, messages:', messages.length);
+        } catch (compactErr) {
+          console.error('[chat] Compaction failed, continuing with full context:', compactErr.message);
+        }
+      }
+
       resetTurnTimeout();
       const response = await client.messages.create({
         model: opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001',
@@ -705,7 +563,9 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
           ? '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 };
+        // Compact tool results immediately to reduce token usage
+        const compactedResult = compactToolResult(tu.name, resultStr);
+        return { type: 'tool_result', tool_use_id: tu.id, content: compactedResult };
       }));
 
       messages.push({ role: 'assistant', content: response.content });
@@ -725,6 +585,7 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
     // 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 {
+        resetTurnTimeout();
         const summaryResponse = await client.messages.create({
           model: opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001',
           max_tokens: 1024,
@@ -737,6 +598,27 @@ When ${ownerName} asks you to DO something (create a file, set a reminder, searc
 
     const text = finalText || 'I completed the action but couldn\'t generate a summary.';
 
+    // Save enriched session state
+    try {
+      const metadata = {
+        lastTopic: message.slice(0, 200),
+        turnCount: lastTurn + 1,
+        toolsUsed: [...new Set(messages
+          .filter(m => m.role === 'assistant' && Array.isArray(m.content))
+          .flatMap(m => m.content.filter(b => b.type === 'tool_use').map(b => b.name))
+        )],
+      };
+      brain.upsertSession({
+        id: sessionId, channel,
+        summary: text.slice(0, 500),
+        turn_count: lastTurn + 1,
+        token_estimate: estimateMessagesTokens(messages),
+        metadata: JSON.stringify(metadata),
+      });
+    } catch (sessionErr) {
+      console.error('[chat] Failed to save session:', sessionErr.message);
+    }
+
     // Save assistant response (user message was already saved before calling Claude)
     brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
 

package/template/wall-e/context/compactor.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const { estimateTokens, estimateMessagesTokens } = require('./token-counter');
+
+const DEFAULT_CONTEXT_WINDOW = 200000; // Haiku 4.5 — 200K context
+const COMPACTION_THRESHOLD = 0.75;     // Compact at 75% of context window
+const KEEP_RECENT_MESSAGES = 4;        // Always keep last 4 messages verbatim
+
+/**
+ * Check whether the conversation should be compacted.
+ * @param {Array} messages
+ * @param {number} systemPromptTokens - estimated tokens in the system prompt
+ * @param {number} contextWindow
+ * @returns {boolean}
+ */
+function shouldCompact(messages, systemPromptTokens, contextWindow = DEFAULT_CONTEXT_WINDOW) {
+  const totalTokens = (systemPromptTokens || 0) + estimateMessagesTokens(messages);
+  return totalTokens > COMPACTION_THRESHOLD * contextWindow;
+}
+
+/**
+ * Immediately truncate a tool result based on tool type.
+ * Called right after each tool execution to keep results lean.
+ * @param {string} toolName
+ * @param {string} resultStr - JSON string of the tool result
+ * @returns {string} - truncated JSON string
+ */
+function compactToolResult(toolName, resultStr) {
+  if (!resultStr) return resultStr;
+
+  // think tool: keep full — cheap and important for reasoning
+  if (toolName === 'think') return resultStr;
+
+  // search_memories: parse and keep top 5 results
+  if (toolName === 'search_memories') {
+    try {
+      const parsed = JSON.parse(resultStr);
+      if (parsed.memories && Array.isArray(parsed.memories)) {
+        parsed.memories = parsed.memories.slice(0, 5);
+        parsed.count = parsed.memories.length;
+        parsed._compacted = true;
+        return JSON.stringify(parsed);
+      }
+    } catch {
+      // If parse fails, fall through to default truncation
+    }
+  }
+
+  // Slack / MCP calls: truncate to 2000 chars
+  if (toolName === 'mcp_call' || toolName.startsWith('slack_')) {
+    if (resultStr.length > 2000) {
+      return resultStr.slice(0, 2000) + '... [truncated]';
+    }
+    return resultStr;
+  }
+
+  // Default: truncate to 3000 chars
+  if (resultStr.length > 3000) {
+    return resultStr.slice(0, 3000) + '... [truncated]';
+  }
+  return resultStr;
+}
+
+/**
+ * Progressively compact messages by summarizing older history.
+ * Keeps the last KEEP_RECENT_MESSAGES verbatim and summarizes everything else.
+ *
+ * @param {Array} messages - conversation messages
+ * @param {object} client - Portkey-compatible Claude client (must have client.messages.create)
+ * @param {object} opts - { contextWindow, model }
+ * @returns {Promise<{ messages: Array, summary: string, tokensBeforeCompaction: number, tokensAfterCompaction: number }>}
+ */
+async function compactMessages(messages, client, opts = {}) {
+  const tokensBeforeCompaction = estimateMessagesTokens(messages);
+
+  if (messages.length <= KEEP_RECENT_MESSAGES) {
+    return {
+      messages,
+      summary: null,
+      tokensBeforeCompaction,
+      tokensAfterCompaction: tokensBeforeCompaction,
+    };
+  }
+
+  // Split: older messages to summarize, recent to keep verbatim
+  const olderMessages = messages.slice(0, messages.length - KEEP_RECENT_MESSAGES);
+  const recentMessages = messages.slice(messages.length - KEEP_RECENT_MESSAGES);
+
+  // Build a text representation of older messages for summarization
+  const olderText = olderMessages.map(m => {
+    const role = m.role || 'unknown';
+    let content = '';
+    if (typeof m.content === 'string') {
+      content = m.content;
+    } else if (Array.isArray(m.content)) {
+      content = m.content.map(block => {
+        if (block.type === 'text') return block.text;
+        if (block.type === 'tool_use') return `[Tool: ${block.name}(${JSON.stringify(block.input).slice(0, 200)})]`;
+        if (block.type === 'tool_result') return `[Result: ${(typeof block.content === 'string' ? block.content : JSON.stringify(block.content)).slice(0, 300)}]`;
+        return `[${block.type}]`;
+      }).join('\n');
+    }
+    return `${role}: ${content}`;
+  }).join('\n\n');
+
+  // Call Claude to summarize
+  const model = opts.model || 'claude-haiku-4-5-20251001';
+  const summaryPrompt = `Summarize this conversation history into a compact reference block. Preserve:
+- All decisions made and their rationale
+- Action items and pending tasks
+- Key identifiers (names, IDs, URLs, file paths)
+- Any constraints or commitments stated
+- The current topic/thread being discussed
+- Tool results and their key findings
+
+Be concise but preserve ALL important details. Output only the summary, no preamble.
+
+CONVERSATION HISTORY:
+${olderText.slice(0, 50000)}`;
+
+  let summary;
+  try {
+    const summaryResponse = await client.messages.create({
+      model,
+      max_tokens: 1024,
+      messages: [{ role: 'user', content: summaryPrompt }],
+    });
+    summary = summaryResponse.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text)
+      .join('');
+  } catch (err) {
+    console.error('[compactor] Summarization failed, using naive truncation:', err.message);
+    // Fallback: just take the last portion of older text
+    summary = 'Previous conversation summary (auto-truncated):\n' + olderText.slice(-2000);
+  }
+
+  // Build compacted messages: summary as first message, then recent messages
+  const compactedMessages = [
+    { role: 'user', content: `[Conversation history summary]\n${summary}` },
+    { role: 'assistant', content: 'Understood. I have the conversation context. Continuing from where we left off.' },
+    ...recentMessages,
+  ];
+
+  const tokensAfterCompaction = estimateMessagesTokens(compactedMessages);
+  console.log(`[compactor] Compacted ${messages.length} messages (${tokensBeforeCompaction} tokens) -> ${compactedMessages.length} messages (${tokensAfterCompaction} tokens)`);
+
+  return {
+    messages: compactedMessages,
+    summary,
+    tokensBeforeCompaction,
+    tokensAfterCompaction,
+  };
+}
+
+module.exports = {
+  DEFAULT_CONTEXT_WINDOW,
+  COMPACTION_THRESHOLD,
+  KEEP_RECENT_MESSAGES,
+  shouldCompact,
+  compactToolResult,
+  compactMessages,
+};