apex-dev 2.0.0 → 3.0.0

package/src/thinking.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { t, indent } = require('./ui');
-
 function parseThinkBlocks(text) {
   const thinkRegex = /<think>([\s\S]*?)(?:<\/think>|think>)/g;
   const thoughts = [];
@@ -35,7 +33,6 @@ function splitAtPartialTag(text) {
   const prefixes = [
     '</think>', '</think', '</thin', '</thi', '</th', '</t', '</',
     '<think>', '<think', '<thin', '<thi', '<th', '<t',
-    'think>', 'think', 'thin', 'thi', 'th',
     '<',
   ];
   for (const prefix of prefixes) {
@@ -49,30 +46,9 @@ function splitAtPartialTag(text) {
   return { safe: text, pending: '' };
 }
 
-function showThinkingBlock(thoughts) {
-  if (!thoughts.length) return;
-  const combined = thoughts.join('\n\n');
-  const lines = combined.split('\n');
-  const maxLines = 8;
-  const preview = lines.length > maxLines ? lines.slice(0, maxLines) : lines;
-  const isTruncated = lines.length > maxLines;
-
-  console.log(indent(t.dim.italic('▸ Thinking'), 2));
-  for (const line of preview) {
-    if (line.trim()) {
-      console.log(indent(t.dim.italic(line), 4));
-    }
-  }
-  if (isTruncated) {
-    console.log(indent(t.dim.italic(`... +${lines.length - maxLines} more lines`), 4));
-  }
-  console.log();
-}
-
 module.exports = {
   parseThinkBlocks,
   findThinkClose,
   stripStrayCloseTag,
   splitAtPartialTag,
-  showThinkingBlock,
 };

package/src/toolExecutors.js

@@ -2,20 +2,67 @@
 
 const fs = require('fs');
 const path = require('path');
+const https = require('https');
 const { execSync } = require('child_process');
 const {
   PROJECT_ROOT,
   TOOL_TIMEOUT,
   REVIEWER_MODEL,
   REVIEWER_SYSTEM_PROMPT,
+  FILE_PICKER_MODEL,
+  FILE_PICKER_SYSTEM_PROMPT,
+  THINKER_MODEL,
+  THINKER_SYSTEM_PROMPT,
+  COMMANDER_MODEL,
+  COMMANDER_SYSTEM_PROMPT,
+  CONTEXT_PRUNER_MODEL,
+  CONTEXT_PRUNER_SYSTEM_PROMPT,
+  SELECTOR_SYSTEM_PROMPT,
+  NVIDIA_MODEL,
   nvidiaClient,
   session,
   truncateOutput,
   resolvePath,
   sleep,
+  getMode,
 } = require('./config');
 
-async function executeTool(name, args) {
+async function streamCompletion(params, onStream) {
+  for (let attempt = 0; attempt <= 2; attempt++) {
+    let content = '';
+    let reasoning = '';
+    try {
+      if (onStream) {
+        const stream = await nvidiaClient.chat.completions.create({ ...params, stream: true });
+        for await (const chunk of stream) {
+          const delta = chunk.choices?.[0]?.delta;
+          if (delta?.content) {
+            content += delta.content;
+            onStream(content || reasoning);
+          }
+          if (delta?.reasoning_content) {
+            reasoning += delta.reasoning_content;
+            onStream(content || reasoning);
+          }
+        }
+        return content || reasoning || '';
+      } else {
+        const response = await nvidiaClient.chat.completions.create(params);
+        return response.choices[0]?.message?.content
+          || response.choices[0]?.message?.reasoning_content
+          || '';
+      }
+    } catch (err) {
+      if (attempt < 2 && err.status >= 400 && err.status < 500) {
+        await sleep(1000 * Math.pow(2, attempt));
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+
+async function executeTool(name, args, onStream) {
   try {
     switch (name) {
       case 'Read': {
@@ -215,6 +262,165 @@ async function executeTool(name, args) {
         return truncateOutput(`Task: ${args.description}\n${'─'.repeat(40)}\n${results.join('\n\n')}`);
       }
 
+      case 'WebSearch': {
+        const apiKey = process.env.EXA_API_KEY;
+        if (!apiKey) return 'Error: EXA_API_KEY environment variable is not set. Get one at https://dashboard.exa.ai/api-keys';
+
+        const body = JSON.stringify({
+          query: args.query,
+          numResults: Math.min(args.num_results || 5, 10),
+          type: args.type || 'auto',
+          ...(args.include_domains && { includeDomains: args.include_domains }),
+          ...(args.category && { category: args.category }),
+          contents: { highlights: { maxCharacters: 300 }, text: { maxCharacters: 1000 } },
+        });
+
+        const result = await new Promise((resolve) => {
+          const req = https.request({
+            hostname: 'api.exa.ai',
+            path: '/search',
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'x-api-key': apiKey,
+            },
+          }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+              if (res.statusCode !== 200) {
+                resolve(`Error: Exa API returned ${res.statusCode}: ${data}`);
+                return;
+              }
+              try {
+                const json = JSON.parse(data);
+                if (!json.results || json.results.length === 0) {
+                  resolve('No results found.');
+                  return;
+                }
+                const formatted = json.results.map((r, i) => {
+                  let entry = `${i + 1}. **${r.title || 'Untitled'}**\n   ${r.url}`;
+                  if (r.publishedDate) entry += `\n   Published: ${r.publishedDate.split('T')[0]}`;
+                  if (r.author) entry += `\n   Author: ${r.author}`;
+                  if (r.text) entry += `\n   ${r.text.trim().slice(0, 500)}`;
+                  else if (r.highlights && r.highlights.length) entry += `\n   ${r.highlights[0].trim().slice(0, 300)}`;
+                  return entry;
+                }).join('\n\n');
+                resolve(truncateOutput(`Web Search Results (${json.results.length}):\n${'─'.repeat(40)}\n${formatted}`));
+              } catch (e) {
+                resolve(`Error: Failed to parse Exa response: ${e.message}`);
+              }
+            });
+          });
+          req.on('error', (e) => resolve(`Error: Exa request failed: ${e.message}`));
+          req.setTimeout(15000, () => { req.destroy(); resolve('Error: Exa search timed out.'); });
+          req.write(body);
+          req.end();
+        });
+        return result;
+      }
+
+      case 'FilePickerMax': {
+        // Gather full directory tree
+        let tree = '';
+        try {
+          tree = execSync(
+            `find "${PROJECT_ROOT}" -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/.cache/*" -not -path "*/.local/*" -not -path "*/.upm/*" -not -path "*/.config/*" 2>/dev/null | head -500`,
+            { encoding: 'utf-8', timeout: 15000 }
+          ).trim();
+          // Make paths relative
+          tree = tree.split('\n').map(f => path.relative(PROJECT_ROOT, f) || '.').join('\n');
+        } catch {
+          tree = '(failed to scan directory tree)';
+        }
+
+        // Gather previews of all source files (first 8 lines each)
+        const sourceExts = /\.(js|ts|jsx|tsx|py|rb|go|rs|java|c|cpp|h|hpp|css|scss|html|svelte|vue|json|yaml|yml|toml|md|sql|sh|bash|env|cfg|ini|xml)$/i;
+        const allFiles = tree.split('\n').filter(f => sourceExts.test(f));
+        const previews = [];
+        for (const relFile of allFiles.slice(0, 200)) {
+          const absFile = path.resolve(PROJECT_ROOT, relFile);
+          try {
+            const stat = fs.statSync(absFile, { throwIfNoEntry: false });
+            if (!stat || stat.isDirectory() || stat.size > 512 * 1024) continue;
+            const content = fs.readFileSync(absFile, 'utf-8');
+            const first8 = content.split('\n').slice(0, 8).join('\n');
+            previews.push(`--- ${relFile} ---\n${first8}`);
+          } catch { /* skip unreadable */ }
+        }
+
+        const pickerMessages = [
+          { role: 'system', content: FILE_PICKER_SYSTEM_PROMPT },
+          {
+            role: 'user',
+            content: `# Prompt\n${args.prompt}\n\n# Directory Tree\n${tree}\n\n# File Previews (first 8 lines each)\n${previews.join('\n\n')}`,
+          },
+        ];
+
+        try {
+          const header = `FilePickerMax Results\n${'─'.repeat(40)}\n`;
+          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+          const raw = await streamCompletion({
+            model: FILE_PICKER_MODEL,
+            messages: pickerMessages,
+            max_tokens: 4096,
+            temperature: 0.2,
+          }, streamCb) || '[]';
+          return truncateOutput(header + raw);
+        } catch (apiErr) {
+          return `Error: FilePickerMax failed — ${apiErr.message}`;
+        }
+      }
+
+      case 'TodoList': {
+        const todoFile = path.join(PROJECT_ROOT, '.apex-todos.json');
+        const loadTodos = () => {
+          try { return JSON.parse(fs.readFileSync(todoFile, 'utf-8')); }
+          catch { return []; }
+        };
+        const saveTodos = (todos) => fs.writeFileSync(todoFile, JSON.stringify(todos, null, 2), 'utf-8');
+        const formatTodos = (todos) => {
+          if (todos.length === 0) return 'Todo list is empty.';
+          return todos.map((t, i) =>
+            `${i + 1}. [${t.done ? 'x' : ' '}] ${t.text}${t.done ? ' ✓' : ''}`
+          ).join('\n');
+        };
+
+        const todos = loadTodos();
+        switch (args.action) {
+          case 'add': {
+            if (!args.text) return 'Error: "text" is required for add action.';
+            todos.push({ text: args.text, done: false, created: Date.now() });
+            saveTodos(todos);
+            return `Added item ${todos.length}: ${args.text}\n\n${formatTodos(todos)}`;
+          }
+          case 'list':
+            return formatTodos(todos);
+          case 'done': {
+            const idx = (args.index || 0) - 1;
+            if (idx < 0 || idx >= todos.length) return `Error: Invalid index. Use 1-${todos.length}.`;
+            todos[idx].done = true;
+            saveTodos(todos);
+            return `Completed: ${todos[idx].text}\n\n${formatTodos(todos)}`;
+          }
+          case 'remove': {
+            const idx = (args.index || 0) - 1;
+            if (idx < 0 || idx >= todos.length) return `Error: Invalid index. Use 1-${todos.length}.`;
+            const removed = todos.splice(idx, 1)[0];
+            saveTodos(todos);
+            return `Removed: ${removed.text}\n\n${formatTodos(todos)}`;
+          }
+          case 'clear': {
+            const before = todos.length;
+            const remaining = todos.filter(t => !t.done);
+            saveTodos(remaining);
+            return `Cleared ${before - remaining.length} completed item(s).\n\n${formatTodos(remaining)}`;
+          }
+          default:
+            return `Error: Unknown action "${args.action}". Use add, list, done, remove, or clear.`;
+        }
+      }
+
       case 'CodeReview': {
         // Auto-collect all modified files from this session
         const allFiles = new Set([...session.filesModified]);
@@ -258,33 +464,384 @@ async function executeTool(name, args) {
         ];
 
         try {
-          let reviewResponse;
-          for (let attempt = 0; attempt <= 2; attempt++) {
-            try {
-              reviewResponse = await nvidiaClient.chat.completions.create({
-                model: REVIEWER_MODEL,
-                messages: reviewMessages,
-                max_tokens: 4096,
-                temperature: 0.3,
-              });
-              break;
-            } catch (retryErr) {
-              if (attempt < 2 && retryErr.status >= 400 && retryErr.status < 500) {
-                await sleep(1000 * Math.pow(2, attempt));
-                continue;
-              }
-              throw retryErr;
-            }
-          }
-          const reviewText = reviewResponse.choices[0]?.message?.content
-            || reviewResponse.choices[0]?.message?.reasoning_content
-            || '(No response from reviewer)';
-          return truncateOutput(`Code Review (${REVIEWER_MODEL}) — ${allFiles.size} file(s)\n${'─'.repeat(40)}\n${reviewText}`);
+          const header = `Code Review (${REVIEWER_MODEL}) — ${allFiles.size} file(s)\n${'─'.repeat(40)}\n`;
+          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+          const reviewText = await streamCompletion({
+            model: REVIEWER_MODEL,
+            messages: reviewMessages,
+            max_tokens: 4096,
+            temperature: 0.3,
+          }, streamCb) || '(No response from reviewer)';
+          return truncateOutput(header + reviewText);
         } catch (apiErr) {
           return `Error: Code review failed — ${apiErr.message}`;
         }
       }
 
+      // ===== Thinker — Deep reasoning/planning =====
+      case 'Thinker': {
+        const historyContext = session.conversationHistory.slice(-10).map(m =>
+          `[${m.role}]: ${(m.content || '').slice(0, 500)}`
+        ).join('\n');
+
+        const thinkerMessages = [
+          { role: 'system', content: THINKER_SYSTEM_PROMPT },
+          {
+            role: 'user',
+            content: `# Recent conversation context\n${historyContext}\n\n# Task to reason about\n${args.prompt}`,
+          },
+        ];
+
+        try {
+          const header = `Thinker (${THINKER_MODEL})\n${'─'.repeat(40)}\n`;
+          const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+          const result = await streamCompletion({
+            model: THINKER_MODEL,
+            messages: thinkerMessages,
+            max_tokens: 4096,
+            temperature: 0.4,
+          }, streamCb) || '(No response from thinker)';
+          return truncateOutput(header + result);
+        } catch (apiErr) {
+          return `Error: Thinker failed — ${apiErr.message}`;
+        }
+      }
+
+      // ===== ThinkerBestOfN — Multiple reasoning passes, select best =====
+      case 'ThinkerBestOfN': {
+        const mode = getMode();
+        if (mode !== 'max') {
+          return 'ThinkerBestOfN is only available in MAX mode. Use /mode max to enable it, or use Thinker instead.';
+        }
+
+        const n = Math.min(5, Math.max(2, args.n || 3));
+        const historyCtx = session.conversationHistory.slice(-10).map(m =>
+          `[${m.role}]: ${(m.content || '').slice(0, 500)}`
+        ).join('\n');
+
+        const header = `Best-of-${n} Thinker (MAX mode)\n${'─'.repeat(40)}\n`;
+        if (onStream) onStream(header + `Spawning ${n} parallel thinking agents...`);
+
+        // Spawn N parallel thinking calls
+        const thinkPromises = [];
+        for (let i = 0; i < n; i++) {
+          const label = String.fromCharCode(65 + i); // A, B, C, ...
+          thinkPromises.push(
+            streamCompletion({
+              model: THINKER_MODEL,
+              messages: [
+                { role: 'system', content: THINKER_SYSTEM_PROMPT + `\n\nYou are Thinker ${label}. Approach this from a unique angle. Be creative and thorough.` },
+                {
+                  role: 'user',
+                  content: `# Context\n${historyCtx}\n\n# Task\n${args.prompt}`,
+                },
+              ],
+              max_tokens: 3072,
+              temperature: 0.7 + (i * 0.1), // Slightly different temperatures for diversity
+            }, null).then(result => ({ label, result }))
+          );
+        }
+
+        let thoughts;
+        try {
+          thoughts = await Promise.all(thinkPromises);
+        } catch (apiErr) {
+          return `Error: ThinkerBestOfN failed — ${apiErr.message}`;
+        }
+
+        if (onStream) onStream(header + `All ${n} thinkers completed. Selecting best response...`);
+
+        // Format thoughts for selector
+        const thoughtsFormatted = thoughts.map(t =>
+          `## Thought ${t.label}\n${t.result || '(empty)'}`
+        ).join('\n\n');
+
+        // Selector picks the best
+        try {
+          const selectorResult = await streamCompletion({
+            model: REVIEWER_MODEL,
+            messages: [
+              {
+                role: 'system',
+                content: `You are a thought selector. You will receive ${n} different reasoning responses to the same question. Pick the best one based on depth, correctness, clarity, and actionability. Output JSON only:\n{ "chosen": "A", "reason": "why this is best" }`,
+              },
+              { role: 'user', content: `# Original question\n${args.prompt}\n\n${thoughtsFormatted}` },
+            ],
+            max_tokens: 1024,
+            temperature: 0.1,
+          }, null);
+
+          let chosen = 'A';
+          let reason = '';
+          try {
+            const parsed = JSON.parse(selectorResult.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+            chosen = parsed.chosen || 'A';
+            reason = parsed.reason || '';
+          } catch { /* default to A */ }
+
+          const winningThought = thoughts.find(t => t.label === chosen) || thoughts[0];
+          const result = `${header}Selected: Thought ${chosen}${reason ? ` — ${reason}` : ''}\n\n${winningThought.result}`;
+          if (onStream) onStream(truncateOutput(result));
+          return truncateOutput(result);
+        } catch (apiErr) {
+          // Fallback to first thought
+          const result = `${header}Selector failed, using Thought A:\n\n${thoughts[0].result}`;
+          return truncateOutput(result);
+        }
+      }
+
+      // ===== EditorMultiPrompt — Parallel implementation strategies, select best =====
+      case 'EditorMultiPrompt': {
+        const mode = getMode();
+        if (mode !== 'max') {
+          return 'EditorMultiPrompt is only available in MAX mode. Use /mode max to enable it.';
+        }
+
+        const strategies = args.strategies || ['straightforward implementation', 'alternative approach'];
+        const filesCtx = (args.files || []).map(f =>
+          `--- ${f.path} ---\n${f.content}`
+        ).join('\n\n');
+
+        const header = `Multi-Prompt Editor (${strategies.length} strategies)\n${'─'.repeat(40)}\n`;
+        if (onStream) onStream(header + `Spawning ${strategies.length} parallel editor agents...`);
+
+        // Spawn parallel editor agents, one per strategy
+        const editorPromises = strategies.map((strategy, i) => {
+          const label = String.fromCharCode(65 + i);
+          return streamCompletion({
+            model: NVIDIA_MODEL,
+            messages: [
+              {
+                role: 'system',
+                content: `You are Code Editor ${label}. You implement code changes using a specific strategy. Output your implementation as a series of file edits.\n\nFor each file change, output:\n--- EDIT: path/to/file ---\nOLD:\n\`\`\`\nexact old code\n\`\`\`\nNEW:\n\`\`\`\nnew replacement code\n\`\`\`\n\nFor new files, output:\n--- CREATE: path/to/file ---\n\`\`\`\nfull file content\n\`\`\`\n\nBe precise. Match existing code style.`,
+              },
+              {
+                role: 'user',
+                content: `# Task\n${args.prompt}\n\n# Strategy\n${strategy}\n\n# Current files\n${filesCtx}`,
+              },
+            ],
+            max_tokens: 4096,
+            temperature: 0.3,
+          }, null).then(result => ({ label, strategy, result: result || '(empty)' }));
+        });
+
+        let implementations;
+        try {
+          implementations = await Promise.all(editorPromises);
+        } catch (apiErr) {
+          return `Error: EditorMultiPrompt failed — ${apiErr.message}`;
+        }
+
+        if (onStream) onStream(header + `All editors completed. Selecting best implementation...`);
+
+        // Format implementations for selector
+        const implFormatted = implementations.map(impl =>
+          `## Implementation ${impl.label} — Strategy: "${impl.strategy}"\n${impl.result}`
+        ).join('\n\n');
+
+        // Selector picks the best
+        try {
+          const selectorResult = await streamCompletion({
+            model: REVIEWER_MODEL,
+            messages: [
+              { role: 'system', content: SELECTOR_SYSTEM_PROMPT },
+              {
+                role: 'user',
+                content: `# Original task\n${args.prompt}\n\n${implFormatted}`,
+              },
+            ],
+            max_tokens: 1024,
+            temperature: 0.1,
+          }, null);
+
+          let chosen = 'A';
+          let reason = '';
+          let improvements = '';
+          try {
+            const parsed = JSON.parse(selectorResult.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+            chosen = parsed.chosen || 'A';
+            reason = parsed.reason || '';
+            improvements = parsed.improvements || '';
+          } catch { /* default to A */ }
+
+          const winning = implementations.find(impl => impl.label === chosen) || implementations[0];
+          let result = `${header}Selected: Implementation ${chosen} ("${winning.strategy}")`;
+          if (reason) result += `\nReason: ${reason}`;
+          if (improvements) result += `\nImprovements to consider: ${improvements}`;
+          result += `\n\n${winning.result}`;
+          if (onStream) onStream(truncateOutput(result));
+          return truncateOutput(result);
+        } catch (apiErr) {
+          const result = `${header}Selector failed, using Implementation A:\n\n${implementations[0].result}`;
+          return truncateOutput(result);
+        }
+      }
+
+      // ===== CodeReviewMulti — Multiple review perspectives in parallel =====
+      case 'CodeReviewMulti': {
+        const mode = getMode();
+        if (mode !== 'max') {
+          return 'CodeReviewMulti is only available in MAX mode. Use /mode max to enable it, or use CodeReview for a single review.';
+        }
+
+        const perspectives = args.perspectives || [
+          'correctness, logic errors, and edge cases',
+          'security vulnerabilities and data safety',
+          'performance, efficiency, and resource usage',
+        ];
+
+        // Gather modified files
+        const modFiles = new Set([...session.filesModified]);
+        if (modFiles.size === 0) return 'CodeReviewMulti skipped — no files were modified.';
+
+        const modFileContents = [];
+        for (const fp of modFiles) {
+          if (!fs.existsSync(fp)) continue;
+          const stat = fs.statSync(fp);
+          if (stat.isDirectory()) continue;
+          modFileContents.push(`--- ${path.relative(PROJECT_ROOT, fp)} ---\n${fs.readFileSync(fp, 'utf-8')}`);
+        }
+
+        let diffText = '';
+        try {
+          diffText = execSync('git diff 2>/dev/null', { encoding: 'utf-8', cwd: PROJECT_ROOT, timeout: 10000 }).trim();
+        } catch {}
+
+        const header = `Multi-Perspective Code Review (${perspectives.length} reviewers)\n${'─'.repeat(40)}\n`;
+        if (onStream) onStream(header + `Spawning ${perspectives.length} parallel reviewers...`);
+
+        const reviewPromises = perspectives.map((perspective, i) => {
+          const label = String.fromCharCode(65 + i);
+          return streamCompletion({
+            model: REVIEWER_MODEL,
+            messages: [
+              {
+                role: 'system',
+                content: REVIEWER_SYSTEM_PROMPT + `\n\nFocus specifically on: ${perspective}. You are Reviewer ${label}.`,
+              },
+              {
+                role: 'user',
+                content: `# Changes\n${args.prompt}\n\n# Files (${modFiles.size})\n${modFileContents.join('\n\n')}${diffText ? `\n\n# Git diff\n\`\`\`diff\n${diffText}\n\`\`\`` : ''}`,
+              },
+            ],
+            max_tokens: 3072,
+            temperature: 0.3,
+          }, null).then(result => ({ label, perspective, result: result || '(no issues found)' }));
+        });
+
+        let reviews;
+        try {
+          reviews = await Promise.all(reviewPromises);
+        } catch (apiErr) {
+          return `Error: CodeReviewMulti failed — ${apiErr.message}`;
+        }
+
+        let result = header;
+        for (const review of reviews) {
+          result += `\n## Reviewer ${review.label} — ${review.perspective}\n${review.result}\n`;
+        }
+        if (onStream) onStream(truncateOutput(result));
+        return truncateOutput(result);
+      }
+
+      // ===== Commander — Terminal command specialist =====
+      case 'Commander': {
+        const header = `Commander (${COMMANDER_MODEL})\n${'─'.repeat(40)}\n`;
+        if (onStream) onStream(header + 'Planning commands...');
+
+        let commandPlan;
+        try {
+          commandPlan = await streamCompletion({
+            model: COMMANDER_MODEL,
+            messages: [
+              { role: 'system', content: COMMANDER_SYSTEM_PROMPT },
+              { role: 'user', content: args.prompt },
+            ],
+            max_tokens: 2048,
+            temperature: 0.2,
+          }, null);
+        } catch (apiErr) {
+          return `Error: Commander failed — ${apiErr.message}`;
+        }
+
+        // Parse command plan
+        let commands;
+        try {
+          commands = JSON.parse(commandPlan.replace(/```json?\n?/g, '').replace(/```/g, '').trim());
+          if (!Array.isArray(commands)) commands = [commands];
+        } catch {
+          return truncateOutput(`${header}Failed to parse command plan:\n${commandPlan}`);
+        }
+
+        // Execute commands in sequence
+        const results = [];
+        for (const cmd of commands) {
+          const command = typeof cmd === 'string' ? cmd : cmd.command;
+          const description = typeof cmd === 'string' ? '' : (cmd.description || '');
+          if (onStream) onStream(truncateOutput(`${header}Running: ${command}${description ? ` (${description})` : ''}...`));
+          try {
+            const output = execSync(command, {
+              encoding: 'utf-8',
+              timeout: TOOL_TIMEOUT,
+              cwd: PROJECT_ROOT,
+              maxBuffer: 1024 * 1024 * 5,
+              stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            results.push(`✓ ${command}${description ? `\n  (${description})` : ''}\n${(output || '').trim()}`);
+            session.commandsRun.push(command);
+          } catch (err) {
+            results.push(`✗ ${command}\nExit code: ${err.status}\n${(err.stdout || '').trim()}\n${(err.stderr || '').trim()}`);
+            session.commandsRun.push(command);
+            break;
+          }
+        }
+
+        const result = `${header}${results.join('\n\n')}`;
+        if (onStream) onStream(truncateOutput(result));
+        return truncateOutput(result);
+      }
+
+      // ===== ContextPruner — Conversation summarization =====
+      case 'ContextPruner': {
+        if (session.conversationHistory.length < 6) {
+          return 'Context pruning skipped — conversation is still short.';
+        }
+
+        const header = `Context Pruner\n${'─'.repeat(40)}\n`;
+        if (onStream) onStream(header + 'Summarizing conversation...');
+
+        const historyText = session.conversationHistory.map(m =>
+          `[${m.role}]: ${(m.content || '').slice(0, 1000)}`
+        ).join('\n');
+
+        try {
+          const summary = await streamCompletion({
+            model: CONTEXT_PRUNER_MODEL,
+            messages: [
+              { role: 'system', content: CONTEXT_PRUNER_SYSTEM_PROMPT },
+              { role: 'user', content: `# Conversation to summarize (${session.conversationHistory.length} messages)\n\n${historyText}` },
+            ],
+            max_tokens: 2048,
+            temperature: 0.2,
+          }, null);
+
+          // Replace conversation history with summary
+          const oldLen = session.conversationHistory.length;
+          session.conversationHistory = [
+            {
+              role: 'system',
+              content: `[Context Summary — ${oldLen} messages condensed]\n${summary}`,
+            },
+          ];
+
+          const result = `${header}Condensed ${oldLen} messages into summary.\n\n${summary}`;
+          if (onStream) onStream(truncateOutput(result));
+          return truncateOutput(result);
+        } catch (apiErr) {
+          return `Error: Context pruning failed — ${apiErr.message}`;
+        }
+      }
+
       default:
         return `Unknown tool: ${name}`;
     }