aiden-runtime 3.16.0

package/dist/core/agentLoop.js

@@ -0,0 +1,2718 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interruptCurrentCall = interruptCurrentCall;
+exports.setStatusEmitter = setStatusEmitter;
+exports.getBudgetState = getBudgetState;
+exports.surfaceRelevantMemories = surfaceRelevantMemories;
+exports.resolveTemplates = resolveTemplates;
+exports.streamOpenAIResponse = streamOpenAIResponse;
+exports.streamGeminiResponse = streamGeminiResponse;
+exports.planWithLLM = planWithLLM;
+exports.validatePlan = validatePlan;
+exports.buildDependencyGroups = buildDependencyGroups;
+exports.executePlan = executePlan;
+exports.respondWithResults = respondWithResults;
+exports.callLLM = callLLM;
+exports.deepResearch = deepResearch;
+// core/agentLoop.ts — 3-step agent loop:
+//   STEP 1: PLAN   — LLM outputs JSON plan only (no execution)
+//   STEP 2: EXECUTE — Code runs each tool, gets real results
+//   STEP 3: RESPOND — LLM sees real results, streams natural language
+const toolRegistry_1 = require("./toolRegistry");
+const recipeEngine_1 = require("./recipeEngine");
+const livePulse_1 = require("../coordination/livePulse");
+const planTool_1 = require("./planTool");
+const workspaceMemory_1 = require("./workspaceMemory");
+const taskState_1 = require("./taskState");
+const skillLoader_1 = require("./skillLoader");
+const entityGraph_1 = require("./entityGraph");
+const learningMemory_1 = require("./learningMemory");
+const conversationMemory_1 = require("./conversationMemory");
+const router_1 = require("../providers/router");
+const index_1 = require("../providers/index");
+const knowledgeBase_1 = require("./knowledgeBase");
+const skillTeacher_1 = require("./skillTeacher");
+const growthEngine_1 = require("./growthEngine");
+const aidenPersonality_1 = require("./aidenPersonality");
+const auditTrail_1 = require("./auditTrail");
+const mcpClient_1 = require("./mcpClient");
+const memoryRecall_1 = require("./memoryRecall");
+const costTracker_1 = require("./costTracker");
+const modelDiscovery_1 = require("./modelDiscovery");
+const semanticMemory_1 = require("./semanticMemory");
+const sessionMemory_1 = require("./sessionMemory");
+const goalTracker_1 = require("./goalTracker");
+const hooks_1 = require("./hooks");
+const instinctSystem_1 = require("./instinctSystem");
+const workflowTracker_1 = require("./workflowTracker");
+const parallelExecutor_1 = require("./parallelExecutor");
+const messageValidator_1 = require("./messageValidator");
+const toolNameRepair_1 = require("./toolNameRepair");
+const slashAsTool_1 = require("./slashAsTool");
+const planResponseRepair_1 = require("./planResponseRepair");
+const nodeFs = __importStar(require("fs"));
+const nodePath = __importStar(require("path"));
+const nodeOs = __importStar(require("os"));
+// ── Pre-compact threshold ──────────────────────────────────────
+// Fire pre_compact hook when history has this many messages
+const COMPACT_THRESHOLD = 40;
+// ── Interrupt / stop state ─────────────────────────────────────
+let currentAbortController = null;
+let executionInterrupted = false;
+function interruptCurrentCall() {
+    executionInterrupted = true;
+    if (currentAbortController) {
+        currentAbortController.abort();
+        currentAbortController = null;
+    }
+}
+// ── Status emitter — set per-request by server.ts, cleared on close ──
+let _emitStatus = null;
+function setStatusEmitter(fn) { _emitStatus = fn; }
+function emitStatus(action, detail) { _emitStatus?.(action, detail); }
+const TOOL_ACTION = {
+    web_search: 'searching', fetch_url: 'searching', deep_research: 'searching', social_research: 'searching',
+    fetch_page: 'reading', file_read: 'reading', file_list: 'reading',
+    file_write: 'writing',
+    run_python: 'coding', run_node: 'coding', shell_exec: 'coding',
+    run_powershell: 'coding', code_interpreter_python: 'coding', code_interpreter_node: 'coding',
+    open_browser: 'browsing', browser_extract: 'browsing', browser_screenshot: 'browsing',
+    browser_click: 'browsing', browser_type: 'browsing',
+};
+function toolStatusDetail(tool, input) {
+    if (!input)
+        return undefined;
+    switch (tool) {
+        case 'web_search':
+        case 'deep_research':
+        case 'social_research':
+            return input.query ? String(input.query).slice(0, 60) : undefined;
+        case 'run_python':
+        case 'code_interpreter_python':
+            return 'Python script';
+        case 'run_node':
+        case 'code_interpreter_node':
+            return 'Node script';
+        case 'open_browser':
+            return input.url ? String(input.url).slice(0, 60) : 'browser';
+        case 'browser_extract':
+        case 'browser_screenshot':
+        case 'fetch_page':
+        case 'fetch_url':
+            return input.url ? String(input.url).slice(0, 60) : 'page';
+        case 'file_read':
+        case 'file_write':
+        case 'file_list': {
+            const p = input.path || input.directory || '';
+            return p ? (String(p).split(/[/\\]/).pop() || String(p).slice(0, 40)) : undefined;
+        }
+        case 'shell_exec':
+        case 'run_powershell':
+            return input.command ? String(input.command).slice(0, 30) : undefined;
+        case 'get_stocks':
+            return input.symbol ?? (input.type ? `${input.market ?? ''} ${input.type}`.trim() : 'stocks');
+        case 'get_market_data':
+        case 'get_company_info':
+            return input.symbol ? String(input.symbol) : undefined;
+        default:
+            if (input.query)
+                return String(input.query).slice(0, 60);
+            if (input.url)
+                return String(input.url).slice(0, 60);
+            if (input.path)
+                return String(input.path).slice(0, 40);
+            if (input.command)
+                return String(input.command).slice(0, 30);
+            return undefined;
+    }
+}
+function getBudgetWarning(budget) {
+    const usage = budget.currentIteration / budget.maxIterations;
+    const remaining = budget.maxIterations - budget.currentIteration;
+    if (usage >= budget.warningThreshold) {
+        return `[BUDGET WARNING: Turn ${budget.currentIteration}/${budget.maxIterations}. Only ${remaining} turn(s) left. Provide your final response NOW. Do not start new tool calls.]`;
+    }
+    if (usage >= budget.cautionThreshold) {
+        return `[BUDGET: Turn ${budget.currentIteration}/${budget.maxIterations}. ${remaining} turns left. Start consolidating your work and prepare a response.]`;
+    }
+    return null;
+}
+let _activeBudget = null;
+function getBudgetState() {
+    if (!_activeBudget)
+        return null;
+    return {
+        current: _activeBudget.currentIteration,
+        max: _activeBudget.maxIterations,
+        remaining: _activeBudget.maxIterations - _activeBudget.currentIteration,
+    };
+}
+// ── Token-based preflight compression ─────────────────────────
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function estimateConversationTokens(messages) {
+    return messages.reduce((sum, msg) => {
+        const content = typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content || '');
+        return sum + estimateTokens(content) + 4; // 4 tokens per message overhead
+    }, 0);
+}
+const MODEL_CONTEXT_LIMITS = {
+    'llama-3.1-8b-instant': 8192,
+    'llama-3.3-70b-versatile': 32768,
+    'gemma-7b-it': 8192,
+    'gemma2-9b-it': 8192,
+    'mixtral-8x7b-32768': 32768,
+    'deepseek-r1-distill-llama-70b': 32768,
+    'qwen-2.5-72b-instruct': 32768,
+    'gemini-2.0-flash': 1048576,
+    'gemini-1.5-flash': 1048576,
+    'gpt-4o': 128000,
+    'claude-sonnet-4-20250514': 200000,
+    'gemini-3-flash': 1048576,
+    'gemini-3.1-pro': 1048576,
+    'gpt-5.3-codex': 200000,
+    'default': 8192,
+};
+function getContextLimit(model) {
+    return MODEL_CONTEXT_LIMITS[model] ?? MODEL_CONTEXT_LIMITS['default'];
+}
+async function flushMemoryFromMessages(messages) {
+    const userMessages = messages
+        .filter(m => m.role === 'user')
+        .map(m => String(m.content))
+        .join('\n');
+    if (userMessages.length > 100) {
+        try {
+            semanticMemory_1.semanticMemory.add(userMessages.slice(0, 500), 'exchange', ['preflight_compression']);
+            console.log('[Context] Memory flushed before compression');
+        }
+        catch {
+            console.log('[Context] Memory flush skipped — extractor unavailable');
+        }
+    }
+}
+async function preflightCompressionCheck(messages, model, sessionId) {
+    const tokenCount = estimateConversationTokens(messages);
+    const contextLimit = getContextLimit(model);
+    const usage = tokenCount / contextLimit;
+    console.log(`[Context] ${tokenCount} tokens / ${contextLimit} limit (${(usage * 100).toFixed(0)}%)`);
+    if (usage < 0.5) {
+        // Under 50% — no compression needed
+        return messages;
+    }
+    console.log(`[Context] Over 50% — compressing middle messages`);
+    // Track parent/child lineage across compressions
+    if (sessionId) {
+        try {
+            (0, sessionMemory_1.createChildSession)(sessionId, 'preflight_compression', messages.length, tokenCount);
+        }
+        catch {
+            console.log('[Context] Session lineage tracking skipped');
+        }
+    }
+    // Step 1: Flush memory before compressing
+    await flushMemoryFromMessages(messages);
+    // Step 2: Keep first 2 messages (system + first user) and last 10 messages
+    const protectedStart = messages.slice(0, 2);
+    const protectedEnd = messages.slice(-10);
+    const middleMessages = messages.slice(2, -10);
+    if (middleMessages.length < 3) {
+        return messages; // not enough to compress
+    }
+    // Step 3: Summarize middle messages into a single system message
+    const middleText = middleMessages
+        .map(m => `${m.role}: ${String(m.content).substring(0, 200)}`)
+        .join('\n');
+    const summary = {
+        role: 'system',
+        content: `[COMPRESSED CONTEXT — ${middleMessages.length} messages summarized]\n` +
+            `Previous conversation covered: ${middleText.substring(0, 1000)}\n` +
+            `[End compressed context]`,
+    };
+    const compressed = [...protectedStart, summary, ...protectedEnd];
+    const newTokens = estimateConversationTokens(compressed);
+    console.log(`[Context] Compressed: ${tokenCount} → ${newTokens} tokens ` +
+        `(${messages.length} → ${compressed.length} messages)`);
+    return compressed;
+}
+// ── Proactive memory surfacing ─────────────────────────────────
+const SKIP_MEMORY_PATTERNS = [
+    /^(hi|hello|hey|thanks|ok|yes|no|sure|bye)\b/i,
+    /^.{1,15}$/,
+];
+async function surfaceRelevantMemories(userMessage) {
+    if (SKIP_MEMORY_PATTERNS.some(p => p.test(userMessage.trim())))
+        return '';
+    const memories = [];
+    // 1. Semantic memory search
+    try {
+        const results = semanticMemory_1.semanticMemory.search(userMessage, 5);
+        for (const r of results) {
+            memories.push(`[Memory] ${r.text}`);
+        }
+    }
+    catch { }
+    // 2. Memory directory files — keyword match
+    try {
+        const memDir = nodePath.join(process.cwd(), 'workspace', 'memory');
+        if (nodeFs.existsSync(memDir)) {
+            const files = nodeFs.readdirSync(memDir).filter((f) => f.endsWith('.md'));
+            const keywords = userMessage.toLowerCase().split(/\s+/).filter((k) => k.length > 3);
+            for (const file of files) {
+                try {
+                    const content = nodeFs.readFileSync(nodePath.join(memDir, file), 'utf8');
+                    const contentLower = content.toLowerCase();
+                    const matches = keywords.filter((k) => contentLower.includes(k));
+                    if (matches.length >= 2) {
+                        const body = content.split('---').slice(2).join('---').trim();
+                        if (body.length > 0 && body.length < 500) {
+                            memories.push(`[Memory] ${body}`);
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    if (memories.length === 0)
+        return '';
+    const unique = [...new Set(memories)].slice(0, 8);
+    console.log(`[Memory] Surfaced ${unique.length} memories for: "${userMessage.substring(0, 40)}"`);
+    return '\n## Relevant Context from Memory\n' + unique.join('\n') + '\n';
+}
+// ── Template resolver ──────────────────────────────────────────
+// Replaces {{step_N_output}} tokens with actual step outputs
+function resolveTemplates(input, stepOutputs) {
+    return input.replace(/\{\{step_(\d+)_output\}\}/g, (_match, n) => {
+        const idx = parseInt(n, 10);
+        return stepOutputs[idx] ?? `(step ${idx} output unavailable)`;
+    });
+}
+// ── SSE stream helpers ─────────────────────────────────────────
+async function streamOpenAIResponse(res, onToken) {
+    if (!res.body)
+        return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.startsWith('data: '))
+                continue;
+            const raw = line.replace('data: ', '').trim();
+            if (raw === '[DONE]')
+                return;
+            try {
+                const parsed = JSON.parse(raw);
+                const token = parsed?.choices?.[0]?.delta?.content;
+                if (token)
+                    onToken(token);
+            }
+            catch { }
+        }
+    }
+}
+async function streamGeminiResponse(res, onToken) {
+    // Gemini streaming with ?alt=sse returns SSE events with data: prefix
+    if (!res.body)
+        return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.startsWith('data: '))
+                continue;
+            const raw = line.replace('data: ', '').trim();
+            try {
+                const parsed = JSON.parse(raw);
+                const text = parsed?.candidates?.[0]?.content?.parts?.[0]?.text;
+                if (text)
+                    onToken(text);
+            }
+            catch { }
+        }
+    }
+}
+// ── Provider endpoint map ──────────────────────────────────────
+const OPENAI_COMPAT_ENDPOINTS = {
+    groq: 'https://api.groq.com/openai/v1/chat/completions',
+    openrouter: 'https://openrouter.ai/api/v1/chat/completions',
+    cerebras: 'https://api.cerebras.ai/v1/chat/completions',
+    nvidia: 'https://integrate.api.nvidia.com/v1/chat/completions',
+    github: 'https://models.inference.ai.azure.com/v1/chat/completions',
+    boa: 'https://api.bayofassets.com/v1/chat/completions',
+};
+function buildHeaders(providerName, apiKey) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+    };
+    if (providerName === 'openrouter') {
+        headers['HTTP-Referer'] = 'http://localhost:3000';
+        headers['X-Title'] = 'DevOS';
+    }
+    return headers;
+}
+// ── Phase inference from tool steps ───────────────────────────
+// Groups consecutive steps of the same capability type into phases.
+function inferPhasesFromSteps(steps) {
+    const capabilityMap = {
+        web_search: 'research', fetch_page: 'research',
+        deep_research: 'research', fetch_url: 'research',
+        get_stocks: 'research',
+        open_browser: 'browsing', browser_click: 'browsing',
+        browser_extract: 'browsing', browser_type: 'browsing',
+        mouse_move: 'browsing', mouse_click: 'browsing',
+        keyboard_type: 'browsing', keyboard_press: 'browsing',
+        screenshot: 'browsing', screen_read: 'browsing',
+        vision_loop: 'browsing',
+        file_write: 'writing', file_read: 'reading',
+        file_list: 'reading', shell_exec: 'execution',
+        run_python: 'execution', run_node: 'execution',
+        system_info: 'execution', notify: 'execution',
+        clipboard_read: 'execution', clipboard_write: 'execution',
+        window_list: 'execution', window_focus: 'execution',
+        app_launch: 'execution', app_close: 'execution',
+        watch_folder: 'execution', watch_folder_list: 'execution',
+    };
+    const phaseNames = {
+        research: 'Research & Gather',
+        browsing: 'Browse & Extract',
+        writing: 'Write & Save',
+        reading: 'Read & Analyze',
+        execution: 'Execute Tasks',
+        delivery: 'Deliver Results',
+    };
+    const phases = [];
+    let currentCap = '';
+    let currentTools = [];
+    for (const step of steps) {
+        const cap = capabilityMap[step.tool] || 'execution';
+        if (cap !== currentCap && currentTools.length > 0) {
+            phases.push({
+                id: `phase_${phases.length + 1}`,
+                title: phaseNames[currentCap] || currentCap,
+                capabilities: [currentCap],
+                tools: [...currentTools],
+            });
+            currentTools = [];
+        }
+        currentCap = cap;
+        currentTools.push(step.tool);
+    }
+    if (currentTools.length > 0) {
+        phases.push({
+            id: `phase_${phases.length + 1}`,
+            title: phaseNames[currentCap] || currentCap,
+            capabilities: [currentCap],
+            tools: currentTools,
+        });
+    }
+    // Always end with a Deliver Results phase
+    phases.push({
+        id: `phase_${phases.length + 1}`,
+        title: 'Deliver Results',
+        capabilities: ['delivery'],
+        tools: ['respond'],
+    });
+    return phases;
+}
+// ── Keyword-based plan inference — fallback when LLM unavailable ──────
+// Detects simple single-tool intents from the message text.
+function inferPlanFromKeywords(message) {
+    const m = message.toLowerCase();
+    // notify
+    if (/send\s+(a\s+)?(desktop\s+)?notif|notify\s+me|desktop\s+alert/.test(m)) {
+        const msgMatch = message.match(/saying\s+(.+?)(?:\s*$)/i);
+        const notifMsg = msgMatch ? msgMatch[1].trim() : message;
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'notify', input: { message: notifMsg }, description: 'Send notification' }],
+            phases: [],
+        };
+    }
+    // file_read — matches "read the file /path/to/file", "read file C:\...", "tell me what it says"
+    const fileReadMatch = message.match(/read\s+(?:the\s+)?file\s+([^\s"']+)/i) ||
+        message.match(/read\s+([A-Z]:[/\\][^\s"']+)/i) ||
+        message.match(/read\s+(\/[^\s"']+\.\w{1,6})/i);
+    if (fileReadMatch) {
+        const filePath = fileReadMatch[1].trim();
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'file_read', input: { path: filePath }, description: `Read ${filePath}` }],
+            phases: [],
+        };
+    }
+    // file_write — matches "write ... to /path/file"
+    const fileWriteMatch = message.match(/write\s+(.+?)\s+to\s+([^\s"']+\.\w{1,6})/i);
+    if (fileWriteMatch) {
+        const content = fileWriteMatch[1].trim();
+        const filePath = fileWriteMatch[2].trim();
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'file_write', input: { path: filePath, content }, description: `Write to ${filePath}` }],
+            phases: [],
+        };
+    }
+    // fetch_url — matches "Fetch https://...", "fetch http://...", "get https://..."
+    const fetchUrlMatch = message.match(/(?:fetch|get|open|load)\s+(https?:\/\/[^\s"']+)/i) ||
+        message.match(/(https?:\/\/[^\s"']+)/i);
+    if (fetchUrlMatch) {
+        const url = fetchUrlMatch[1].trim();
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'fetch_url', input: { url }, description: `Fetch ${url}` }],
+            phases: [],
+        };
+    }
+    // web_search / search the web
+    if (/search\s+(the\s+)?web|web\s+search|look\s+up|find\s+info/.test(m)) {
+        const query = message.replace(/search\s+(the\s+)?web\s+(for\s+)?/i, '').replace(/look\s+up\s+/i, '').trim();
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'web_search', input: { query: query || message }, description: 'Search' }],
+            phases: [],
+        };
+    }
+    // get_stocks / stock gainers
+    if (/top\s+(gainers|losers|active)|nse\s+top|bse\s+top|stock\s+(market|data|gainers)|get\s+stocks/.test(m)) {
+        const isLosers = /loser/.test(m);
+        const market = /bse/.test(m) ? 'BSE' : 'NSE';
+        const type = isLosers ? 'losers' : /active/.test(m) ? 'active' : 'gainers';
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'get_stocks', input: { market, type }, description: `Get ${market} top ${type}` }],
+            phases: [],
+        };
+    }
+    // system_info
+    if (/system\s+info|hardware\s+info|what.{0,10}(cpu|ram|memory|os|specs)|show\s+system|computer\s+specs/.test(m)) {
+        return {
+            goal: message, requires_execution: true,
+            plan: [{ step: 1, tool: 'system_info', input: {}, description: 'Get system info' }],
+            phases: [],
+        };
+    }
+    // run_python / run_node fast-path intentionally removed.
+    // These tools require actual executable source code in their input, which we cannot
+    // fabricate from a natural-language description. If all LLMs are down we cannot
+    // generate code, so we fall through to null and let the caller handle gracefully.
+    return null;
+}
+// ── Sprint 5: Planner racing helper ──────────────────────────
+// Fires top-2 available APIs simultaneously; returns first valid JSON string.
+async function racePlannerAPIs(promptText, topN = 2) {
+    const cfg = (0, index_1.loadConfig)();
+    const candidates = [];
+    for (const cp of (cfg.customProviders ?? [])) {
+        if (!cp.enabled || !cp.baseUrl)
+            continue;
+        candidates.push({ provider: 'custom', model: cp.model, key: cp.apiKey, url: cp.baseUrl, tier: cp.tier ?? 99 });
+    }
+    for (const a of cfg.providers.apis) {
+        if (!a.enabled || a.rateLimited)
+            continue;
+        const k = a.key.startsWith('env:') ? (process.env[a.key.replace('env:', '')] || '') : a.key;
+        if (!k || !OPENAI_COMPAT_ENDPOINTS[a.provider])
+            continue;
+        candidates.push({ provider: a.provider, model: a.model, key: k, url: OPENAI_COMPAT_ENDPOINTS[a.provider], tier: a.tier ?? 50 });
+    }
+    const pool = candidates.sort((a, b) => a.tier - b.tier).slice(0, topN);
+    if (pool.length < 1)
+        return null;
+    const controllers = pool.map(() => new AbortController());
+    const callOne = async (entry, ctrl) => {
+        const messages = [{ role: 'user', content: promptText }];
+        const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${entry.key}` };
+        if (entry.provider !== 'custom') {
+            Object.assign(headers, buildHeaders(entry.provider, entry.key));
+        }
+        const r = await fetch(entry.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ model: entry.model, messages, stream: false, max_tokens: 2000 }),
+            signal: AbortSignal.any([AbortSignal.timeout(45000), ctrl.signal]),
+        });
+        if (!r.ok)
+            throw new Error(`${entry.provider} ${r.status}`);
+        const d = await r.json();
+        const text = d?.choices?.[0]?.message?.content || '';
+        if (!text.trim() || !text.includes('{'))
+            throw new Error('no JSON');
+        return text;
+    };
+    const promises = pool.map((entry, i) => callOne(entry, controllers[i]).then(text => {
+        controllers.forEach((c, j) => { if (j !== i) {
+            try {
+                c.abort();
+            }
+            catch { }
+        } });
+        return text;
+    }));
+    try {
+        return await Promise.race(promises);
+    }
+    catch { }
+    return null;
+}
+// ── Compaction protection — critical files survive context reset ──
+// When the sliding context window summarizes older messages, we re-inject
+// these files word-for-word as a system message so identity and rules survive.
+const COMPACTION_PROTECTED = [
+    'SOUL.md', // personality + boundaries
+    'STANDING_ORDERS.md', // persistent instructions
+    'LESSONS.md', // failure rules
+    'GOALS.md', // active goals
+    'USER.md', // user profile
+];
+async function rebuildContextAfterCompaction(contextHistory) {
+    const workspaceDir = nodePath.join(process.cwd(), 'workspace');
+    const protectedContent = [];
+    // Read all protected files
+    for (const filename of COMPACTION_PROTECTED) {
+        try {
+            const filepath = nodePath.join(workspaceDir, filename);
+            if (nodeFs.existsSync(filepath)) {
+                const content = nodeFs.readFileSync(filepath, 'utf-8');
+                if (content.trim()) {
+                    protectedContent.push(`## ${filename}\n${content.trim()}`);
+                }
+            }
+        }
+        catch { }
+    }
+    // Top 5 instincts by confidence (read directly from workspace/instincts.json)
+    let instinctCount = 0;
+    try {
+        const instinctsPath = nodePath.join(workspaceDir, 'instincts.json');
+        if (nodeFs.existsSync(instinctsPath)) {
+            const raw = JSON.parse(nodeFs.readFileSync(instinctsPath, 'utf-8'));
+            const topInsts = raw
+                .filter(i => i.status === 'active' && i.confidence >= 0.7)
+                .sort((a, b) => b.confidence - a.confidence)
+                .slice(0, 5);
+            if (topInsts.length > 0) {
+                const instinctText = topInsts
+                    .map(i => `- ${i.action} (confidence: ${(i.confidence * 100).toFixed(0)}%)`)
+                    .join('\n');
+                protectedContent.push(`## Active Instincts\n${instinctText}`);
+                instinctCount = topInsts.length;
+            }
+        }
+    }
+    catch { }
+    if (protectedContent.length === 0)
+        return contextHistory;
+    console.log(`[Compaction] Protected ${COMPACTION_PROTECTED.length} files ` +
+        `+ ${instinctCount} instincts — re-injected into context`);
+    const protectedMessage = {
+        role: 'system',
+        content: `[PROTECTED CONTEXT — survives compaction]\n\n${protectedContent.join('\n\n---\n\n')}`,
+    };
+    return [protectedMessage, ...contextHistory];
+}
+// ── STEP 1: planWithLLM ────────────────────────────────────────
+async function planWithLLM(message, history, apiKey, model, provider, memoryContext) {
+    // ── Pre-compact hook — fire at multiples of COMPACT_THRESHOLD ─
+    // Fires at 40, 80, 120 … to avoid triggering on every message after crossing 40.
+    if (history.length >= COMPACT_THRESHOLD && history.length % COMPACT_THRESHOLD === 0) {
+        (0, hooks_1.fireHook)('pre_compact', { historyLength: history.length, message }).catch(() => { });
+    }
+    // ── Vague goal detection — ask for clarification before planning ──
+    const VAGUE_PATTERNS = [/\bthe thing\b/i, /\bthe stuff\b/i, /\bthe place\b/i, /\bdo it\b$/i, /\bfix it\b$/i];
+    if (VAGUE_PATTERNS.some(p => p.test(message))) {
+        return {
+            goal: message,
+            requires_execution: false,
+            plan: [],
+            phases: [],
+            direct_response: 'I need more detail. What specifically should I do, with what, and where?',
+            reason: 'goal_too_vague',
+        };
+    }
+    // ── Recipe engine — YAML workflow definitions ─────────────────
+    // Check before LLM planning: if a recipe trigger matches, execute
+    // the structured workflow instead of the probabilistic planner.
+    const recipes = (0, recipeEngine_1.loadAllRecipes)();
+    const recipeMatch = (0, recipeEngine_1.matchRecipe)(message, recipes);
+    if (recipeMatch) {
+        try {
+            const recipeResult = await (0, recipeEngine_1.executeRecipe)(recipeMatch.recipe, recipeMatch.params);
+            return {
+                goal: message,
+                requires_execution: false,
+                plan: [],
+                phases: [],
+                direct_response: recipeResult.output || `Completed recipe: ${recipeMatch.recipe.name}`,
+                reason: `recipe:${recipeMatch.recipe.name}`,
+            };
+        }
+        catch (err) {
+            console.warn(`[Recipe] Execution failed for ${recipeMatch.recipe.name}: ${err} — falling through to LLM planner`);
+        }
+    }
+    const ALLOWED_TOOLS = [
+        'web_search', 'fetch_page', 'open_browser', 'browser_extract',
+        'browser_click', 'browser_type', 'browser_screenshot', 'browser_scroll', 'browser_get_url',
+        'file_write', 'file_read',
+        'file_list', 'shell_exec', 'run_python', 'run_node',
+        'system_info', 'notify', 'deep_research', 'get_stocks',
+        'get_market_data', 'get_company_info', 'social_research',
+        'mouse_move', 'mouse_click', 'keyboard_type', 'keyboard_press',
+        'screenshot', 'screen_read', 'vision_loop', 'wait',
+        'code_interpreter_python', 'code_interpreter_node',
+        'clipboard_read', 'clipboard_write', 'window_list', 'window_focus',
+        'app_launch', 'app_close',
+        'watch_folder', 'watch_folder_list',
+        'send_file_local', 'receive_file_local',
+        'get_briefing',
+        'respond',
+        'clarify', 'todo', 'cronjob', 'vision_analyze',
+        'voice_speak', 'voice_transcribe', 'voice_clone', 'voice_design',
+        'lookup_skill', 'lookup_tool_schema',
+        'spawn', 'spawn_subagent', 'swarm',
+        ...slashAsTool_1.SLASH_MIRROR_TOOL_NAMES,
+    ];
+    // Sprint 13: append discovered MCP tools
+    const mcpToolNames = mcpClient_1.mcpClient.getAllCachedTools().map(t => t.name);
+    const allTools = mcpToolNames.length > 0
+        ? [...ALLOWED_TOOLS, ...mcpToolNames]
+        : ALLOWED_TOOLS;
+    // Dynamic tool loading — filter to relevant tools per task category
+    // Reduces planner prompt from ~15K to ~3-5K tokens without losing capability.
+    // Validation (line ~898) still uses full allTools — filtering is prompt-only.
+    const categories = (0, toolRegistry_1.detectToolCategories)(message);
+    const categoryTools = (0, toolRegistry_1.getToolsForCategories)(categories);
+    // MCP tools always included; ALLOWED_TOOLS filtered by detected category
+    const plannerTools = allTools.filter(t => t.startsWith('mcp_') || categoryTools.includes(t));
+    console.log(`[Tools] ${plannerTools.length}/${allTools.length} tools loaded for categories: ${categories.join(', ')}`);
+    // Load any relevant skills to guide planning
+    const relevantSkills = skillLoader_1.skillLoader.findRelevant(message);
+    const skillContext = skillLoader_1.skillLoader.formatForPrompt(relevantSkills);
+    // Append instinct context to memory (micro-patterns learned from past tool calls)
+    const instinctCtx = instinctSystem_1.instinctSystem?.getRelevantInstincts(message) || '';
+    const fullMemCtx = (memoryContext || '') + (instinctCtx ? '\n\n' + instinctCtx : '');
+    // Build memory section — inject when available
+    const memorySection = fullMemCtx.trim()
+        ? `\n\nCONVERSATION MEMORY (use to resolve references like "that file", "the report", "it"):\n${fullMemCtx}\n\nWhen the user says "that file", "the report", "the script" etc., use the paths/queries above to resolve them into concrete values in your plan inputs.\n`
+        : '';
+    // Build learning context — past experiences with similar tasks
+    const learningCtx = learningMemory_1.learningMemory.buildLearningContext(message);
+    const learningSection = learningCtx ? `\n${learningCtx}\n` : '';
+    // Build knowledge context — relevant chunks from user's knowledge base files
+    const knowledgeCtxPlanner = knowledgeBase_1.knowledgeBase.buildContext(message);
+    const knowledgeSection = knowledgeCtxPlanner
+        ? `\n\n${knowledgeCtxPlanner}\n`
+        : '';
+    // LESSONS.md — permanent failure rules, injected every session
+    const lessonsContent = loadLessons();
+    const lessonsSection = lessonsContent
+        ? `\n\nPERMANENT FAILURE RULES (learned from past task failures — follow strictly):\n${lessonsContent.split('\n').filter(l => /^\d+\./.test(l.trim())).map(l => `  ${l.trim()}`).join('\n')}\n`
+        : '';
+    // Sprint 21: unified memory recall — only when message references past context
+    // Gate prevents unnecessary hybrid-search I/O on routine messages
+    let memoryRecallSection = '';
+    if ((0, skillLoader_1.needsMemory)(message)) {
+        try {
+            const recalled = await (0, memoryRecall_1.unifiedMemoryRecall)(message, 5);
+            const memoryInjected = (0, memoryRecall_1.buildMemoryInjection)(recalled);
+            if (memoryInjected) {
+                memoryRecallSection = memoryInjected;
+            }
+        }
+        catch { }
+    }
+    // N+27: inject distilled facts from past sessions into planner context
+    // N+33: also inject smart-sliced Honcho user profile (replaces dumb full-dump)
+    let distilledFactsSection = '';
+    try {
+        const factHits = semanticMemory_1.semanticMemory.search(message, 5, 0.3)
+            .filter((r) => r.metadata?.type === 'fact')
+            .slice(0, 5);
+        if (factHits.length > 0) {
+            const factLines = factHits
+                .map((r) => `- ${r.text ?? ''}`)
+                .filter((l) => l.length > 3)
+                .join('\n');
+            if (factLines.trim()) {
+                distilledFactsSection = `\n\nREMEMBERED CONTEXT (facts distilled from past sessions — use to resolve references and avoid repeating work):\n${factLines}\n`;
+            }
+        }
+    }
+    catch { }
+    // N+33: smart Honcho profile slice injection (zero LLM cost — regex classifier)
+    let honchoProfileSection = '';
+    try {
+        const { formatForPrompt } = await Promise.resolve().then(() => __importStar(require('./userProfile')));
+        honchoProfileSection = await formatForPrompt(message);
+    }
+    catch { }
+    // Resolve the actual Windows username and home directory at runtime
+    const _sysUsername = process.env.USERNAME || process.env.USER || nodeOs.userInfo().username || 'User';
+    const _sysHomedir = nodeOs.homedir();
+    const plannerPrompt = `You are DevOS Planner. Analyze the user request and output a JSON plan.
+
+GOAL DECOMPOSITION: Before writing your plan, count the distinct intents in the user message.
+If the message contains 2 or more distinct goals (e.g., "search X AND write a file", "do A then B", "1. … 2. …"), add a "goals" array to your JSON listing each goal as a short phrase (max 8 words each). Your plan MUST cover ALL listed goals — do not silently drop any.
+Single-goal messages: omit "goals" or leave it as an empty array.
+
+SYSTEM CONTEXT — use these exact values for all file paths:
+- Windows username: ${_sysUsername}
+- Home directory: ${_sysHomedir}
+- Desktop: ${nodePath.join(_sysHomedir, 'Desktop')}
+- Documents: ${nodePath.join(_sysHomedir, 'Documents')}
+- Downloads: ${nodePath.join(_sysHomedir, 'Downloads')}
+IMPORTANT: NEVER use "C:\\Users\\Aiden" — "Aiden" is the AI assistant's name, NOT the Windows username. Always use "${_sysUsername}" as the username in any path.
+
+CRITICAL RULES:
+1. If the answer is in your training data (capitals, definitions, facts, opinions, advice) → requires_execution: false
+2. ONLY use tools when you need: live data, file operations, running code, or computer control
+3. AVAILABLE TOOLS (use ONLY these — name: one-liner):
+${plannerTools.map(t => `  ${t}: ${toolRegistry_1.TOOL_NAMES_ONLY[t] ?? ''}`).join('\n')}
+  For full parameter schema: call lookup_tool_schema({ toolName: "name" })
+  Tier-0 (no lookup needed): web_search, notify, lookup_skill, lookup_tool_schema, schedule_reminder, file_read, file_write, respond
+4. DO NOT invent tools like "identify_top_3", "generate_report", "analyze" — these don't exist
+5. Processing/analysis happens in your response — NOT as a tool step
+6. NEVER use placeholders like "{{result}}" or "{output}" — steps must have real concrete inputs
+7. For multi-step tasks: if step N+1 needs step N's output, use the literal string "PREVIOUS_OUTPUT"
+   CRITICAL: Step 1 CANNOT use "PREVIOUS_OUTPUT" — there is no previous step. Step 1 must always have a literal concrete input value (e.g. a real URL, search query, or file path).
+8. Output ONLY valid JSON — no text before or after
+
+SCHEDULER (CRITICAL): You have a real persistent scheduler. When the user asks for a reminder, alarm, or time-delayed action ("remind me in N seconds/minutes/hours", "in N minutes do X", "every day at..."):
+- You MUST call schedule_reminder — this is the ONLY correct path.
+- Params: message (what to say), delaySeconds calculated from the user's request (e.g. "10 minutes" → delaySeconds: 600)
+- For recurring reminders add: recurring: "hourly" | "daily" | "weekly"
+- After scheduling, confirm with the exact fire time (e.g. "Done — I'll remind you at 3:45 PM.")
+- To see pending reminders: schedule_reminder with op: "list"
+- To cancel: schedule_reminder with op: "cancel" and the reminder id
+- STRICTLY FORBIDDEN — these are ALL wrong and must NEVER appear in a reminder plan:
+  • Using wait in a loop (e.g. wait(5000) × N) — this blocks the whole system
+  • Using run_node or run_python with setTimeout/sleep to simulate a delay
+  • Saying "Waiting N seconds..." in a respond step and then firing notify
+  • Responding inline with the reminder message instead of scheduling it
+  schedule_reminder fires a real desktop notification asynchronously — set it and respond immediately.
+
+RUN_AGENT HONESTY: run_agent executes inline — the result comes directly in your next response. NEVER tell the user "your research is being processed", "the agent is working in background", or "results will be ready soon". If you use run_agent, the answer is available immediately in the same response turn.
+
+SUBAGENTS (CRITICAL):
+Use spawn_subagent when the user's task has independent parallel sub-questions (e.g., "research X AND summarize Y AND find Z"):
+- Each spawn_subagent call runs an isolated agent with its own context and half your remaining iteration budget
+- Spawn returns the subagent's synthesized answer — it is available immediately, not in the background
+- After spawning, synthesize all results into a unified final response, clearly attributing: "From a parallel research subagent: <result>"
+
+When NOT to use spawn_subagent:
+- Simple linear tasks (plan the steps yourself)
+- Single-tool questions (just call the tool)
+- Quick lookups (respond directly)
+
+NEVER say "the subagent is working in background" — spawn_subagent is synchronous and returns before your response.
+
+WHEN TO USE TOOLS vs NOT:
+✅ Use tools for:
+- Weather, news, current prices → web_search
+- Opening websites → open_browser
+- Writing/reading files → file_write, file_read
+- Running code → run_python, run_node
+- System info → system_info
+- Research with real sources → deep_research
+- Git repo state (status, branch, commits, changes) → git_status — ALWAYS run the tool, never answer from training data
+- Compound tasks needing multiple steps (fetch + process + save) → run
+
+## When to use the run tool
+
+For compound tasks that need multiple steps, prefer run over separate tool calls.
+Write JavaScript that composes the aiden SDK:
+
+  aiden.web.search(query), aiden.file.write(path, content), aiden.shell.exec(cmd), etc.
+
+This collapses what would be 5 LLM turns into 1. Much faster.
+
+Example — instead of:
+  turn 1: web_search("hn top")
+  turn 2: fetch_url(article[0].url)
+  turn 3: web_search(related)
+  turn 4: file_write(summary)
+
+Use run:
+  const top = await aiden.web.search("hn top")
+  const article = await aiden.web.fetch(top[0].url)
+  const related = await aiden.web.search(article.title)
+  await aiden.file.write("/tmp/brief.md", ...)
+
+❌ Do NOT use tools for:
+- "What is the capital of X" → just answer
+- "Who is [famous person]" → just answer
+- "Explain X concept" → just answer
+- "What do you think about X" → just answer
+- Any question answerable from training knowledge
+
+TOOL INPUT RULES (Tier-0 examples — for all others call lookup_tool_schema first):
+- web_search: { "query": "specific search term" }
+- notify: { "message": "text to show", "title": "optional title" }
+- respond: { "message": "your reply text" }
+- lookup_skill: { "query": "task description" }
+- lookup_tool_schema: { "toolName": "tool_name" }  — returns full description for any tool
+- wait: { "ms": 2000 }  — ONLY after browser/UI actions. Max 5000ms. NOT for reminders.
+
+TOOL DISCOVERY: If you are unsure of a tool's parameters, call lookup_tool_schema FIRST (as step 1 of your plan) with the toolName, then use the returned description to build the real tool step.
+
+COMPUTER CONTROL RULES — follow strictly when controlling mouse/keyboard/browser:
+- ALWAYS use open_browser BEFORE keyboard_type or mouse_click on browser
+- ALWAYS add a wait step of 2000ms after open_browser before any interaction
+- For web searches: step 1 = open_browser(url), step 2 = wait(2000), step 3 = keyboard_press(ctrl+l), step 4 = keyboard_type(query), step 5 = keyboard_press(enter)
+- For clicking browser address bar: use keyboard_press(ctrl+l) to focus it first
+- After typing a URL: use keyboard_press(enter) to navigate
+- For vision_loop tasks: set max_steps to at least 5
+- Never assume the browser is already open — always open it first
+- After any mouse_click: add wait(800) to let UI respond
+
+URL RULES:
+- Always use COMPLETE URLs — never truncate a URL in a tool input
+- For market-wide queries (gainers, losers, most active) → use get_stocks, NOT web_search
+- For individual stock price / market data → use get_market_data({ "symbol": "RELIANCE" })
+- For company profile, financials, P/E ratio, EPS → use get_company_info({ "symbol": "RELIANCE" })
+- Example: get_stocks({ "market": "NSE", "type": "gainers" })
+
+OUTPUT FORMAT (strict JSON only):
+{
+  "goal": "exact user request",
+  "goals": ["goal 1 short phrase", "goal 2 short phrase"],
+  "requires_execution": true,
+  "reasoning": "one sentence why",
+  "plan": [
+    { "step": 1, "tool": "web_search", "input": { "query": "weather London today" }, "description": "Get London weather" }
+  ]
+}
+
+CODE TOOL RULES — the "code" / "script" field MUST contain executable source, NEVER a description:
+- run_python: { "tool": "run_python", "input": { "code": "def reverse(s):\n    return s[::-1]\n\nprint(reverse('hello'))" } }
+  NOT: { "input": { "code": "a python script that reverses a string" } }
+- run_node:   { "tool": "run_node",   "input": { "code": "console.log([1,2,3].map(x => x*2))" } }
+  NOT: { "input": { "code": "node script to double array elements" } }
+- shell_exec: { "tool": "shell_exec", "input": { "command": "echo hello" } }
+  NOT: { "input": { "command": "a command that prints hello" } }
+If the user says "write a python script that prints fibonacci numbers up to 10", the plan step must contain the actual working Python source code, not the user's English description.
+
+If requires_execution is false:
+{ "goal": "...", "requires_execution": false, "reasoning": "...", "plan": [], "direct_response": "your answer here" }
+
+NOTE: "goals" is only required when 2+ distinct intents are present. Single-goal messages may omit it.
+
+THE 'respond' TOOL — use this for ALL conversational messages:
+- 'respond' is ALWAYS a valid plan. When no external tool is needed, plan a single respond step.
+- respond: { "message": "your answer text here" }
+- Use respond for: greetings, capability questions, simple facts from training data, clarifying questions, short answers.
+- Example: user says "hi" → { "goal": "hi", "requires_execution": true, "plan": [{ "step": 1, "tool": "respond", "input": { "message": "Hi! What can I help you with today?" } }] }
+
+ACTION GATE RULES — apply BEFORE creating any plan:
+1. CAPABILITY GATE: If message is "Can you do X?" / "Can you X?" / "Are you able to X?" → plan respond with answer
+2. EXPLICIT-ASK GATE: ONLY use file_write if user said "write", "save", "create file". ONLY use deep_research if user said "research", "find out", "look up"
+3. VAGUENESS GATE: If request is AMBIGUOUS, plan a respond step that asks ONE clarifying question:
+   - "do marketing" → respond: "What specifically? Copywriting, competitor research, Product Hunt listing, or content calendar?"
+   - "check my system" → respond: "What aspect? Hardware specs, running processes, disk space, or network?"
+   - "build something" → respond: "What would you like me to build?"
+   - Clear requests execute directly: "check NIFTY price" → get_market_data, "write a Python script to X" → run_python
+4. NEVER create comparison tables, reports, or verdicts unless user explicitly asked for them
+5. NEVER mention Pega, BlueWinston, Gaude Digital, or any third-party product by name
+
+## SKILL DISCOVERY
+
+Before planning any multi-step task (>=2 tools), call lookup_skill with the user's message as the query.
+- If it returns a skill, read the Steps section and follow that tool sequence as your plan.
+- If it returns no match (score < threshold), proceed with normal planning.
+- lookup_skill is Tier 1 — it is fast and free. Never skip it for multi-step tasks.
+
+## Tool Priority Rules (STRICT)
+
+TIER 1 (USE FIRST): lookup_skill, respond, web_search, fetch_page, fetch_url, deep_research, get_market_data, get_stocks, get_company_info, social_research, system_info, notify, get_briefing, run_agent
+  → ALWAYS try these before anything else
+  → If a task CAN be done via API/data tool, use that
+
+TIER 2 (USE SECOND): file_write, file_read, file_list, shell_exec, run_powershell, run_python, run_node, code_interpreter_python, code_interpreter_node, git_status, git_commit, git_push, clipboard_read, clipboard_write, spawn_subagent, swarm
+  → Use when you need to read/write files, run scripts, or run git commands
+
+TIER 3 (USE THIRD): open_browser, browser_click, browser_type, browser_extract, browser_screenshot, window_list, window_focus, app_launch, app_close
+  → ONLY when task requires interacting with a website UI
+  → NEVER use browser when an API tool can do the same job
+  → For other selectors always pass selector: "<css selector>", never guess at element text.
+
+BROWSER CHAIN (CRITICAL): When the user wants to CONSUME content — not just see search results — you MUST emit a TWO-STEP plan:
+  Step 1: open_browser with the search/query URL
+  Step 2: browser_click with target: "first_result"
+  browser_click handles site-specific waiting and navigation automatically for: youtube.com, google.com, duckduckgo.com, bing.com.
+
+  Phrases that REQUIRE the chain (open_browser → browser_click first_result):
+  • "play [song/video/anything]" — open YouTube search → click first result
+  • "watch [anything]"
+  • "open the article about X" / "open the top result"
+  • "read about X" when it implies opening a page, not just searching
+  • "find and play" / "find and read" / "find and open"
+  • Any request where the user clearly wants to land on the content page
+
+  Phrases that do NOT require the chain (open_browser alone is fine):
+  • "search for X" / "search YouTube for X"
+  • "show me search results for X"
+  • "look up X" / "find news about X"
+  • "open youtube" / "go to google.com" (no specific content target)
+
+  When in doubt, chain the click — users want the content, not the search page.
+
+TIER 4 (LAST RESORT): mouse_move, mouse_click, keyboard_type, keyboard_press, screenshot, screen_read, vision_loop
+  → ONLY when browser fails or for desktop apps with no API
+  → ALWAYS explain WHY lower tiers won't work
+
+VIOLATIONS (these are WRONG — do not do these):
+- Using open_browser to check stock price when get_market_data exists
+- Using screenshot to search when web_search exists
+- Using browser to get weather when web_search exists
+- Using vision_loop for any task where a simpler tool works
+
+FAILURE REPLANNING RULES (when message contains "previous approach failed at"):
+- Keep new plan to max 2 steps
+- Use ONLY the specific alternative approach mentioned in the message
+- DO NOT add web_search, deep_research, file_write, or notify unless directly needed
+- DO NOT add unrelated analysis or comparison steps
+${skillContext}${memorySection}${learningSection}${knowledgeSection}${memoryRecallSection}${distilledFactsSection}${honchoProfileSection}${lessonsSection}${(() => { const s = (0, goalTracker_1.getActiveGoalsSummary)(); return s ? `\n\n## Your Active Goals\n${s}` : ''; })()}
+Output ONLY valid JSON, nothing else:`;
+    const cleanHistory = history
+        .filter((h) => h.content && String(h.content).trim().length > 0);
+    console.log(`[Planner] History: ${cleanHistory.length} messages (${history.length} raw)`);
+    // ── Sliding context window — keep last 10, summarize older messages ──
+    const RECENT_WINDOW = 10;
+    let contextHistory = cleanHistory;
+    if (cleanHistory.length > RECENT_WINDOW) {
+        const recent = cleanHistory.slice(-RECENT_WINDOW);
+        const older = cleanHistory.slice(Math.max(0, cleanHistory.length - RECENT_WINDOW * 2), cleanHistory.length - RECENT_WINDOW);
+        if (older.length > 0) {
+            try {
+                const summaryInput = older.map((m) => `${m.role}: ${String(m.content).slice(0, 200)}`).join('\n');
+                const summary = await callLLM(`Summarize these messages in 2-3 sentences, keeping key facts and decisions:\n\n${summaryInput}`, '', (0, router_1.getOllamaModelForTask)('executor'), 'ollama').catch(() => null);
+                if (summary) {
+                    const compacted = [{ role: 'system', content: `Earlier conversation summary: ${summary}` }, ...recent];
+                    contextHistory = await rebuildContextAfterCompaction(compacted);
+                    console.log(`[Planner] Context window: summarized ${older.length} older messages`);
+                }
+                else {
+                    contextHistory = await rebuildContextAfterCompaction(recent);
+                }
+            }
+            catch {
+                contextHistory = recent;
+            }
+        }
+    }
+    const messages = [
+        { role: 'system', content: plannerPrompt },
+        ...contextHistory.slice(-3).map((h) => ({
+            role: h.role === 'assistant' ? 'assistant' : 'user',
+            content: String(h.content).slice(0, 300),
+        })),
+        { role: 'user', content: message },
+    ];
+    // ── Sprint 6: Task-tiered provider selection ─────────────────
+    // Always use the best reasoning model for planning, regardless of what
+    // the caller passed in. Falls back to caller's values if tiering has nothing.
+    {
+        const tiered = (0, router_1.getModelForTask)('planner');
+        if (tiered.apiKey || tiered.providerName === 'ollama') {
+            apiKey = tiered.apiKey;
+            model = tiered.model;
+            provider = tiered.providerName;
+            console.log(`[Planner] Sprint 6 tiering: using ${tiered.apiName} (${provider}/${model})`);
+        }
+        else if (!apiKey) {
+            // Caller had nothing either — last resort Ollama
+            const cfg = (0, index_1.loadConfig)();
+            apiKey = '';
+            model = cfg.model?.activeModel || 'mistral:7b';
+            provider = 'ollama';
+        }
+    }
+    let curApiKey = apiKey;
+    let curModel = model;
+    let curProvider = provider;
+    let curApiName = provider; // tracks the api entry name (e.g. 'groq-1') for markRateLimited
+    {
+        const tiered = (0, router_1.getModelForTask)('planner');
+        if (tiered.apiKey || tiered.providerName === 'ollama') {
+            curApiName = tiered.apiName;
+        }
+    }
+    let raw = '';
+    let parsed = null;
+    // Cap at 3 cloud attempts — getModelForTask() handles provider rotation automatically
+    // (marks failures → skips rate-limited → picks next tier). Walking all 12+ providers
+    // serially at 5s each caused 60-120s cascade when most were rate-limited.
+    // If all 3 fail, the Ollama fallback below catches it.
+    const _cfg = (0, index_1.loadConfig)();
+    const _customAsApi = (_cfg.customProviders ?? [])
+        .filter((cp) => cp.enabled)
+        .map((cp) => ({ ...cp, provider: 'custom', key: cp.apiKey, rateLimited: false, tier: cp.tier ?? 99 }));
+    const _plannerChain = [
+        ..._cfg.providers.apis.filter((a) => a.enabled && a.provider !== 'ollama'),
+        ..._customAsApi,
+    ].sort((a, b) => (a.tier ?? 99) - (b.tier ?? 99));
+    const _availableCount = _plannerChain.filter((a) => !a.rateLimited).length;
+    const maxPlannerAttempts = _availableCount === 0 ? 0 : Math.min(3, _availableCount);
+    for (let attempt = 0; attempt < maxPlannerAttempts; attempt++) {
+        raw = ''; // reset each attempt so stale values don't bleed through
+        try {
+            // Sprint 5: on first attempt, race top-2 providers simultaneously
+            if (attempt === 0) {
+                const promptText = messages.map(m => `${m.role}: ${m.content}`).join('\n');
+                const raceRaw = await racePlannerAPIs(promptText).catch(() => null);
+                if (raceRaw && raceRaw.trim().length > 0) {
+                    raw = raceRaw;
+                    console.log('[Planner] Race winner resolved');
+                }
+            }
+            if (!raw) {
+                raw = await callLLM(messages.map(m => `${m.role}: ${m.content}`).join('\n'), curApiKey, curModel, curProvider);
+            }
+            if (!raw || raw.trim().length === 0) {
+                console.warn(`[Planner] Empty response attempt ${attempt + 1} (${curApiName}) — marking and rotating`);
+                try {
+                    (0, router_1.markRateLimited)(curApiName);
+                }
+                catch { }
+            }
+            else {
+                const jsonMatch = raw.replace(/```json\s*/g, '').replace(/```\s*/g, '').match(/\{[\s\S]*\}/);
+                if (!jsonMatch) {
+                    // Phase 1 — repair: try to salvage plain-text / fenced responses before retrying
+                    const repair = (0, planResponseRepair_1.repairPlanResponse)(raw);
+                    if (repair.plan) {
+                        console.log(`[Planner] Repaired non-JSON response — treating as ${repair.directAnswer ? 'direct answer' : 'recovered plan'}`);
+                        parsed = repair.plan;
+                        try {
+                            (0, router_1.incrementUsage)(curApiName);
+                        }
+                        catch { }
+                        break;
+                    }
+                    console.warn(`[Planner] No JSON attempt ${attempt + 1}: ${raw.slice(0, 100)}`);
+                }
+                else {
+                    parsed = JSON.parse(jsonMatch[0]);
+                    try {
+                        (0, router_1.incrementUsage)(curApiName);
+                    }
+                    catch { }
+                    try {
+                        if (curApiName !== 'ollama')
+                            (0, router_1.markHealthy)(curApiName);
+                    }
+                    catch { }
+                    break; // success — exit retry loop
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`[Planner] Attempt ${attempt + 1} error (${curApiName}): ${e.message}`);
+            if (e.message?.includes('timeout') ||
+                e.message?.includes('429') ||
+                e.message?.includes('rate') ||
+                e.message?.includes('aborted')) {
+                try {
+                    (0, router_1.markRateLimited)(curApiName);
+                    console.log(`[Planner] Marked ${curApiName} as rate limited — will rotate away`);
+                }
+                catch { }
+            }
+        }
+        // Wait before next attempt — helps with rate-limit recovery
+        await new Promise(r => setTimeout(r, 1000));
+        // Rotate to next best planner provider for this attempt
+        try {
+            const tiered = (0, router_1.getModelForTask)('planner');
+            if (tiered.apiKey || tiered.providerName === 'ollama') {
+                curApiKey = tiered.apiKey;
+                curModel = tiered.model;
+                curProvider = tiered.providerName;
+                curApiName = tiered.apiName;
+                console.log(`[Planner] Rotating (tiered) to ${tiered.apiName} (${curProvider}/${curModel})`);
+            }
+            else {
+                const cfg = (0, index_1.loadConfig)();
+                curApiKey = '';
+                curModel = cfg.model?.activeModel || 'mistral:7b';
+                curProvider = 'ollama';
+                curApiName = 'ollama';
+                console.log(`[Planner] No cloud APIs — falling back to Ollama (${curModel})`);
+            }
+        }
+        catch { }
+    }
+    if (!parsed) {
+        // Final guaranteed attempt with Ollama before giving up
+        // Discover which model is actually installed via api/tags
+        try {
+            const cfg = (0, index_1.loadConfig)();
+            let ollamaModel = process.env.OLLAMA_MODEL || cfg.ollama?.model || 'gemma4:e4b';
+            try {
+                const _ollamaBase = (process.env.OLLAMA_HOST ?? 'http://127.0.0.1:11434').replace(/\/$/, '');
+                const tagsRes = await fetch(`${_ollamaBase}/api/tags`, { signal: AbortSignal.timeout(3000) });
+                if (tagsRes.ok) {
+                    const tagsData = await tagsRes.json();
+                    const firstModel = tagsData?.models?.[0]?.name;
+                    if (firstModel) {
+                        ollamaModel = firstModel;
+                        console.log(`[Planner] Ollama model discovered via api/tags: ${ollamaModel}`);
+                    }
+                }
+            }
+            catch { /* Ollama not running — use config model */ }
+            console.log(`[Planner] All cloud attempts failed — final Ollama attempt (${ollamaModel})`);
+            const raw = await callLLM(messages.map(m => `${m.role}: ${m.content}`).join('\n'), '', ollamaModel, 'ollama');
+            if (raw && raw.trim().length > 0) {
+                const jsonMatch = raw.replace(/```json\s*/g, '').replace(/```\s*/g, '').match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    parsed = JSON.parse(jsonMatch[0]);
+                    console.log('[Planner] Ollama fallback succeeded');
+                }
+                else {
+                    // Repair fallback — Ollama often returns plain text for trivial questions
+                    const repair = (0, planResponseRepair_1.repairPlanResponse)(raw);
+                    if (repair.plan) {
+                        parsed = repair.plan;
+                        console.log(`[Planner] Ollama fallback repaired — ${repair.directAnswer ? 'direct answer' : 'recovered plan'}`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`[Planner] Ollama fallback failed: ${e.message}`);
+        }
+    }
+    if (!parsed) {
+        // Keyword-based plan generation — when all LLMs fail, infer tool from message
+        const heuristicPlan = inferPlanFromKeywords(message);
+        if (heuristicPlan) {
+            console.log(`[Planner] Keyword-based plan: ${JSON.stringify(heuristicPlan.plan.map(s => s.tool))}`);
+            parsed = heuristicPlan;
+        }
+    }
+    if (!parsed) {
+        console.warn('[Planner] All LLM attempts failed — respond fallback');
+        return {
+            goal: message,
+            requires_execution: true,
+            plan: [{ step: 1, tool: 'respond', input: { message: "I'm not sure how to help with that right now. Could you rephrase your request?" }, description: 'Fallback response' }],
+            phases: [],
+        };
+    }
+    // Guard against null/empty plan object
+    if (!parsed.plan && !parsed.steps) {
+        return {
+            goal: message,
+            requires_execution: false,
+            plan: [],
+            phases: [],
+            direct_response: parsed.direct_response || "I'll answer directly.",
+        };
+    }
+    // Validate tool names — reject hallucinated tools
+    const rawPlan = (parsed.plan || parsed.steps || []);
+    const validatedPlan = rawPlan.filter((s) => {
+        if (!allTools.includes(s.tool)) {
+            console.warn(`[Planner] Rejected invalid tool: ${s.tool}`);
+            return false;
+        }
+        // Reject old-style placeholder inputs
+        const inputStr = JSON.stringify(s.input || s.args || {});
+        if (inputStr.includes('{{') || inputStr.includes('{result') || inputStr.includes('{output')) {
+            console.warn(`[Planner] Rejected placeholder input in: ${s.tool}`);
+            return false;
+        }
+        return true;
+    });
+    const normalizedPlan = validatedPlan.map((s, idx) => ({
+        step: s.step ?? (idx + 1),
+        tool: s.tool || '',
+        input: s.input || s.args || {},
+        description: s.description || '',
+    }));
+    // Fix step ordering — research before write
+    const orderedPlan = fixStepOrdering(normalizedPlan);
+    // Create phased task plan and workspace
+    const phases = inferPhasesFromSteps(orderedPlan);
+    const taskPlan = planTool_1.planTool.create(message, phases);
+    const workspace = new workspaceMemory_1.WorkspaceMemory(taskPlan.id);
+    workspace.write('goal.txt', message);
+    const candidatePlan = {
+        goal: parsed.goal || message,
+        requires_execution: parsed.requires_execution === true && orderedPlan.length > 0,
+        plan: orderedPlan,
+        direct_response: parsed.direct_response,
+        planId: taskPlan.id,
+        workspaceDir: taskPlan.workspaceDir,
+        phases: taskPlan.phases,
+    };
+    // Validate before returning — log warnings, strip hard-invalid steps
+    const validation = validatePlan(candidatePlan);
+    if (validation.warnings.length > 0) {
+        console.warn(`[Planner] Validation warnings:\n  ${validation.warnings.join('\n  ')}`);
+        // Carry repair log onto the plan so SSE clients can show ↺ repair events
+        const repairWarnings = validation.warnings.filter(w => w.includes('auto-repaired'));
+        if (repairWarnings.length > 0)
+            candidatePlan.repairLog = repairWarnings;
+    }
+    if (!validation.valid) {
+        console.warn(`[Planner] Plan has validation errors:\n  ${validation.errors.join('\n  ')}`);
+        // One retry — ask the LLM to fix the plan
+        console.log('[Planner] Retrying with validation errors injected into prompt...');
+        const retryMessages = [
+            ...messages,
+            {
+                role: 'assistant',
+                content: raw.slice(0, 500),
+            },
+            {
+                role: 'user',
+                content: `The plan you produced has errors:\n${validation.errors.join('\n')}\n\nFix these issues and output a corrected JSON plan.`,
+            },
+        ];
+        try {
+            const retryRaw = await callLLM(retryMessages.map(m => `${m.role}: ${m.content}`).join('\n'), curApiKey, curModel, curProvider);
+            const retryMatch = retryRaw.replace(/```json\s*/g, '').replace(/```\s*/g, '').match(/\{[\s\S]*\}/);
+            if (retryMatch) {
+                const retryParsed = JSON.parse(retryMatch[0]);
+                const retryRaw2 = (retryParsed.plan || retryParsed.steps || []);
+                const retryValid = retryRaw2.filter((s) => allTools.includes(s.tool));
+                const retryNorm = retryValid.map((s, idx) => ({
+                    step: s.step ?? (idx + 1),
+                    tool: s.tool || '',
+                    input: s.input || s.args || {},
+                    description: s.description || '',
+                }));
+                const retryOrdered = fixStepOrdering(retryNorm);
+                if (retryOrdered.length > 0) {
+                    candidatePlan.plan = retryOrdered;
+                    console.log(`[Planner] Retry succeeded: ${retryOrdered.length} valid steps`);
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`[Planner] Retry failed: ${e.message}`);
+        }
+    }
+    return candidatePlan;
+}
+// ── Plan validation ────────────────────────────────────────────
+// Called after planWithLLM — rejects structurally bad plans before execution.
+const VALID_TOOLS = [
+    'web_search', 'fetch_page', 'fetch_url', 'open_browser', 'browser_extract',
+    'browser_click', 'browser_type', 'browser_screenshot', 'browser_scroll', 'browser_get_url',
+    'file_write', 'file_read',
+    'file_list', 'shell_exec', 'run_python', 'run_node', 'run_powershell',
+    'system_info', 'notify', 'deep_research', 'get_stocks', 'run_agent', 'git_commit',
+    'git_push', 'get_market_data', 'get_company_info',
+    'mouse_move', 'mouse_click', 'keyboard_type', 'keyboard_press',
+    'screenshot', 'screen_read', 'vision_loop', 'wait',
+    'code_interpreter_python', 'code_interpreter_node',
+    'clipboard_read', 'clipboard_write', 'window_list', 'window_focus',
+    'app_launch', 'app_close',
+    'watch_folder', 'watch_folder_list',
+    'send_file_local', 'receive_file_local',
+    'clarify', 'todo', 'cronjob', 'vision_analyze',
+    'voice_speak', 'voice_transcribe', 'voice_clone', 'voice_design',
+    'lookup_skill', 'lookup_tool_schema',
+    'spawn', 'spawn_subagent', 'swarm',
+    ...slashAsTool_1.SLASH_MIRROR_TOOL_NAMES,
+];
+function validatePlan(plan) {
+    const errors = [];
+    const warnings = [];
+    if (!plan.requires_execution || plan.plan.length === 0) {
+        return { valid: true, errors, warnings };
+    }
+    for (const step of plan.plan) {
+        // Check tool name — attempt fuzzy repair before flagging as error
+        if (!VALID_TOOLS.includes(step.tool)) {
+            const repair = (0, toolNameRepair_1.repairToolName)(step.tool, VALID_TOOLS);
+            if (repair) {
+                warnings.push(`Step ${step.step}: auto-repaired tool "${repair.original}" → "${repair.repaired}" (edit distance ${repair.distance})`);
+                console.log(`[ToolRepair] ↺ "${repair.original}" → "${repair.repaired}" (distance ${repair.distance})`);
+                step.tool = repair.repaired; // mutate in-place — plan will execute with correct name
+            }
+            else {
+                errors.push(`Step ${step.step}: unknown tool "${step.tool}"`);
+                continue;
+            }
+        }
+        const input = step.input || {};
+        // Tool-specific required field checks
+        switch (step.tool) {
+            case 'web_search':
+                if (!input.query && !input.topic && !input.command) {
+                    errors.push(`Step ${step.step}: web_search requires a "query" field`);
+                }
+                break;
+            case 'deep_research':
+                if (!input.topic && !input.query && !input.command) {
+                    errors.push(`Step ${step.step}: deep_research requires a "topic" field`);
+                }
+                break;
+            case 'file_write':
+                if (!input.path && !input.file) {
+                    errors.push(`Step ${step.step}: file_write requires a "path" field`);
+                }
+                if (input.content === undefined && input.content !== '') {
+                    warnings.push(`Step ${step.step}: file_write has no "content" — will write empty file`);
+                }
+                break;
+            case 'file_read':
+                if (!input.path && !input.file) {
+                    errors.push(`Step ${step.step}: file_read requires a "path" field`);
+                }
+                break;
+            case 'open_browser':
+                if (!input.url && !input.command) {
+                    errors.push(`Step ${step.step}: open_browser requires a "url" field`);
+                }
+                break;
+            case 'shell_exec':
+                if (!input.command && !input.cmd) {
+                    errors.push(`Step ${step.step}: shell_exec requires a "command" field`);
+                }
+                break;
+            case 'run_python':
+            case 'run_node':
+                if (!input.script && !input.code && !input.command) {
+                    errors.push(`Step ${step.step}: ${step.tool} requires a "script" field`);
+                }
+                break;
+            case 'fetch_page':
+            case 'fetch_url':
+                if (!input.url && !input.command) {
+                    errors.push(`Step ${step.step}: ${step.tool} requires a "url" field`);
+                }
+                break;
+            case 'vision_loop':
+                if (!input.goal) {
+                    errors.push(`Step ${step.step}: vision_loop requires a "goal" field`);
+                }
+                break;
+            case 'wait':
+                if (!input.ms && input.ms !== 0) {
+                    warnings.push(`Step ${step.step}: wait has no "ms" — will default to 1000ms`);
+                }
+                break;
+        }
+        // Reject residual placeholder patterns that were not caught by planner
+        const inputStr = JSON.stringify(input);
+        if (/\{\{|\{result|\{output|\bPREVIOUS_OUTPUT\b/.test(inputStr) && step.tool !== 'file_write') {
+            if (step.step === 1) {
+                warnings.push(`Step 1: PREVIOUS_OUTPUT is invalid for the first step (no prior output). Provide a literal input.`);
+            }
+            else {
+                warnings.push(`Step ${step.step}: input contains placeholder — may fail at runtime`);
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+// ── Smart replan on failure ────────────────────────────────────
+const MAX_REPLANS = 2;
+async function handleToolFailure(replanState, failedTool, error, userMessage, completedResults, apiKey, model, provider) {
+    const existing = replanState.failedSteps.get(failedTool);
+    if (existing) {
+        existing.attempts++;
+        existing.error = error;
+    }
+    else {
+        replanState.failedSteps.set(failedTool, { error, attempts: 1 });
+    }
+    if (replanState.replanCount >= MAX_REPLANS) {
+        console.log('[Replan] Max replans reached — reporting failure');
+        return null;
+    }
+    replanState.replanCount++;
+    const succeeded = completedResults.filter(r => r.success);
+    const failed = Array.from(replanState.failedSteps.entries());
+    console.log(`[Replan] Replanning (${replanState.replanCount}/${MAX_REPLANS}) after ${failedTool} failed: ${error.slice(0, 80)}`);
+    const replanContext = `Previous approach failed. Use a DIFFERENT strategy.\n\n` +
+        `Original request: ${userMessage}\n\n` +
+        `Already completed:\n` +
+        (succeeded.map(s => `✅ ${s.tool}: ${s.output.substring(0, 100)}`).join('\n') || 'Nothing yet') +
+        `\n\nWhat failed:\n` +
+        failed.map(([tool, f]) => `❌ ${tool}: ${f.error} (tried ${f.attempts}x)`).join('\n') +
+        `\n\nRULES:\n` +
+        `- Do NOT retry ${failedTool} with same approach\n` +
+        `- Use a completely different tool or strategy\n` +
+        `- Build on completed steps — don't redo them\n` +
+        `- If API failed, try different data source\n` +
+        `- If browser failed on a site, try fetch_url instead`;
+    try {
+        const newPlan = await planWithLLM(replanContext, [], apiKey, model, provider);
+        if (newPlan?.plan?.length > 0) {
+            console.log(`[Replan] New plan: ${newPlan.plan.map(s => s.tool).join(' → ')}`);
+            return newPlan.plan;
+        }
+    }
+    catch (e) {
+        console.warn(`[Replan] planWithLLM failed: ${e.message}`);
+    }
+    return null;
+}
+// ── Sprint 28: shouldReplan ────────────────────────────────────
+// After each failed step, ask the LLM: should we replan?
+async function shouldReplan(originalGoal, completedSteps, failedStep, failureReason, apiKey, model, provider) {
+    const prompt = `You are replanning a failed task.
+
+Original goal: "${originalGoal}"
+
+Steps completed so far:
+${completedSteps.map((s, i) => `${i + 1}. ${s.tool}: ${s.success ? 'succeeded' : 'failed'}`).join('\n') || 'None'}
+
+Failed step: ${failedStep.tool}
+Failure reason: ${failureReason}
+
+Should I replan with a different approach, or retry the same step?
+
+Respond in JSON only:
+{
+  "replan": true/false,
+  "reason": "why",
+  "newApproach": "describe the new approach if replanning, or null"
+}`;
+    try {
+        const raw = await callLLM(prompt, apiKey, model, provider);
+        const match = raw.match(/\{[\s\S]*\}/);
+        const parsed = JSON.parse(match?.[0] || '{}');
+        return { replan: parsed.replan === true, newApproach: parsed.newApproach || undefined };
+    }
+    catch {
+        return { replan: false };
+    }
+}
+// ── STEP 2: executePlan ────────────────────────────────────────
+// ── validateResultQuality — lightweight output sanity check ──
+function validateResultQuality(tool, input, output) {
+    if (tool === 'web_search') {
+        if (!output || output === '[]' || output === 'No results') {
+            return { valid: false, reason: 'Empty search results' };
+        }
+        try {
+            const results = typeof output === 'string' ? JSON.parse(output) : output;
+            if (Array.isArray(results) && results.length === 0) {
+                return { valid: false, reason: 'Zero search results' };
+            }
+        }
+        catch { }
+    }
+    if (tool === 'fetch_url' || tool === 'fetch_page') {
+        const text = String(output).toLowerCase();
+        if (text.includes('404') && text.includes('not found')) {
+            return { valid: false, reason: '404 page returned' };
+        }
+        if (text.includes('403') && text.includes('forbidden')) {
+            return { valid: false, reason: '403 forbidden' };
+        }
+        if (text.length < 50) {
+            return { valid: false, reason: 'Suspiciously short page content' };
+        }
+    }
+    if (tool === 'get_market_data') {
+        const text = String(output);
+        if (text.includes('error') || text.includes('failed') || text.includes('null')) {
+            return { valid: false, reason: 'Market data returned error' };
+        }
+    }
+    if (tool === 'file_read') {
+        if (!output || String(output).trim().length === 0) {
+            return { valid: false, reason: 'Empty file content' };
+        }
+    }
+    if (tool === 'run_python' || tool === 'run_node' || tool === 'shell_exec') {
+        const text = String(output).toLowerCase();
+        if (text.includes('traceback') || text.includes('error:') ||
+            text.includes('exception') || text.includes('syntaxerror')) {
+            return { valid: false, reason: 'Code execution error in output' };
+        }
+    }
+    if (tool === 'open_browser') {
+        const text = String(output).toLowerCase();
+        if (text.includes('err_') || text.includes('timed out') ||
+            text.includes('cannot navigate')) {
+            return { valid: false, reason: 'Browser navigation failed' };
+        }
+    }
+    return { valid: true };
+}
+// ── LESSONS.md — permanent failure rules ──────────────────────
+// Auto-appended on task failure. Injected into every planning session.
+const LESSONS_PATH = nodePath.join(process.cwd(), 'workspace', 'LESSONS.md');
+const LESSONS_CAP = 50;
+const LESSONS_SUMMARIZE_AT = 25; // when cap exceeded, summarize oldest N lessons
+function loadLessons() {
+    try {
+        if (!nodeFs.existsSync(LESSONS_PATH))
+            return '';
+        return nodeFs.readFileSync(LESSONS_PATH, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function appendLesson(lesson) {
+    try {
+        nodeFs.mkdirSync(nodePath.dirname(LESSONS_PATH), { recursive: true });
+        const today = new Date().toISOString().split('T')[0];
+        const newLine = `\n${lesson.startsWith('[') ? lesson : `[${today}] ${lesson}`}`;
+        let content = nodeFs.existsSync(LESSONS_PATH)
+            ? nodeFs.readFileSync(LESSONS_PATH, 'utf-8')
+            : '# LESSONS.md — Permanent Failure Rules\n\n## Rules\n';
+        // Count existing lesson lines (numbered lines in ## Rules section)
+        const lessonLines = content
+            .split('\n')
+            .filter(l => /^\d+\./.test(l.trim()));
+        if (lessonLines.length >= LESSONS_CAP) {
+            // Summarize oldest LESSONS_SUMMARIZE_AT lessons into 5 consolidated rules
+            console.log(`[Lessons] Cap reached (${lessonLines.length}). Summarizing oldest ${LESSONS_SUMMARIZE_AT} lessons.`);
+            const oldest = lessonLines.slice(0, LESSONS_SUMMARIZE_AT);
+            const remaining = lessonLines.slice(LESSONS_SUMMARIZE_AT);
+            const summarized = [
+                `[consolidated] Avoid retrying tools that fail with permission or auth errors — report immediately.`,
+                `[consolidated] When web_search returns empty, rephrase with different keywords before retrying.`,
+                `[consolidated] Do not use error-string outputs as valid data — fall back to alternative tools.`,
+                `[consolidated] When replan is triggered repeatedly for the same goal, stop and report.`,
+                `[consolidated] Browser navigation failures (ERR_/timeout) require a fresh approach, not a retry.`,
+            ];
+            const headerLines = content.split('\n').filter(l => !(/^\d+\./.test(l.trim())));
+            const newRules = [...summarized, ...remaining, lesson.startsWith('[') ? lesson : `[${today}] ${lesson}`];
+            const numbered = newRules.map((r, i) => `${i + 1}. ${r.replace(/^\d+\.\s*/, '')}`);
+            const headerText = headerLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+            content = `${headerText}\n\n${numbered.join('\n')}\n`;
+            console.log(`[Lessons] Summarized ${oldest.length} old lessons → 5 rules. Total: ${numbered.length}`);
+        }
+        else {
+            const nextNum = lessonLines.length + 1;
+            content = content.trimEnd() + `\n${nextNum}.${newLine}\n`;
+        }
+        nodeFs.writeFileSync(LESSONS_PATH, content, 'utf-8');
+        console.log(`[Lessons] Appended: ${lesson.slice(0, 80)}`);
+    }
+    catch (e) {
+        console.error('[Lessons] Failed to append lesson:', e.message);
+    }
+}
+// ── executeToolWithRetry — step-level retry with exponential backoff ──
+// Tools that mutate state are excluded from retry to prevent double-execution.
+const NO_RETRY_TOOLS = new Set([
+    'shell_exec', 'run_python', 'run_node', 'notify',
+    'mouse_click', 'keyboard_type', 'keyboard_press',
+    'app_launch', 'app_close',
+    'open_browser', 'browser_extract', 'browser_screenshot', 'browser_click', 'browser_type', 'browser_scroll', 'browser_get_url',
+]);
+async function executeToolWithRetry(tool, input, maxRetries = 2) {
+    const retryable = !NO_RETRY_TOOLS.has(tool);
+    const effectiveMax = retryable ? maxRetries : 0;
+    for (let attempt = 0; attempt <= effectiveMax; attempt++) {
+        try {
+            const result = await (0, toolRegistry_1.executeTool)(tool, input);
+            if (result.success) {
+                const quality = validateResultQuality(tool, input, result.output || result);
+                if (!quality.valid) {
+                    console.log(`[Quality] ${tool} returned but quality check failed: ${quality.reason}`);
+                    if (attempt < effectiveMax) {
+                        const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                        console.log(`[Quality] Retrying ${tool} in ${delay}ms`);
+                        await new Promise(r => setTimeout(r, delay));
+                        continue;
+                    }
+                    console.log(`[Quality] ${tool} — accepting low-quality result after ${effectiveMax} retries`);
+                    appendLesson(`${tool} produced low-quality output (${quality.reason}) after ${effectiveMax} retries — consider alternative approach for this tool.`);
+                }
+                return result;
+            }
+            if (attempt < effectiveMax) {
+                const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                console.log(`[Exec] ${tool} failed, retrying in ${delay}ms (attempt ${attempt + 1}/${effectiveMax})`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+            else {
+                return result;
+            }
+        }
+        catch (error) {
+            if (attempt >= effectiveMax)
+                throw error;
+            const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+            console.log(`[Exec] ${tool} threw error, retrying in ${delay}ms`);
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+    appendLesson(`${tool} failed after ${effectiveMax} retries — avoid this tool or approach for similar tasks.`);
+    return { success: false, output: '', error: 'Max retries exceeded', duration: 0, retries: effectiveMax };
+}
+// —— Sprint 8: dependency-group builder ——————————————
+// Groups consecutive tool steps into batches: parallel-safe tools are
+// batched together; sequential tools break the batch.
+const PARALLEL_SAFE = new Set([
+    'web_search', 'system_info', 'get_stocks', 'get_market_data',
+    'social_research', 'fetch_url', 'fetch_page', 'get_company_info',
+    'deep_research', 'code_interpreter_python', 'code_interpreter_node',
+    'clipboard_read', 'window_list', 'watch_folder_list',
+    'get_calendar', 'read_email', 'get_natural_events', 'ingest_youtube',
+]);
+const SEQUENTIAL_ONLY = new Set([
+    'file_write', 'run_python', 'run_node', 'shell_exec',
+    'open_browser', 'browser_click', 'browser_type', 'browser_extract',
+    'mouse_move', 'mouse_click', 'keyboard_type', 'keyboard_press',
+    'screenshot', 'screen_read', 'vision_loop', 'notify', 'wait',
+    'clipboard_write', 'window_focus', 'app_launch', 'app_close',
+    'watch_folder',
+]);
+function buildDependencyGroups(steps) {
+    const groups = [];
+    let currentGroup = [];
+    for (const step of steps) {
+        const inputStr = JSON.stringify(step.input || {});
+        const dependsOnPrevious = inputStr.includes('PREVIOUS_OUTPUT') || SEQUENTIAL_ONLY.has(step.tool);
+        if (PARALLEL_SAFE.has(step.tool) && !dependsOnPrevious) {
+            currentGroup.push(step);
+        }
+        else {
+            if (currentGroup.length > 0) {
+                groups.push([...currentGroup]);
+                currentGroup = [];
+            }
+            groups.push([step]);
+        }
+    }
+    if (currentGroup.length > 0)
+        groups.push(currentGroup);
+    return groups;
+}
+async function executePlan(plan, onStep, onPhaseChange, existingState, replanApiKey, replanModel, replanProvider) {
+    executionInterrupted = false; // reset on each new plan execution
+    // ── Iteration budget ─────────────────────────────────────────
+    const budget = {
+        maxIterations: Math.max(plan.plan.length + 5, 15),
+        currentIteration: 0,
+        cautionThreshold: 0.7,
+        warningThreshold: 0.9,
+    };
+    _activeBudget = budget;
+    const results = [];
+    const stepOutputs = {};
+    const planStart = Date.now();
+    const replanState = { failedSteps: new Map(), replanCount: 0 };
+    console.log(`[ExecutePlan] Starting: ${plan.plan.length} steps, goal: "${plan.goal.slice(0, 60)}"`);
+    // Workflow tracking — feed the Watch Mode node graph
+    (0, workflowTracker_1.startWorkflow)(plan.goal);
+    (0, workflowTracker_1.addNode)({ id: 'main', agent: 'aiden', label: plan.goal.slice(0, 50), status: 'active', toolCalls: 0, startedAt: Date.now() });
+    // Workspace memory for persisting intermediate artifacts
+    const workspace = plan.planId ? new workspaceMemory_1.WorkspaceMemory(plan.planId) : null;
+    // Initialize or reuse persistent task state (enables crash recovery)
+    const taskId = plan.planId || `task_${Date.now()}`;
+    const state = existingState || taskState_1.taskStateManager.create(taskId, plan.goal, plan.plan.length, plan.planId);
+    // Restore step outputs from already-completed steps so PREVIOUS_OUTPUT works on resume
+    for (const savedStep of state.steps) {
+        if (savedStep.status === 'completed' && savedStep.output) {
+            stepOutputs[savedStep.index] = savedStep.output;
+        }
+    }
+    // Maps each tool to its capability bucket (for phase transition detection)
+    const capabilityMap = {
+        web_search: 'research', fetch_page: 'research',
+        deep_research: 'research', fetch_url: 'research',
+        get_stocks: 'research',
+        open_browser: 'browsing', browser_click: 'browsing',
+        browser_extract: 'browsing', browser_type: 'browsing',
+        mouse_move: 'browsing', mouse_click: 'browsing',
+        keyboard_type: 'browsing', keyboard_press: 'browsing',
+        screenshot: 'browsing', screen_read: 'browsing',
+        vision_loop: 'browsing',
+        file_write: 'writing', file_read: 'reading',
+        file_list: 'reading', shell_exec: 'execution',
+        run_python: 'execution', run_node: 'execution',
+        system_info: 'execution', notify: 'execution',
+        clipboard_read: 'execution', clipboard_write: 'execution',
+        window_list: 'execution', window_focus: 'execution',
+        app_launch: 'execution', app_close: 'execution',
+        watch_folder: 'execution', watch_folder_list: 'execution',
+    };
+    let lastCapability = '';
+    let currentPhaseIdx = 0;
+    const totalPhases = plan.phases?.length || 1;
+    // —— Sprint 8: single-step executor ————————————————————
+    // Called by executePlan for both sequential (group.length===1) and parallel paths.
+    async function executeSingleStep(step, stepOutputs, state, plan, workspace, onStep) {
+        // BUDGET CHECK
+        if (taskState_1.taskStateManager.isOverBudget(state)) {
+            const budgetMsg = `Token budget exceeded (${state.tokenUsage}/${state.tokenLimit}) — task stopped`;
+            console.warn(`[AgentLoop] ${budgetMsg}`);
+            taskState_1.taskStateManager.fail(state, budgetMsg);
+            return { step: step.step, tool: step.tool, input: step.input, success: false, output: '', error: budgetMsg, duration: 0 };
+        }
+        const totalSteps = plan.plan.length;
+        const stepStart = Date.now();
+        console.log(`[Exec] Step ${step.step}/${totalSteps}: ${step.tool} — RUNNING`);
+        console.log(`[ExecutePlan] Step ${step.step}: ${step.tool} — input: ${JSON.stringify(step.input).slice(0, 100)}`);
+        livePulse_1.livePulse.tool('Aiden', step.tool, JSON.stringify(step.input).slice(0, 80));
+        // Validate tool exists
+        if (!toolRegistry_1.TOOLS[step.tool]) {
+            const stepResult = {
+                step: step.step, tool: step.tool, input: step.input,
+                success: false, output: '',
+                error: `Tool "${step.tool}" does not exist. Available: ${Object.keys(toolRegistry_1.TOOLS).slice(0, 8).join(', ')}`,
+                duration: 0,
+            };
+            onStep(step, stepResult);
+            livePulse_1.livePulse.error('Aiden', `Invalid tool: ${step.tool}`);
+            return stepResult;
+        }
+        // Tools that legitimately take zero input
+        const NO_INPUT_TOOLS = ['system_info', 'screenshot', 'get_hardware', 'screen_read', 'vision_loop', 'health_check', 'respond'];
+        if (!NO_INPUT_TOOLS.includes(step.tool)) {
+            if (!step.input || Object.keys(step.input).length === 0) {
+                console.log(`[ExecutePlan] Skipping step ${step.step} (${step.tool}) — empty input`);
+                return { step: step.step, tool: step.tool, input: step.input, success: false, output: '', error: 'empty input', duration: 0 };
+            }
+        }
+        // Resolve PREVIOUS_OUTPUT and {{step_N_output}} tokens
+        let resolvedInput = resolvePreviousOutput(step.input, stepOutputs, step.step);
+        // Mark step started in persistent state
+        taskState_1.taskStateManager.startStep(state, step.step, step.tool, resolvedInput);
+        // Emit status before tool execution
+        emitStatus(TOOL_ACTION[step.tool] ?? 'tooling', toolStatusDetail(step.tool, resolvedInput));
+        // Execute the tool (step-level retry + per-tool timeout)
+        let toolResult = await executeToolWithRetry(step.tool, resolvedInput);
+        // file_write fallback — retry at Desktop if original path failed
+        if (!toolResult.success && step.tool === 'file_write' && resolvedInput.path) {
+            const desktopPath = nodePath.join(nodeOs.homedir(), 'Desktop', nodePath.basename(resolvedInput.path));
+            if (desktopPath !== resolvedInput.path) {
+                livePulse_1.livePulse.error('Aiden', `file_write failed — retrying at Desktop: ${desktopPath}`);
+                const fallback = await (0, toolRegistry_1.executeTool)('file_write', { ...resolvedInput, path: desktopPath });
+                if (fallback.success) {
+                    toolResult = { ...fallback, output: fallback.output + ' (saved to Desktop)' };
+                    resolvedInput = { ...resolvedInput, path: desktopPath };
+                }
+            }
+        }
+        if (toolResult.retries > 0) {
+            livePulse_1.livePulse.act('Aiden', `${step.tool} succeeded after ${toolResult.retries} retry(s)`);
+        }
+        let stepResult = {
+            step: step.step, tool: step.tool, input: resolvedInput,
+            success: toolResult.success,
+            output: toolResult.output || '',
+            error: toolResult.error,
+            duration: toolResult.duration,
+        };
+        // Persist significant outputs to workspace
+        if (toolResult.success && workspace && toolResult.output.length > 300) {
+            workspace.write(`step_${step.step}_${step.tool}.txt`, toolResult.output);
+        }
+        // Verify file_write actually landed on disk
+        if (toolResult.success && step.tool === 'file_write') {
+            const targetPath = resolvedInput.path || '';
+            if (targetPath && !nodeFs.existsSync(targetPath)) {
+                stepResult.success = false;
+                stepResult.error = `Verification failed: file not found at ${targetPath}`;
+            }
+        }
+        const execStatus = stepResult.success ? 'SUCCESS' : 'FAILED';
+        const execDuration = Date.now() - stepStart;
+        console.log(`[Exec] Step ${step.step}/${totalSteps}: ${step.tool} — ${execStatus} (${execDuration}ms)`);
+        if (!stepResult.success) {
+            console.log(`[Exec] Step ${step.step}: ${step.tool} — FAILED after ${toolResult.retries ?? 0} retries: ${stepResult.error || 'unknown error'}`);
+        }
+        console.log(`[ExecutePlan] Step ${step.step} result: ${stepResult.success ? '✓' : '✗'} ${stepResult.error || stepResult.output?.slice(0, 80) || ''}`);
+        console.log(`[Tool] ${step.tool} (Tier ${(0, toolRegistry_1.getToolTier)(step.tool)}) — ${stepResult.duration}ms`);
+        stepOutputs[step.step] = stepResult.output;
+        (0, workflowTracker_1.updateNode)('main', { currentTool: step.tool, toolCalls: Object.keys(stepOutputs).length, tier: (0, toolRegistry_1.getToolTier)(step.tool), status: 'active' });
+        // Persist step to executions log for crash recovery / audit
+        try {
+            const execDir = nodePath.join(process.cwd(), 'workspace', 'executions');
+            nodeFs.mkdirSync(execDir, { recursive: true });
+            const execFile = nodePath.join(execDir, `exec_${state.id}.json`);
+            const existing = nodeFs.existsSync(execFile)
+                ? JSON.parse(nodeFs.readFileSync(execFile, 'utf8'))
+                : { id: `exec_${state.id}`, goal: plan.goal, steps: [], status: 'in_progress', startedAt: Date.now() };
+            existing.steps = existing.steps.filter((s) => s.step !== step.step);
+            existing.steps.push({
+                step: step.step,
+                tool: step.tool,
+                status: stepResult.success ? 'success' : 'failed',
+                duration: execDuration,
+                timestamp: new Date().toISOString(),
+                error: stepResult.error,
+            });
+            existing.totalDuration = Date.now() - (existing.startedAt || Date.now());
+            nodeFs.writeFileSync(execFile, JSON.stringify(existing, null, 2));
+        }
+        catch { /* non-blocking — never crash the agent loop */ }
+        onStep(step, stepResult);
+        // Audit trail
+        auditTrail_1.auditTrail.record({
+            action: 'tool',
+            tool: step.tool,
+            input: JSON.stringify(step.input).slice(0, 200),
+            output: stepResult.output?.slice(0, 200),
+            durationMs: stepResult.duration,
+            success: stepResult.success,
+            error: stepResult.error,
+            goal: plan.goal,
+            traceId: plan.planId,
+        });
+        // Fire after_tool_call hook (non-blocking) — feeds instinct system
+        (0, hooks_1.fireHook)('after_tool_call', {
+            toolName: step.tool,
+            input: resolvedInput,
+            success: stepResult.success,
+        }).catch(() => { });
+        // Persist step result to task state
+        if (stepResult.success) {
+            taskState_1.taskStateManager.completeStep(state, step.step, stepResult.output, stepResult.duration);
+            livePulse_1.livePulse.done('Aiden', `${step.tool} ✓ ${stepResult.output.slice(0, 60)}`);
+        }
+        else {
+            taskState_1.taskStateManager.failStep(state, step.step, stepResult.error || 'unknown error');
+            livePulse_1.livePulse.error('Aiden', `${step.tool} failed: ${stepResult.error}`);
+        }
+        return stepResult;
+    }
+    // —— Sprint 8: group-based dispatch (parallel where safe) ———————————
+    const groups = buildDependencyGroups(plan.plan);
+    console.log(`[ExecutePlan] Dependency groups: ${groups.map(g => g.length === 1 ? g[0].tool : `[${g.map(s => s.tool).join('+')}]`).join(' → ')}`);
+    if ((0, parallelExecutor_1.hasParallelism)(groups))
+        console.log(`[ExecutePlan] Parallel execution enabled — ${groups.filter(g => g.length > 1).length} concurrent batch(es) detected`);
+    let _gi = 0;
+    while (_gi < groups.length) {
+        const group = groups[_gi++];
+        // Phase-transition detection — use first step of each group
+        const thisCap = capabilityMap[group[0].tool] || 'execution';
+        if (thisCap !== lastCapability && lastCapability !== '') {
+            if (plan.planId) {
+                planTool_1.planTool.advancePhase(plan.planId, `Completed ${lastCapability}`);
+                currentPhaseIdx++;
+                const nextPhase = planTool_1.planTool.getCurrentPhase(plan.planId);
+                if (nextPhase && onPhaseChange) {
+                    onPhaseChange(nextPhase, currentPhaseIdx, totalPhases);
+                }
+            }
+        }
+        lastCapability = thisCap;
+        // Skip already-completed steps (crash recovery idempotency)
+        const unskipped = group.filter(s => !taskState_1.taskStateManager.isStepCompleted(state, s.step));
+        for (const s of group) {
+            if (taskState_1.taskStateManager.isStepCompleted(state, s.step)) {
+                console.log(`[AgentLoop] Step ${s.step} (${s.tool}) already completed — skipping`);
+                const savedStep = state.steps.find(ss => ss.index === s.step);
+                if (savedStep?.output)
+                    stepOutputs[s.step] = savedStep.output;
+            }
+        }
+        if (unskipped.length === 0)
+            continue;
+        if (unskipped.length === 1) {
+            // —— Sequential single step ————————————————
+            const step = unskipped[0];
+            // ── Budget: increment before execution ────────────────────────
+            budget.currentIteration++;
+            if (budget.currentIteration >= budget.maxIterations) {
+                console.log('[Budget] Exhausted — forcing final response');
+                const summary = results.filter(s => s.success)
+                    .map(s => `✓ ${s.tool}: ${String(s.output).substring(0, 100)}`).join('\n');
+                results.push({
+                    step: step.step, tool: 'budget_exhausted', input: {},
+                    success: false, output: `I've reached my iteration limit. Here's what I completed:\n\n${summary}\n\nLet me know if you need me to continue.`,
+                    error: 'iteration budget exhausted', duration: 0,
+                });
+                break;
+            }
+            const stepResult = await executeSingleStep(step, stepOutputs, state, plan, workspace, onStep);
+            stepOutputs[step.step] = stepResult.output;
+            // ── Budget: append pressure warning to result output ──────────
+            const budgetWarning = getBudgetWarning(budget);
+            if (budgetWarning) {
+                stepResult.output = stepResult.output + '\n\n' + budgetWarning;
+            }
+            results.push(stepResult);
+            // ── Interrupt check ────────────────────────────────────────────
+            if (executionInterrupted) {
+                console.log('[AgentLoop] Execution interrupted by user — stopping early');
+                break;
+            }
+            // ── Smart replan on failure ────────────────────────────────────
+            if (!stepResult.success) {
+                // Resolve credentials: prefer explicit params, then route through getNextAvailableAPI
+                let _rpKey = replanApiKey || '';
+                let _rpModel = replanModel || '';
+                let _rpProvider = replanProvider || '';
+                if (!_rpKey && !_rpModel) {
+                    try {
+                        const _next = (0, router_1.getNextAvailableAPI)();
+                        if (_next) {
+                            _rpKey = _next.entry.key.startsWith('env:')
+                                ? (process.env[_next.entry.key.replace('env:', '')] || '')
+                                : _next.entry.key;
+                            _rpModel = _next.entry.model;
+                            _rpProvider = _next.entry.provider;
+                        }
+                    }
+                    catch { }
+                }
+                if (_rpKey || _rpProvider === 'ollama') {
+                    const newSteps = await handleToolFailure(replanState, step.tool, stepResult.error || 'unknown error', plan.goal, results, _rpKey, _rpModel, _rpProvider);
+                    if (newSteps && newSteps.length > 0) {
+                        livePulse_1.livePulse.act('Aiden', `Replanning with different strategy (${replanState.replanCount}/${MAX_REPLANS})`);
+                        auditTrail_1.auditTrail.record({
+                            action: 'system',
+                            tool: 'replan',
+                            input: `Failed: ${step.tool}`,
+                            output: `New plan: ${newSteps.map(s => s.tool).join(' → ')}`,
+                            durationMs: 0,
+                            success: true,
+                            goal: plan.goal,
+                            traceId: plan.planId,
+                        });
+                        const newGroups = buildDependencyGroups(newSteps);
+                        groups.splice(_gi, groups.length - _gi, ...newGroups);
+                        console.log(`[Replan] Spliced ${newGroups.length} new group(s) into execution from position ${_gi}`);
+                    }
+                    else if (replanState.replanCount >= MAX_REPLANS) {
+                        const failedList = Array.from(replanState.failedSteps.entries())
+                            .map(([tool, f]) => `- ${tool}: ${f.error}`)
+                            .join('\n');
+                        console.log(`[Replan] All ${MAX_REPLANS} replans exhausted for goal: "${plan.goal.slice(0, 60)}"`);
+                        appendLesson(`Replan exhausted (${MAX_REPLANS} attempts) for goal: "${plan.goal.slice(0, 80)}". Failed tools: ${Array.from(replanState.failedSteps.keys()).join(', ')}.`);
+                        results.push({
+                            step: step.step + 1, tool: 'replan_exhausted', input: {},
+                            success: false, output: '',
+                            error: `Tried ${MAX_REPLANS + 1} different approaches:\n${failedList}\n\nWould you like me to try a different approach?`,
+                            duration: 0,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // —— Parallel group ———————————————————————
+            // Chunk oversized groups so we never exceed MAX_PARALLEL concurrent calls
+            const chunks = unskipped.length > parallelExecutor_1.MAX_PARALLEL ? (0, parallelExecutor_1.chunkSteps)(unskipped, parallelExecutor_1.MAX_PARALLEL) : [unskipped];
+            for (const chunk of chunks) {
+                // ── Budget: one increment per parallel chunk ───────────────────
+                budget.currentIteration++;
+                livePulse_1.livePulse.act('Aiden', `Running ${chunk.length} steps in parallel: ${chunk.map(s => s.tool).join(', ')}`);
+                // Emit parallel metadata onto workflow nodes before dispatch
+                for (const s of chunk) {
+                    (0, workflowTracker_1.updateNode)(`step_${s.step}`, { parallel: true, groupSize: chunk.length });
+                }
+                const settled = await Promise.allSettled(chunk.map(step => executeSingleStep(step, stepOutputs, state, plan, workspace, onStep)));
+                for (let i = 0; i < chunk.length; i++) {
+                    const s = chunk[i];
+                    const result = settled[i];
+                    if (result.status === 'fulfilled') {
+                        stepOutputs[s.step] = result.value.output;
+                        results.push(result.value);
+                    }
+                    else {
+                        const errResult = {
+                            step: s.step, tool: s.tool, input: s.input,
+                            success: false, output: '', error: String(result.reason), duration: 0,
+                        };
+                        results.push(errResult);
+                        taskState_1.taskStateManager.failStep(state, s.step, errResult.error || 'parallel rejected');
+                        livePulse_1.livePulse.error('Aiden', `${s.tool} parallel rejected: ${result.reason}`);
+                    }
+                }
+            }
+        }
+    }
+    // Complete final phase
+    if (plan.planId) {
+        planTool_1.planTool.advancePhase(plan.planId, 'All steps completed');
+    }
+    // Finalize task state
+    const allSucceeded = results.every(r => r.success);
+    if (allSucceeded) {
+        taskState_1.taskStateManager.complete(state);
+    }
+    else {
+        const failed = results.filter(r => !r.success).map(r => r.tool).join(', ');
+        taskState_1.taskStateManager.fail(state, failed ? `Steps failed: ${failed}` : 'Incomplete execution');
+    }
+    // Workflow tracking — close the node graph
+    (0, workflowTracker_1.updateNode)('main', { status: allSucceeded ? 'completed' : 'failed', completedAt: Date.now() });
+    (0, workflowTracker_1.completeWorkflow)(allSucceeded ? 'completed' : 'failed');
+    // Record experience for self-learning
+    const filesCreatedInPlan = results
+        .filter(r => r.tool === 'file_write' && r.success && r.input?.path)
+        .map(r => r.input.path)
+        .filter(Boolean);
+    learningMemory_1.learningMemory.record({
+        task: plan.goal,
+        success: allSucceeded,
+        steps: results.map(r => r.tool),
+        duration: Date.now() - planStart,
+        tokenUsage: state.tokenUsage,
+        filesCreated: filesCreatedInPlan,
+        errorMessage: !allSucceeded
+            ? results.find(r => !r.success)?.error
+            : undefined,
+    });
+    // Self-teaching — generate/update SKILL.md for this tool sequence
+    const executedTools = results.map(r => r.tool);
+    const totalDuration = results.reduce((s, r) => s + (r.duration || 0), 0);
+    const anyFailed = results.some(r => !r.success);
+    if (allSucceeded && executedTools.length > 0) {
+        // GrowthEngine — record success for gap-resolution tracking
+        growthEngine_1.growthEngine.logSuccess(plan.goal, executedTools);
+        try {
+            const next = (0, router_1.getNextAvailableAPI)();
+            if (next) {
+                const key = next.entry.key.startsWith('env:')
+                    ? (process.env[next.entry.key.replace('env:', '')] || '')
+                    : next.entry.key;
+                skillTeacher_1.skillTeacher.recordSuccess(plan.goal, executedTools, totalDuration, callLLM, key, next.entry.model, next.entry.provider).catch(() => { });
+            }
+        }
+        catch { }
+    }
+    else if (anyFailed) {
+        // GrowthEngine — record failure with full error context
+        const firstError = results.find(r => !r.success)?.error ?? 'Unknown error';
+        growthEngine_1.growthEngine.logFailure(plan.goal, firstError, executedTools);
+        skillTeacher_1.skillTeacher.recordFailure(plan.goal, executedTools);
+    }
+    // Execution summary
+    const successCount = results.filter(r => r.success).length;
+    const execTotalMs = Date.now() - planStart;
+    console.log(`[Exec] Complete: ${successCount}/${results.length} steps succeeded in ${execTotalMs}ms`);
+    // Finalize executions log
+    try {
+        const execFile = nodePath.join(process.cwd(), 'workspace', 'executions', `exec_${state.id}.json`);
+        if (nodeFs.existsSync(execFile)) {
+            const log = JSON.parse(nodeFs.readFileSync(execFile, 'utf8'));
+            log.status = allSucceeded ? 'completed' : 'failed';
+            log.totalDuration = execTotalMs;
+            nodeFs.writeFileSync(execFile, JSON.stringify(log, null, 2));
+        }
+    }
+    catch { /* non-blocking */ }
+    return results;
+}
+// ── Step ordering fixer ────────────────────────────────────────
+// Ensures research/fetch steps always run before file_write steps.
+// Prevents file_write from executing before deep_research has data.
+function fixStepOrdering(steps) {
+    const researchTools = ['web_search', 'deep_research', 'fetch_url', 'fetch_page'];
+    const writeTools = ['file_write'];
+    const research = steps.filter(s => researchTools.includes(s.tool));
+    const writes = steps.filter(s => writeTools.includes(s.tool));
+    const others = steps.filter(s => !researchTools.includes(s.tool) && !writeTools.includes(s.tool));
+    // Order: research → other → write — re-number steps
+    return [...research, ...others, ...writes]
+        .map((s, i) => ({ ...s, step: i + 1 }));
+}
+// Resolve PREVIOUS_OUTPUT and {{step_N_output}} in step inputs
+function resolvePreviousOutput(input, stepOutputs, currentStep) {
+    const resolved = {};
+    const lastOutput = stepOutputs[currentStep - 1] || '';
+    // Step 1 with PREVIOUS_OUTPUT = planner bug. Log a warning and substitute with
+    // empty string so the tool fails with a clear "no input" error rather than
+    // passing the literal placeholder text to the API.
+    if (currentStep === 1) {
+        const inputStr = JSON.stringify(input);
+        if (inputStr.includes('PREVIOUS_OUTPUT')) {
+            console.warn('[Planner] Step 1 used PREVIOUS_OUTPUT — no previous output exists. Substituting empty string.');
+        }
+    }
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === 'string') {
+            resolved[key] = value
+                .replace(/PREVIOUS_OUTPUT/g, lastOutput)
+                .replace(/\{\{step_(\d+)_output\}\}/g, (_, n) => stepOutputs[parseInt(n, 10)] || '');
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
+// ── STEP 3: respondWithResults ────────────────────────────────
+function responderSystem(userName, date) {
+    return (0, aidenPersonality_1.AIDEN_RESPONDER_SYSTEM)(userName, date);
+}
+async function respondWithResults(originalMessage, plan, results, history, userName, apiKey, model, providerName, onToken, sessionId, goals) {
+    const date = new Date().toLocaleDateString('en-US', {
+        weekday: 'long', month: 'long', day: 'numeric', year: 'numeric',
+    });
+    // Load skill guidance for the response
+    const responseSkills = skillLoader_1.skillLoader.findRelevant(originalMessage, 2);
+    const responseSkillContext = responseSkills.length > 0
+        ? `\nSkill guidance for this response:\n${responseSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')}\n`
+        : '';
+    // Selective skill injection — simple messages (< 15 words, no tool keywords) get no skills;
+    // complex messages get only the relevant subset (already filtered by findRelevant above).
+    // Replaces the old loadAll() dump that injected all ~96 skills into every prompt.
+    const capabilitiesSection = (0, skillLoader_1.isSimpleMessage)(originalMessage)
+        ? ''
+        : (responseSkills.length > 0
+            ? `Relevant skills for this task: ${responseSkills.map(s => `${s.name} (${s.description})`).join(', ')}\n\n`
+            : '');
+    // Knowledge context — relevant chunks from user's uploaded files
+    const knowledgeCtxResponder = knowledgeBase_1.knowledgeBase.buildContext(originalMessage || '');
+    const knowledgeResponderSection = knowledgeCtxResponder
+        ? `\nRELEVANT KNOWLEDGE FROM YOUR FILES:\n${knowledgeCtxResponder}\n`
+        : '';
+    // ── Depth scoring: detect research tasks and force deep analysis ──
+    const isResearch = results.some(r => r.tool === 'deep_research' ||
+        r.tool === 'run_agent' ||
+        (r.tool === 'web_search' && results.length > 1));
+    const depthInstruction = isResearch
+        ? `\n\nRESEARCH RESPONSE REQUIREMENTS:
+- Minimum 500 words
+- Must include: Overview, Comparison (table or structured list), Key findings, Trends, Recommendation
+- Compare entities explicitly: "X is better than Y for Z because..."
+- Extract specific facts and numbers from the research data
+- End with a clear Verdict or Recommendation section
+- DO NOT just summarize — ANALYZE and provide INSIGHTS`
+        : '';
+    // Phase 1: multi-goal numbered output instruction
+    const _goalsToUse = goals && goals.length >= 2 ? goals : (plan.goals && plan.goals.length >= 2 ? plan.goals : null);
+    const multiGoalInstruction = _goalsToUse
+        ? `\n\nMULTI-GOAL RESPONSE — the user had ${_goalsToUse.length} distinct goals:\n${_goalsToUse.map((g, i) => `${i + 1}. ${g}`).join('\n')}\nStructure your response with numbered sections (1., 2., …) that match each goal above. Do not skip any goal.`
+        : '';
+    const executionSummary = results.length
+        ? results.map((r, i) => `Step ${i + 1} [${r.tool}]: ${r.success ? r.output.slice(0, 500) : 'FAILED — ' + r.error}`).join('\n\n')
+        : '';
+    // Inject conversation memory only when the message references past context
+    // (reduces prompt size for routine messages — "hi", "thanks", etc.)
+    const memCtx = (0, skillLoader_1.needsMemory)(originalMessage) ? conversationMemory_1.conversationMemory.buildContext() : '';
+    const memSection = memCtx
+        ? `\nCONVERSATION HISTORY:\n${memCtx}\n\nIf the user asks what we worked on, what was researched, or references previous work — answer from this history.\n`
+        : '';
+    // Entity graph — 1-line summary only (never dump full graph into prompt)
+    const entityStats = entityGraph_1.entityGraph.getStats();
+    const entitySummary = entityStats.nodes > 0
+        ? `You know ${entityStats.nodes} entities across your work.\n\n`
+        : '';
+    // Build a tool-results context block for the system prompt
+    const toolResultsContext = results.length
+        ? results.map(r => `[${r.tool} result]: ${r.success ? r.output.slice(0, 1000) : 'FAILED: ' + r.error}`).join('\n')
+        : '';
+    const systemWithResults = toolResultsContext
+        ? `${capabilitiesSection}${entitySummary}${responderSystem(userName, date)}${responseSkillContext}${knowledgeResponderSection}${multiGoalInstruction}
+
+YOU JUST RAN THESE TOOLS AND GOT THESE RESULTS:
+${toolResultsContext}
+
+CRITICAL RULES FOR YOUR RESPONSE:
+- Include the ACTUAL output from the tools above in your response
+- Do NOT say "I ran the tool" — show the RESULT
+- If run_python returned a number, say that number
+- If file_read returned text, show that text
+- If system_info returned hardware data, show the data
+- Be direct: show the actual output, then provide context if needed
+- If a tool failed, say it failed and why`
+        : `${capabilitiesSection}${entitySummary}${responderSystem(userName, date)}${responseSkillContext}${knowledgeResponderSection}${multiGoalInstruction}`;
+    const userContent = executionSummary
+        ? `User asked: "${originalMessage}"\n\nReal execution results:\n${executionSummary}\n\nRespond naturally based on these real results only. Show the actual output, not a description of it.${depthInstruction}${memSection}`
+        : `${originalMessage}${memSection}`;
+    let messages = [
+        { role: 'system', content: systemWithResults },
+        ...history.slice(-6),
+        { role: 'user', content: userContent },
+    ];
+    messages = await preflightCompressionCheck(messages, model, sessionId);
+    messages = (0, messageValidator_1.sanitizeMessages)(messages);
+    if (executionInterrupted)
+        return;
+    const _respCtrl = new AbortController();
+    currentAbortController = _respCtrl;
+    try {
+        if (providerName === 'gemini') {
+            const contents = messages
+                .filter(m => m.role !== 'system')
+                .map(m => ({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text: m.content }] }));
+            const system = messages.find(m => m.role === 'system')?.content;
+            const r = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    contents,
+                    systemInstruction: system ? { parts: [{ text: system }] } : undefined,
+                }),
+                signal: AbortSignal.any([AbortSignal.timeout(30000), _respCtrl.signal]),
+            });
+            if (!r.ok) {
+                const errText = await r.text().catch(() => '');
+                if (r.status === 429 || r.status === 503) {
+                    try {
+                        (0, router_1.markRateLimited)(providerName);
+                    }
+                    catch { }
+                }
+                const capacityHint = errText.toLowerCase().includes('capacity') || errText.toLowerCase().includes('overloaded') ? ' capacity' : '';
+                throw new Error(`Responder ${r.status}${capacityHint}: ${errText.slice(0, 200)}`);
+            }
+            await streamGeminiResponse(r, onToken);
+        }
+        else if (providerName === 'ollama') {
+            const ollamaMs = Math.min((0, modelDiscovery_1.getOllamaTimeout)(model || ''), 15000); // cap at 15s for chat
+            const _t0 = Date.now();
+            console.log(`[Router] respondWithResults → ollama, model: ${model}, timeout: ${ollamaMs}ms`);
+            const r = await fetch('http://localhost:11434/api/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model, stream: true, messages }),
+                signal: AbortSignal.any([AbortSignal.timeout(ollamaMs), _respCtrl.signal]),
+            });
+            if (!r.body)
+                throw new Error('Ollama: no response body');
+            const reader = r.body.getReader();
+            const decoder = new TextDecoder();
+            let ollamaTokens = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const line = decoder.decode(value);
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed?.message?.content) {
+                        onToken(parsed.message.content);
+                        ollamaTokens++;
+                    }
+                }
+                catch { }
+            }
+            console.log(`[Router] Ollama responded in ${Date.now() - _t0}ms (${ollamaTokens} tokens)`);
+            if (ollamaTokens === 0)
+                throw new Error('Ollama: empty response — no tokens emitted');
+        }
+        else {
+            // OpenAI-compatible
+            const url = OPENAI_COMPAT_ENDPOINTS[providerName] || OPENAI_COMPAT_ENDPOINTS.groq;
+            const r = await fetch(url, {
+                method: 'POST',
+                headers: buildHeaders(providerName, apiKey),
+                body: JSON.stringify({ model, messages, stream: true }),
+                signal: AbortSignal.any([AbortSignal.timeout(30000), _respCtrl.signal]),
+            });
+            if (!r.ok) {
+                const errText = await r.text().catch(() => '');
+                if (r.status === 429 || r.status === 503) {
+                    try {
+                        (0, router_1.markRateLimited)(providerName);
+                    }
+                    catch { }
+                }
+                const capacityHint = errText.toLowerCase().includes('capacity') || errText.toLowerCase().includes('overloaded') ? ' capacity' : '';
+                throw new Error(`Responder ${r.status}${capacityHint}: ${errText.slice(0, 200)}`);
+            }
+            await streamOpenAIResponse(r, onToken);
+        }
+    }
+    catch (e) {
+        if (e.name === 'AbortError')
+            return;
+        console.error('[Responder] Error:', e.message);
+        if (e.message?.includes('timeout') ||
+            e.message?.includes('429') ||
+            e.message?.includes('503') ||
+            e.message?.includes('capacity') ||
+            e.message?.includes('overloaded') ||
+            e.message?.includes('rate') ||
+            e.message?.includes('aborted')) {
+            try {
+                (0, router_1.markRateLimited)(providerName);
+            }
+            catch { }
+        }
+        // If cloud provider hit capacity, try next provider in chain before falling to Ollama
+        if (providerName !== 'ollama' && (e.message?.includes('capacity') || e.message?.includes('503') || e.message?.includes('overloaded'))) {
+            const nextCloud = (0, router_1.getModelForTask)('responder');
+            if (nextCloud.providerName !== 'ollama' && nextCloud.apiName !== providerName && nextCloud.apiKey) {
+                console.log(`[Responder] ${providerName} at capacity — trying ${nextCloud.providerName} (${nextCloud.model})`);
+                try {
+                    const url = OPENAI_COMPAT_ENDPOINTS[nextCloud.providerName] || OPENAI_COMPAT_ENDPOINTS.groq;
+                    const headers = buildHeaders(nextCloud.providerName, nextCloud.apiKey);
+                    const r = await fetch(url, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify({ model: nextCloud.model, messages, stream: true }),
+                        signal: AbortSignal.timeout(30000),
+                    });
+                    if (r.ok) {
+                        await streamOpenAIResponse(r, onToken);
+                        return;
+                    }
+                    if (r.status === 429 || r.status === 503) {
+                        try {
+                            (0, router_1.markRateLimited)(nextCloud.apiName);
+                        }
+                        catch { }
+                    }
+                }
+                catch (nextErr) {
+                    console.error(`[Responder] ${nextCloud.providerName} fallback also failed: ${nextErr.message}`);
+                }
+            }
+        }
+        // If Ollama was primary and failed/timed out, fall back to best cloud provider
+        if (providerName === 'ollama') {
+            const cloudFallback = (0, router_1.getModelForTask)('responder');
+            if (cloudFallback.providerName !== 'ollama' && cloudFallback.apiKey) {
+                console.log(`[Router] Ollama timeout/error — falling back to ${cloudFallback.providerName} (${cloudFallback.model})`);
+                try {
+                    const url = OPENAI_COMPAT_ENDPOINTS[cloudFallback.providerName] || OPENAI_COMPAT_ENDPOINTS.groq;
+                    const headers = buildHeaders(cloudFallback.providerName, cloudFallback.apiKey);
+                    const r = await fetch(url, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify({ model: cloudFallback.model, messages, stream: true }),
+                        signal: AbortSignal.timeout(15000),
+                    });
+                    if (r.ok) {
+                        await streamOpenAIResponse(r, onToken);
+                        return;
+                    }
+                }
+                catch (fbErr) {
+                    console.error(`[Router] Cloud fallback also failed: ${fbErr.message}`);
+                }
+            }
+        }
+        // If the cloud provider failed and we haven't tried Ollama yet, try it
+        let ollamaResponded = false;
+        if (providerName !== 'ollama') {
+            try {
+                // Discover installed model via api/tags
+                const cfg = (0, index_1.loadConfig)();
+                let ollamaModel = process.env.OLLAMA_MODEL || cfg.ollama?.model || 'gemma4:e4b';
+                try {
+                    const _ob = (process.env.OLLAMA_HOST ?? 'http://127.0.0.1:11434').replace(/\/$/, '');
+                    const tagsRes = await fetch(`${_ob}/api/tags`, { signal: AbortSignal.timeout(3000) });
+                    if (tagsRes.ok) {
+                        const tagsData = await tagsRes.json();
+                        const firstModel = tagsData?.models?.[0]?.name;
+                        if (firstModel)
+                            ollamaModel = firstModel;
+                    }
+                }
+                catch { /* Ollama not running */ }
+                console.log(`[Responder] Cloud provider failed — falling back to Ollama (${ollamaModel})`);
+                const r = await fetch('http://localhost:11434/api/chat', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ model: ollamaModel, stream: true, messages }),
+                    signal: AbortSignal.timeout((0, modelDiscovery_1.getOllamaTimeout)(ollamaModel)),
+                });
+                if (r.ok && r.body) {
+                    const reader = r.body.getReader();
+                    const decoder = new TextDecoder();
+                    let tokensEmitted = 0;
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        try {
+                            const parsed = JSON.parse(decoder.decode(value));
+                            if (parsed?.message?.content) {
+                                onToken(parsed.message.content);
+                                tokensEmitted++;
+                            }
+                        }
+                        catch { }
+                    }
+                    if (tokensEmitted > 0) {
+                        ollamaResponded = true;
+                    }
+                }
+            }
+            catch (ollamaErr) {
+                console.warn(`[Responder] Ollama fallback also failed: ${ollamaErr.message}`);
+            }
+        }
+        if (ollamaResponded)
+            return;
+        // Last resort: return raw tool output if tools ran successfully
+        if (results && results.length > 0 && results.some(r => r.success)) {
+            const successResults = results.filter(r => r.success);
+            const lastResult = successResults[successResults.length - 1];
+            onToken(lastResult.output || 'Here are the results.');
+            return;
+        }
+        // Include error info from failed tools if any
+        if (results && results.length > 0) {
+            const failedResult = results[results.length - 1];
+            if (failedResult.error) {
+                onToken(`Error: ${failedResult.error}`);
+                return;
+            }
+        }
+        const degraded = (0, router_1.enterDegradedMode)(e.message || 'unknown error');
+        onToken(degraded.message);
+    }
+}
+// ── Non-streaming LLM helper (used by deepResearch) ──────────
+async function callLLM(prompt, apiKey, model, providerName, opts) {
+    if (executionInterrupted)
+        return '';
+    const _ctrl = new AbortController();
+    currentAbortController = _ctrl;
+    const messages = [{ role: 'user', content: prompt }];
+    try {
+        if (providerName === 'gemini') {
+            const r = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    contents: [{ role: 'user', parts: [{ text: prompt }] }],
+                    generationConfig: { maxOutputTokens: 2000 },
+                }),
+                signal: AbortSignal.any([AbortSignal.timeout(12000), _ctrl.signal]),
+            });
+            if (r.status === 429) {
+                try {
+                    (0, router_1.markRateLimited)(providerName);
+                }
+                catch { }
+                throw new Error(`Rate limited (429): ${providerName}`);
+            }
+            if (!r.ok) {
+                throw new Error(`HTTP ${r.status} from ${providerName}`);
+            }
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage(providerName, model, d?.usageMetadata?.promptTokenCount ?? 0, d?.usageMetadata?.candidatesTokenCount ?? 0, opts?.traceId, opts?.isSystem ?? false);
+            }
+            catch { }
+            return d?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        }
+        else if (providerName === 'ollama') {
+            const r = await fetch('http://localhost:11434/api/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: model || 'mistral:7b', stream: false, messages }),
+                signal: AbortSignal.any([AbortSignal.timeout((0, modelDiscovery_1.getOllamaTimeout)(model || '')), _ctrl.signal]),
+            });
+            if (r.status === 429) {
+                try {
+                    (0, router_1.markRateLimited)(providerName);
+                }
+                catch { }
+                throw new Error(`Rate limited (429): ${providerName}`);
+            }
+            if (!r.ok) {
+                throw new Error(`HTTP ${r.status} from ${providerName}`);
+            }
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage(providerName, model, d?.prompt_eval_count ?? 0, d?.eval_count ?? 0, opts?.traceId, opts?.isSystem ?? false);
+            }
+            catch { }
+            return d?.message?.content || '';
+        }
+        else if (providerName === 'cloudflare') {
+            // Cloudflare Workers AI — accountId|modelName stored in model field
+            const [accountId, cfModel] = model.split('|');
+            const r = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${cfModel || '@cf/meta/llama-3.1-8b-instruct'}`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ messages }),
+                signal: AbortSignal.any([AbortSignal.timeout(20000), _ctrl.signal]),
+            });
+            if (r.status === 429) {
+                try {
+                    (0, router_1.markRateLimited)(providerName);
+                }
+                catch { }
+                throw new Error(`Rate limited (429): ${providerName}`);
+            }
+            if (!r.ok)
+                throw new Error(`cloudflare ${r.status}`);
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage(providerName, model, 0, 0, opts?.traceId, opts?.isSystem ?? false);
+            }
+            catch { }
+            return d?.result?.response || '';
+        }
+        else if (providerName === 'custom') {
+            // Custom provider — look up baseUrl from config by matching apiKey
+            const cfgCustom = (0, index_1.loadConfig)();
+            const cp = cfgCustom.customProviders?.find((c) => c.enabled && c.apiKey === apiKey);
+            if (!cp?.baseUrl)
+                throw new Error(`callLLM: no baseUrl for custom provider (model=${model})`);
+            const r = await fetch(cp.baseUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+                body: JSON.stringify({
+                    model,
+                    messages: [
+                        { role: 'system', content: 'You are Aiden, a local-first personal AI OS. Be concise and direct.' },
+                        ...messages,
+                    ],
+                    stream: false,
+                    max_tokens: 2000,
+                }),
+                signal: AbortSignal.any([AbortSignal.timeout(45000), _ctrl.signal]),
+            });
+            if (r.status === 429) {
+                try {
+                    (0, router_1.markRateLimited)(providerName);
+                }
+                catch { }
+                throw new Error(`Rate limited (429): custom/${model}`);
+            }
+            if (!r.ok)
+                throw new Error(`HTTP ${r.status} from custom/${model}`);
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage(providerName, model, d?.usage?.prompt_tokens ?? 0, d?.usage?.completion_tokens ?? 0, opts?.traceId, opts?.isSystem ?? false);
+            }
+            catch { }
+            return d?.choices?.[0]?.message?.content || '';
+        }
+        else {
+            // OpenAI-compatible: groq, openrouter, cerebras, nvidia, github
+            const url = OPENAI_COMPAT_ENDPOINTS[providerName] || OPENAI_COMPAT_ENDPOINTS.groq;
+            const headers = buildHeaders(providerName, apiKey);
+            const r = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ model, messages, stream: false, max_tokens: 2000 }),
+                signal: AbortSignal.any([AbortSignal.timeout(12000), _ctrl.signal]),
+            });
+            if (r.status === 429) {
+                try {
+                    (0, router_1.markRateLimited)(providerName);
+                }
+                catch { }
+                throw new Error(`Rate limited (429): ${providerName}`);
+            }
+            if (!r.ok) {
+                throw new Error(`HTTP ${r.status} from ${providerName}`);
+            }
+            const d = await r.json();
+            try {
+                costTracker_1.costTracker.trackUsage(providerName, model, d?.usage?.prompt_tokens ?? 0, d?.usage?.completion_tokens ?? 0, opts?.traceId, opts?.isSystem ?? false);
+            }
+            catch { }
+            return d?.choices?.[0]?.message?.content || '';
+        }
+    }
+    catch (e) {
+        if (e.name === 'AbortError')
+            return '';
+        console.error('[callLLM] error:', e.message);
+        return '';
+    }
+}
+// ── Deep research: 3-pass LLM-assisted research loop ─────────
+// Called directly (e.g. from a /api/research endpoint) or as
+// a high-level entry point when the planner picks deep_research.
+async function deepResearch(topic, apiKey, model, provider, onProgress) {
+    const allResults = [];
+    let currentQuery = topic;
+    const maxPasses = 7;
+    for (let pass = 1; pass <= maxPasses; pass++) {
+        onProgress(`Pass ${pass}: Searching "${currentQuery}"...`);
+        const searchResult = await (0, toolRegistry_1.executeTool)('web_search', { query: currentQuery });
+        if (!searchResult.success || !searchResult.output)
+            break;
+        allResults.push(`=== Pass ${pass}: ${currentQuery} ===\n${searchResult.output}`);
+        // Reflection: what gaps remain?
+        const reflectionPrompt = `You are researching: "${topic}"
+
+So far you have found:
+${allResults.join('\n\n').slice(0, 3000)}
+
+Analyze the gaps:
+1. What important aspects of "${topic}" are still missing?
+2. What contradictions need resolving?
+3. What specific follow-up query would fill the biggest gap?
+
+Respond in JSON:
+{
+  "gaps": ["gap1", "gap2"],
+  "nextQuery": "specific search query to fill the biggest gap",
+  "complete": true/false
+}`;
+        const reflection = await callLLM(reflectionPrompt, apiKey, model, provider);
+        let reflectionData = {};
+        try {
+            const match = reflection.match(/\{[\s\S]*\}/);
+            reflectionData = JSON.parse(match?.[0] || '{}');
+        }
+        catch { }
+        if (reflectionData.complete === true || !reflectionData.nextQuery)
+            break;
+        currentQuery = reflectionData.nextQuery;
+        onProgress(`Filling gap: ${reflectionData.gaps?.[0] || currentQuery}`);
+        // Source quality scoring
+        const isHighQuality = searchResult.output.includes('wikipedia') ||
+            searchResult.output.includes('.gov') ||
+            searchResult.output.includes('reuters') ||
+            searchResult.output.includes('bloomberg');
+        if (isHighQuality)
+            onProgress('✓ High-quality source found');
+    }
+    return allResults.join('\n\n');
+}