funolio-agent 1.0.47 → 1.0.48

package/dist/message-loop.js

@@ -47,15 +47,12 @@ const approval_1 = require("./approval");
 const local_db_1 = require("./local-db");
 const config_1 = require("./config");
 const auto_detect_1 = require("./auth/auto-detect");
+const anthropic_subscription_1 = require("./auth/anthropic-subscription");
 const clerk_model_1 = require("./clerk-model");
+const local_funnel_1 = require("./local-funnel");
 const auto_organizer_1 = require("./auto-organizer");
-const orchestrator_profile_1 = require("./orchestrator-profile");
-const response_guard_1 = require("./response-guard");
-const context_compressor_1 = require("./context-compressor");
-const crypto = __importStar(require("crypto"));
+const tool_permissions_1 = require("./tool-permissions");
 const data = __importStar(require("./local-data"));
-const prompt_template_1 = require("./prompt-template");
-const local_funnel_1 = require("./local-funnel");
 /** Determine priority from an AgentCommand */
 function getCommandPriority(command) {
     if (command.priority)
@@ -111,12 +108,20 @@ function summarizeToolResult(output, isError) {
     const compact = output.replace(/\s+/g, ' ').trim();
     return `${prefix}${compact}`.slice(0, 240);
 }
+function normalizeMcpToolNames(toolNames) {
+    if (!Array.isArray(toolNames))
+        return undefined;
+    const trimmed = toolNames
+        .filter((toolName) => typeof toolName === 'string')
+        .map((toolName) => toolName.trim())
+        .filter(Boolean);
+    return [...new Set(trimmed)];
+}
 class MessageLoop {
     options;
     llmProvider;
     activeCommandId = null;
     activeCommandSource = null;
-    chunkSeq = 0;
     toolContext;
     toolDefinitions;
     builtinToolDefinitions;
@@ -126,7 +131,6 @@ class MessageLoop {
     resolvedAuth = null;
     idleTimer = null;
     approvalManager;
-    _activeAbortController = null;
     /** Rate limiting / cost guardrails */
     maxToolCallsPerMessage;
     maxTokensPerMessage;
@@ -139,41 +143,42 @@ class MessageLoop {
     static IDLE_THRESHOLD_MS = 15 * 60 * 1000; // 15 minutes
     constructor(options) {
         this.options = options;
-        const effectiveKey = options.apiKey || '';
+        // DO NOT remap Claude CLI OAuth sessions to the public Anthropic runtime
+        // without explicit user approval.
+        const effectiveKey = options.oauthToken || options.apiKey || '';
         const effectiveProvider = options.provider;
-        const llmAuthMode = options.authMode || (effectiveKey.startsWith('sk-ant-oat') ? 'oauth-bearer' : 'api-key');
+        const isOAuthToken = effectiveKey.startsWith('sk-ant-oat01-');
         this.llmProvider = (0, index_1.createProvider)(effectiveProvider, {
             apiKey: effectiveKey,
             model: options.model,
-            authMode: llmAuthMode,
-            ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
-            ...(options.apiStyle ? { apiStyle: options.apiStyle } : {}),
+            ...(isOAuthToken ? { authMode: 'oauth-bearer' } : {}),
         });
-        // Resolve Funolio API credentials for bot status reporting
-        const cfg = (0, config_1.loadConfig)();
-        const funoliApiKey = cfg.auth?.token || process.env.FUNOLIO_API_KEY || '';
-        const funoliApiBaseUrl = config_1.FUNOLIO_API_URL;
-        const unrestrictedCliProvider = index_1.CLI_PROVIDERS.has(effectiveProvider);
+        // Async: attempt to resolve Anthropic subscription auth (create_api_key exchange)
+        if (isOAuthToken && effectiveProvider === 'anthropic') {
+            this.resolveAndUpgradeAuth(effectiveKey, options.model);
+        }
         this.toolContext = (0, index_2.createToolContext)(options.projectDir, {
             actorType: 'llm',
             actorId: options.agentName || options.userId,
-            llmProvider: effectiveProvider,
-            llmModel: options.model,
-            llmApiKey: effectiveKey,
-            llmAuthMode,
-            restrictFileAccessToProject: unrestrictedCliProvider ? false : undefined,
-            apiKey: funoliApiKey,
-            apiBaseUrl: funoliApiBaseUrl,
-            botName: options.agentName || 'funolio-agent',
         });
+        this.options.enabledTools = (0, tool_permissions_1.normalizeConfiguredToolNames)(options.enabledTools);
+        this.options.enabledMcpTools = normalizeMcpToolNames(options.enabledMcpTools);
         let allTools = (0, index_2.getAllToolDefinitions)(options.mcpManager);
         let builtinTools = (0, index_2.getToolDefinitions)();
-        // Filter tools by enabledTools whitelist if specified
-        if (!unrestrictedCliProvider && options.enabledTools && options.enabledTools.length > 0) {
-            const allowed = new Set(options.enabledTools);
-            allTools = allTools.filter((t) => allowed.has(t.name));
-            builtinTools = builtinTools.filter((t) => allowed.has(t.name));
-            console.log(chalk_1.default.gray(`  [${options.agentName || 'agent'}] Tool filter: ${allTools.length} tools enabled (${options.enabledTools.length} configured)`));
+        // Filter builtin and MCP tools independently.
+        // An explicit empty array means "deny all" for that category.
+        if (this.options.enabledTools !== undefined || this.options.enabledMcpTools !== undefined) {
+            const builtinNames = new Set(builtinTools.map((t) => t.name));
+            const allowedBuiltin = this.options.enabledTools !== undefined ? new Set(this.options.enabledTools) : null;
+            const allowedMcp = this.options.enabledMcpTools !== undefined ? new Set(this.options.enabledMcpTools) : null;
+            allTools = allTools.filter((t) => {
+                if (builtinNames.has(t.name)) {
+                    return allowedBuiltin ? allowedBuiltin.has(t.name) : true;
+                }
+                return allowedMcp ? allowedMcp.has(t.name) : true;
+            });
+            builtinTools = builtinTools.filter((t) => (allowedBuiltin ? allowedBuiltin.has(t.name) : true));
+            console.log(chalk_1.default.gray(`  [${options.agentName || 'agent'}] Tool filter: ${allTools.length} enabled (builtin=${this.options.enabledTools?.length ?? 'all'}, mcp=${this.options.enabledMcpTools?.length ?? 'all'})`));
         }
         this.toolDefinitions = allTools;
         this.builtinToolDefinitions = builtinTools;
@@ -192,12 +197,59 @@ class MessageLoop {
         });
         // Rate limiting defaults (can be overridden via options from agent config)
         this.maxToolCallsPerMessage = options.maxToolCallsPerMessage ?? 50;
-        // maxTokensPerMessage retained for backwards compat but no longer enforced.
-        // LLM providers handle their own context limits with proper error responses.
-        this.maxTokensPerMessage = options.maxTokensPerMessage ?? 1_000_000;
+        this.maxTokensPerMessage = options.maxTokensPerMessage ?? 200_000;
         // Session idle detection timer (checks every 60s)
         this.idleTimer = setInterval(() => this.checkIdleSession(), 60_000);
     }
+    /**
+     * Attempt to resolve Anthropic subscription auth via create_api_key exchange.
+     * If successful, recreates the LLM provider with the exchanged API key (which
+     * works with standard x-api-key auth and unlocks all models on the subscription).
+     * Falls back to bearer mode silently if exchange fails.
+     */
+    async resolveAndUpgradeAuth(oauthToken, model) {
+        try {
+            const result = await (0, anthropic_subscription_1.resolveAnthropicSubscriptionAuth)({
+                accessToken: oauthToken,
+                refreshToken: this.options.resolvedAuth?.credential?.refreshToken || null,
+                expiresAt: this.options.resolvedAuth?.credential?.expiresAt || null,
+                onRefresh: (credential) => {
+                    // Propagate refreshed credentials to BOTH auth stores
+                    if (this.options.resolvedAuth) {
+                        this.options.resolvedAuth.credential = credential;
+                    }
+                    if (this.resolvedAuth) {
+                        this.resolvedAuth.credential = credential;
+                        // Also update the apiKey field so ensureFreshToken() sees the new token
+                        this.resolvedAuth.apiKey = credential.accessToken;
+                    }
+                    console.log('[message-loop] Anthropic OAuth token refreshed and propagated to runtime state');
+                },
+            });
+            if (result.source === 'api-key-exchange') {
+                // Successfully exchanged OAuth token for a temporary API key
+                console.log('[message-loop] Anthropic subscription auth: using exchanged API key');
+                this.llmProvider = (0, index_1.createProvider)('anthropic', {
+                    apiKey: result.token,
+                    model,
+                });
+            }
+            else {
+                // Bearer fallback — recreate provider with the (possibly refreshed) token
+                const currentToken = this.options.resolvedAuth?.credential?.accessToken || oauthToken;
+                console.log('[message-loop] Anthropic subscription auth: using bearer fallback' +
+                    (currentToken !== oauthToken ? ' (with refreshed token)' : ''));
+                this.llmProvider = (0, index_1.createProvider)('anthropic', {
+                    apiKey: currentToken,
+                    model,
+                    authMode: 'oauth-bearer',
+                });
+            }
+        }
+        catch (err) {
+            console.warn('[message-loop] Anthropic subscription auth resolution failed, keeping bearer mode:', err?.message || err);
+        }
+    }
     /** Check if a session has gone idle and trigger auto-organize */
     async checkIdleSession() {
         if (!this.lastMessageAt || !(0, auto_organizer_1.isAutoOrganizeEnabled)())
@@ -298,11 +350,6 @@ class MessageLoop {
                 console.log(chalk_1.default.yellow(`Cancelling command ${command.id}`));
                 this.activeCommandId = null;
                 this.approvalManager.cancelAll();
-                // Abort any running tool execution
-                if (this._activeAbortController) {
-                    this._activeAbortController.abort();
-                    this._activeAbortController = null;
-                }
             }
             return;
         }
@@ -315,37 +362,51 @@ class MessageLoop {
         const overrideModel = command.model?.model;
         let provider = overrideProvider || this.options.provider;
         const model = overrideModel || this.options.model;
-        const apiKey = this.options.apiKey;
+        const apiKey = this.options.oauthToken || this.options.apiKey;
         // Only create a new provider if provider or model actually changed (ignore apiKey overrides from server)
         const hasOverride = (overrideProvider && overrideProvider !== this.options.provider) ||
             (overrideModel && overrideModel !== this.options.model);
         let llm;
         if (hasOverride) {
-            llm = (0, index_1.createProvider)(provider, {
-                apiKey,
-                model,
-                ...(provider === this.options.provider && this.options.authMode ? { authMode: this.options.authMode } : {}),
-                ...(provider === this.options.provider && this.options.baseUrl ? { baseUrl: this.options.baseUrl } : {}),
-                ...(provider === this.options.provider && this.options.apiStyle ? { apiStyle: this.options.apiStyle } : {}),
-            });
+            // For overrides with OAuth tokens, try subscription auth resolution
+            if ((apiKey || '').startsWith('sk-ant-oat01-') && provider === 'anthropic') {
+                try {
+                    const authResult = await (0, anthropic_subscription_1.resolveAnthropicSubscriptionAuth)({
+                        accessToken: apiKey,
+                        refreshToken: this.options.resolvedAuth?.credential?.refreshToken || null,
+                        expiresAt: this.options.resolvedAuth?.credential?.expiresAt || null,
+                        onRefresh: (credential) => {
+                            if (this.options.resolvedAuth) {
+                                this.options.resolvedAuth.credential = credential;
+                            }
+                            if (this.resolvedAuth) {
+                                this.resolvedAuth.credential = credential;
+                                this.resolvedAuth.apiKey = credential.accessToken;
+                            }
+                            console.log('[message-loop] Anthropic OAuth token refreshed (override path)');
+                        },
+                    });
+                    llm = (0, index_1.createProvider)(provider, {
+                        apiKey: authResult.token,
+                        model,
+                        ...(authResult.authMode === 'oauth-bearer' ? { authMode: 'oauth-bearer' } : {}),
+                    });
+                }
+                catch {
+                    llm = (0, index_1.createProvider)(provider, { apiKey, model, authMode: 'oauth-bearer' });
+                }
+            }
+            else {
+                llm = (0, index_1.createProvider)(provider, { apiKey, model });
+            }
         }
         else {
             llm = this.llmProvider;
         }
         // Refresh tool definitions each command so newly installed MCP tools are visible
         this.toolDefinitions = (0, index_2.getAllToolDefinitions)(this._mcpManager);
-        // Fix 3: Check for dead MCP servers and note unavailable tools
-        let deadServerNote = '';
-        if (this._mcpManager) {
-            const dead = this._mcpManager.getDeadServers();
-            if (dead.length > 0) {
-                deadServerNote = `\n\n⚠️ UNAVAILABLE TOOL SERVERS: The following MCP servers have crashed and are no longer available: ${dead.join(', ')}. Do NOT attempt to use tools from these servers — they will fail. Inform the user if they ask for functionality from these servers.`;
-                console.log(chalk_1.default.yellow(`  [MCP] Dead servers detected: ${dead.join(', ')}`));
-            }
-        }
         this.activeCommandId = command.id;
         this.activeCommandSource = command.source || 'user';
-        this.chunkSeq = 0;
         this.processing = true;
         this.lastMessageAt = Date.now();
         const commandStartMs = Date.now();
@@ -406,21 +467,15 @@ class MessageLoop {
                 : undefined;
             const effectiveProjectId = command.context?.projectId || activeConversation?.project_id || undefined;
             const effectiveProject = effectiveProjectId ? localData?.getProject(effectiveProjectId) : undefined;
-            // Create abort controller for this command execution
-            const commandAbortController = new AbortController();
-            this._activeAbortController = commandAbortController;
             const commandToolContext = {
                 ...this.toolContext,
                 projectId: effectiveProjectId ?? null,
-                abortSignal: commandAbortController.signal,
-                // Use project folder as working directory if available
-                ...(effectiveProject?.folder ? { projectDir: effectiveProject.folder } : {}),
             };
             // ─── Orchestrator Mode Branch ─────────────────────────
             // Resolve the selected bot profile — from command.bot, conversation bot_id, or default
             const selectedBotId = command.bot?.id || activeConversation?.bot_id || localAgentId;
             const activeProfile = selectedBotId ? localData?.getAgentProfile(selectedBotId) : null;
-            if ((0, orchestrator_profile_1.isOrchestratorProfile)(activeProfile) && localFirst) {
+            if (activeProfile?.role_class === 'orchestrator' && localFirst) {
                 const clerk = (0, clerk_model_1.getClerk)();
                 if (!clerk) {
                     // Do not silently fall through to direct chat — report error
@@ -435,15 +490,6 @@ class MessageLoop {
                     const { getWorkflowEngine } = await Promise.resolve().then(() => __importStar(require('./workflow-engine')));
                     const workflowEngine = getWorkflowEngine(this.options.projectDir);
                     const orchestrator = new OrchestratorAgent(clerk, workflowEngine);
-                    // Orchestrator work is conversation-scoped and can continue in parallel.
-                    // Release the global message-loop lock here so another conversation can start.
-                    this.activeCommandId = null;
-                    this.processing = false;
-                    if (this.scheduledTaskTimer) {
-                        clearTimeout(this.scheduledTaskTimer);
-                        this.scheduledTaskTimer = null;
-                    }
-                    void this.drainQueue();
                     try {
                         const response = await orchestrator.handleUserMessage(command.prompt, localConvId || '', {
                             projectDir: this.options.projectDir,
@@ -453,33 +499,27 @@ class MessageLoop {
                                 await this.options.mqttClient.publishResult({
                                     commandId: command.id,
                                     type: 'chunk',
-                                    seq: this.chunkSeq++,
                                     content: status + '\n',
                                     timestamp: Date.now(),
                                 });
                             },
                             mqttPublish: (result) => this.options.mqttClient.publishResult(result),
                         });
-                        const responseMeta = orchestrator.getLastResponseMeta();
-                        const finalAgentName = responseMeta?.agentName || 'Orchestrator';
-                        const finalBotId = responseMeta?.botId || (finalAgentName === 'Orchestrator' ? activeProfile?.id : undefined);
-                        const finalModelLabel = responseMeta?.modelLabel || undefined;
-                        // Save final response to local DB
-                        if (localConvId && localData && activeProfile) {
-                            localData.addMessage(localConvId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
+                        // Save O's response to local DB
+                        if (localConvId && localData) {
+                            localData.addMessage(localConvId, 'assistant', response, undefined, undefined, activeProfile.id, 'Project Manager');
                         }
                         // Publish final response and complete
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'chunk',
-                            seq: this.chunkSeq++,
                             content: response,
                             timestamp: Date.now(),
                         });
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'complete',
-                            content: response || '',
+                            content: '',
                             timestamp: Date.now(),
                         });
                     }
@@ -493,7 +533,7 @@ class MessageLoop {
                             clearTimeout(this.scheduledTaskTimer);
                             this.scheduledTaskTimer = null;
                         }
-                        void this.drainQueue();
+                        this.drainQueue();
                     }
                     return;
                 }
@@ -524,7 +564,7 @@ class MessageLoop {
                             includeKeyDecisions: false,
                         });
                         systemPrompt = built.systemPrompt;
-                        console.log(chalk_1.default.gray(`  [clerk] Context: ${built.injectedSummaries} summaries (${built.contextTokensUsed} tokens)`));
+                        console.log(chalk_1.default.gray(`  [clerk] Context: ${built.injectedFacts} facts, ${built.injectedDecisions} decisions, ${built.injectedSummaries} summaries (${built.contextTokensUsed} tokens)`));
                     }
                     else {
                         systemPrompt = this.buildFallbackSystemPrompt(command);
@@ -538,17 +578,13 @@ class MessageLoop {
                 systemPrompt = this.buildFallbackSystemPrompt(command);
             }
             // --- Context priority rules & tool fallback (AFTER context) ---
-            // Fix 3: Inject dead server warnings into system prompt
-            if (deadServerNote) {
-                systemPrompt += deadServerNote;
-            }
             systemPrompt += `\n\nCONTEXT PRIORITY RULES:
-1. ALWAYS use the context provided above (summaries, workflow history, and conversations) to answer questions about past work, decisions, or projects. This is your PRIMARY knowledge source — it comes from the user's stored conversation history.
+1. ALWAYS use the context provided above (decisions, memory facts, conversations) to answer questions about past work, decisions, or projects. This is your PRIMARY knowledge source — it comes from the user's stored conversation history.
 2. Do NOT browse local files or run shell commands unless:
    a. The provided context does not contain the answer, OR
    b. The user explicitly asks you to look at local files or run a command, OR
    c. The user asks about current runtime state (logs, running processes, file contents right now)
-3. When you use provided context, briefly cite the source (e.g. "Based on your stored summary..." or "From your conversation history...").
+3. When you use provided context, briefly cite the source (e.g. "Based on your stored decisions..." or "From your conversation history...").
 4. If no relevant context was provided AND the question is about past work/decisions, say "I don't have stored context about that topic yet" — don't guess or hallucinate.
 
 TOOL EFFICIENCY RULES:
@@ -556,245 +592,56 @@ TOOL EFFICIENCY RULES:
 - PREFER one broad command over many narrow ones (e.g. "find . -name '*.json' -exec grep 'error' {} +" instead of checking files one by one)
 - PLAN your approach before starting — outline what you need to find, then execute with minimal tool calls`;
             // Count context sections injected into system prompt
-            const contextSectionCount = ['[Relevant Conversations]', '[Code References]', '[Relevant Files]', '[Bot Memory]', '[Retrieved Context]', '[Summaries]']
+            const contextSectionCount = ['[Key Decisions]', '[Memory Facts]', '[Relevant Conversations]', '[Code References]', '[Relevant Files]', '[Bot Memory]', '[Retrieved Context]']
                 .filter(header => systemPrompt.includes(header)).length;
-            // Add the current prompt (with image attachments if present)
-            if (command.attachments && command.attachments.length > 0) {
-                const contentParts = [];
-                for (const att of command.attachments) {
-                    if (att.fileType === 'image' && att.dataUrl) {
-                        // Anthropic native format: source block with base64
-                        const commaIdx = att.dataUrl.indexOf(',');
-                        if (commaIdx >= 0) {
-                            const mimeMatch = att.dataUrl.match(/^data:([^;]+);/);
-                            const mediaType = mimeMatch?.[1] || att.mimeType || 'image/png';
-                            const base64Data = att.dataUrl.slice(commaIdx + 1);
-                            contentParts.push({ type: 'image', source: { type: 'base64', media_type: mediaType, data: base64Data } });
-                        }
-                        else {
-                            // Fallback: treat as URL
-                            contentParts.push({ type: 'image_url', image_url: { url: att.dataUrl, detail: 'auto' } });
-                        }
-                    }
-                    if (att.extractedText) {
-                        contentParts.push({ type: 'text', text: `[File: ${att.filename}]\n${att.extractedText}` });
-                    }
-                }
-                contentParts.push({ type: 'text', text: command.prompt });
-                messages.push({ role: 'user', content: contentParts });
-            }
-            else {
-                messages.push({ role: 'user', content: command.prompt });
-            }
-            // Retry budget tracker (Optimization 2)
-            const toolFailuresByKey = new Map(); // toolName:argsHash → count
-            const toolFailuresByName = new Map(); // toolName → count
-            function getArgsHash(args) {
-                const str = JSON.stringify(args || {}).slice(0, 200);
-                return crypto.createHash('md5').update(str).digest('hex').slice(0, 12);
-            }
-            function getRetryKey(name, args) {
-                // Bug 6: For meta-tools, include action in retry key so different actions don't share budget
-                if (args?.action)
-                    return `${name}:${args.action}`;
-                return name;
-            }
-            function trackToolFailure(name, args) {
-                const key = `${getRetryKey(name, args)}:${getArgsHash(args)}`;
-                const retryKey = getRetryKey(name, args);
-                toolFailuresByKey.set(key, (toolFailuresByKey.get(key) || 0) + 1);
-                toolFailuresByName.set(retryKey, (toolFailuresByName.get(retryKey) || 0) + 1);
-            }
-            // Futility detection: track consecutive low-value tool results
-            let consecutiveEmptyResults = 0;
-            const FUTILITY_THRESHOLD = 6; // after 6 consecutive empty/low-value results, nudge the LLM
-            let futilityNudgeInjected = false;
-            function isLowValueResult(output) {
-                if (!output || output.length < 30)
-                    return true;
-                const lower = output.toLowerCase();
-                if (lower.includes('no matches found') || lower.includes('no results'))
-                    return true;
-                if (lower.includes('0 bytes') || lower.includes('empty'))
-                    return true;
-                // exit code 1 with no meaningful stdout
-                if (/\[exit code: [^0]/.test(lower) && output.replace(/\[exit code:.*?\]/g, '').trim().length < 20)
-                    return true;
-                return false;
-            }
-            function checkRetryBudget(name, args) {
-                const key = `${getRetryKey(name, args)}:${getArgsHash(args)}`;
-                const retryKey = getRetryKey(name, args);
-                const keyCount = toolFailuresByKey.get(key) || 0;
-                const nameCount = toolFailuresByName.get(retryKey) || 0;
-                if (keyCount >= 2) {
-                    return `This exact operation has failed ${keyCount} times. Stop retrying and inform the user what went wrong. Suggest an alternative approach or ask for help.`;
-                }
-                if (nameCount >= 3) {
-                    return `The ${name} tool has failed ${nameCount} times in this conversation. Consider a completely different approach.`;
-                }
-                return null;
-            }
+            // Add the current prompt
+            messages.push({ role: 'user', content: command.prompt });
             // Agentic loop - keep calling LLM until no more tool calls
             let iteration = 0;
-            // Phase 1d: hard caps on iterations, tokens, and tool calls
-            // Web/MQTT commands (source undefined or 'user') get tighter cap; scheduled/system tasks get more room
-            const MAX_ITERATIONS = (command.source === 'scheduled' || command.source === 'system') ? 10 : 5;
-            const MAX_INPUT_TOKENS = 150_000; // 150K cumulative input token budget
-            const MAX_TOOL_CALLS = 20; // hard cap on tool calls per turn
-            const INACTIVITY_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes of no LLM/tool activity
-            let lastActivityMs = Date.now();
-            let lastProgressMs = Date.now();
+            const MAX_ITERATIONS = Infinity;
             let totalTokensUsed = 0;
-            let totalInputTokens = 0;
-            let totalOutputTokens = 0;
-            let totalCacheReadTokens = 0;
-            let totalCacheCreationTokens = 0;
-            let totalToolCallDurationMs = 0;
-            const deniedTools = new Set(); // Track tools denied by user — don't re-ask
-            const commandStartMs = Date.now();
-            // Publish prompt context for "View Prompt" panel
-            try {
-                const promptSnapshot = [
-                    { role: 'system', content: systemPrompt.slice(0, 4000) + (systemPrompt.length > 4000 ? '\n...(truncated)' : '') },
-                    ...messages.map(m => ({ role: m.role, content: typeof m.content === 'string' ? m.content.slice(0, 2000) : '' })),
-                ];
-                await this.options.mqttClient.publishResult({
-                    commandId: command.id,
-                    type: 'prompt_messages',
-                    messages: promptSnapshot,
-                    contextSections: contextSectionCount,
-                    model,
-                    timestamp: Date.now(),
-                });
-            }
-            catch { }
             while (iteration < MAX_ITERATIONS && this.activeCommandId === command.id) {
                 iteration++;
-                // Emit progress every 60 seconds
-                if (Date.now() - lastProgressMs >= 60_000) {
-                    lastProgressMs = Date.now();
-                    await this.options.mqttClient.publishResult({
-                        commandId: command.id,
-                        type: 'progress',
-                        elapsed: Math.round((Date.now() - commandStartMs) / 1000),
-                        iteration,
-                        toolsUsed: totalToolCalls,
-                        timestamp: Date.now(),
-                    });
-                }
-                // Inactivity timeout check (5 min of no LLM response or tool completion)
-                if (Date.now() - lastActivityMs > INACTIVITY_TIMEOUT_MS) {
-                    console.log(chalk_1.default.red(`  ⏱ Inactivity timeout exceeded (${INACTIVITY_TIMEOUT_MS / 1000}s) — attempting graceful wind-down`));
-                    // Inject wind-down system message and do one final LLM call
-                    messages.push({
-                        role: 'user',
-                        content: '[System] You are running out of time. Stop using tools immediately. Summarize everything you have so far and provide your best answer now.',
-                    });
-                    let windDownSucceeded = false;
-                    let windDownResponse = null;
-                    try {
-                        windDownResponse = await llm.chat({
-                            messages,
-                            system: systemPrompt,
-                            stream: true,
-                            onChunk: async (chunk) => {
-                                if (this.activeCommandId !== command.id)
-                                    return;
-                                await this.options.mqttClient.publishResult({
-                                    commandId: command.id,
-                                    type: 'chunk',
-                                    seq: this.chunkSeq++,
-                                    content: chunk,
-                                    timestamp: Date.now(),
-                                });
-                            },
-                        });
-                        if (windDownResponse.usage) {
-                            totalTokensUsed += windDownResponse.usage.inputTokens + windDownResponse.usage.outputTokens;
-                            totalInputTokens += windDownResponse.usage.inputTokens;
-                            totalOutputTokens += windDownResponse.usage.outputTokens;
-                        }
-                        windDownSucceeded = true;
-                    }
-                    catch (windDownErr) {
-                        console.error(chalk_1.default.red(`  Wind-down LLM call failed: ${windDownErr.message}`));
-                        commandAbortController.abort();
-                    }
-                    // Emit stats
-                    await this.options.mqttClient.publishResult({
-                        commandId: command.id,
-                        type: 'stats',
-                        llmCalls: iteration,
-                        toolsUsed: totalToolCalls,
-                        inputTokens: totalInputTokens,
-                        outputTokens: totalOutputTokens,
-                        cacheReadTokens: totalCacheReadTokens || undefined,
-                        cacheCreationTokens: totalCacheCreationTokens || undefined,
-                        totalTokens: totalTokensUsed,
-                        latencyMs: Date.now() - commandStartMs,
-                        toolCallDurationMs: totalToolCallDurationMs || undefined,
-                        contextSections: contextSectionCount || undefined,
-                        model,
-                        timestamp: Date.now(),
-                    });
-                    if (windDownSucceeded) {
-                        // Wind-down produced a summary — treat as completed
-                        await this.options.mqttClient.publishResult({
-                            commandId: command.id,
-                            type: 'complete',
-                            content: windDownResponse?.content || '',
-                            timestamp: Date.now(),
-                        });
-                        console.log(chalk_1.default.green(`  Command completed (inactivity wind-down): ${iteration} iterations, ${totalToolCalls} tool calls`));
-                    }
-                    else {
-                        // Wind-down failed — emit error so the job is marked failed, not completed
-                        await this.options.mqttClient.publishResult({
-                            commandId: command.id,
-                            type: 'error',
-                            error: `Command timed out after ${Math.round((Date.now() - commandStartMs) / 60000)} minutes of inactivity and wind-down failed.`,
-                            timestamp: Date.now(),
-                        });
-                        console.log(chalk_1.default.red(`  Command failed (wind-down failed): ${iteration} iterations, ${totalToolCalls} tool calls`));
-                    }
-                    break;
-                }
                 // Send a separator between agentic loop iterations so streamed text
                 // from different LLM calls doesn't run together in the UI.
                 if (iteration > 1) {
                     await this.options.mqttClient.publishResult({
                         commandId: command.id,
                         type: 'chunk',
-                        seq: this.chunkSeq++,
                         content: '\n\n',
                         timestamp: Date.now(),
                     });
                 }
-                // API keys don't expire — ensureFreshToken is a no-op for api-key source
+                // Refresh OAuth token before each LLM call if needed
                 if (this.resolvedAuth) {
                     const refreshed = await (0, auto_detect_1.ensureFreshToken)(this.resolvedAuth);
+                    if (refreshed.expired) {
+                        console.error(chalk_1.default.red(`  [auth] Token refresh failed: ${refreshed.error}`));
+                        await this.options.mqttClient.publishResult({
+                            commandId: command.id,
+                            type: 'error',
+                            error: 'Your authentication token has expired or been revoked. Please re-authenticate by running `funolio-agent login` or `funolio-agent configure`.',
+                            timestamp: Date.now(),
+                        });
+                        break;
+                    }
                     if (refreshed.apiKey !== this.resolvedAuth.apiKey) {
                         this.resolvedAuth = refreshed;
                         this.updateToken(refreshed.apiKey);
                     }
                 }
+                // With OAuth auto-detection, all providers now use direct API calls
+                // with full tool support. The old CLI_PROVIDERS check is kept only
+                // for logging/diagnostics but no longer gates tool availability.
                 // Smart tool filtering: only send relevant tools to reduce token usage
-                const filteredTools = index_1.CLI_PROVIDERS.has(this.options.provider)
-                    ? this.toolDefinitions
-                    : (0, tool_filter_1.filterToolsForMessage)(this.toolDefinitions, this.builtinToolDefinitions, command.prompt);
-                if (!index_1.CLI_PROVIDERS.has(this.options.provider) && filteredTools.length < this.toolDefinitions.length) {
+                const filteredTools = (0, tool_filter_1.filterToolsForMessage)(this.toolDefinitions, this.builtinToolDefinitions, command.prompt);
+                if (filteredTools.length < this.toolDefinitions.length) {
                     console.log(chalk_1.default.gray(`  [tool-filter] ${filteredTools.length}/${this.toolDefinitions.length} tools selected`));
                 }
-                // Compress context before sending to LLM (Optimizations 3+4)
-                const compressedMessages = (0, context_compressor_1.compressContext)(messages, 40, 3, 200);
-                if (compressedMessages.length < messages.length) {
-                    console.log(chalk_1.default.gray(`  [context] Compressed ${messages.length} → ${compressedMessages.length} messages`));
-                }
                 let response;
                 try {
                     response = await llm.chat({
-                        messages: compressedMessages,
+                        messages,
                         system: systemPrompt,
                         stream: true,
                         tools: filteredTools,
@@ -804,7 +651,6 @@ TOOL EFFICIENCY RULES:
                             await this.options.mqttClient.publishResult({
                                 commandId: command.id,
                                 type: 'chunk',
-                                seq: this.chunkSeq++,
                                 content: chunk,
                                 timestamp: Date.now(),
                             });
@@ -819,76 +665,16 @@ TOOL EFFICIENCY RULES:
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'error',
-                            error: 'API authentication failed. Check your API key or run `funolio-agent configure` to update it.',
+                            error: 'API authentication failed. Your token may have expired — run `funolio-agent login` to refresh.',
                             timestamp: Date.now(),
                         });
                         break;
                     }
                     throw llmError;
                 }
-                // Reset inactivity timer after LLM response
-                lastActivityMs = Date.now();
                 // Track token usage across iterations
                 if (response.usage) {
                     totalTokensUsed += response.usage.inputTokens + response.usage.outputTokens;
-                    totalInputTokens += response.usage.inputTokens;
-                    totalOutputTokens += response.usage.outputTokens;
-                    totalCacheReadTokens += response.usage.cacheReadTokens || 0;
-                    totalCacheCreationTokens += response.usage.cacheCreationTokens || 0;
-                }
-                // Phase 1d: Check cumulative input token budget
-                if (totalInputTokens >= MAX_INPUT_TOKENS) {
-                    console.log(`[token-cap] Input token budget exceeded: ${totalInputTokens}/${MAX_INPUT_TOKENS} — triggering wind-down`);
-                    messages.push({
-                        role: 'user',
-                        content: '[System] Token budget exceeded. Stop using tools immediately. Summarize everything you have so far and provide your best answer now.',
-                    });
-                    try {
-                        const capResponse = await llm.chat({
-                            messages, system: systemPrompt, stream: true,
-                            onChunk: async (chunk) => {
-                                if (this.activeCommandId !== command.id)
-                                    return;
-                                await this.options.mqttClient.publishResult({ commandId: command.id, type: 'chunk', seq: this.chunkSeq++, content: chunk, timestamp: Date.now() });
-                            },
-                        });
-                        if (capResponse.usage) {
-                            totalTokensUsed += capResponse.usage.inputTokens + capResponse.usage.outputTokens;
-                            totalInputTokens += capResponse.usage.inputTokens;
-                            totalOutputTokens += capResponse.usage.outputTokens;
-                        }
-                    }
-                    catch (e) {
-                        console.error(`[token-cap] Wind-down LLM call failed: ${e.message}`);
-                    }
-                    break;
-                }
-                // Phase 1d: Check tool call hard cap
-                if (totalToolCalls >= MAX_TOOL_CALLS) {
-                    console.log(`[token-cap] Tool call cap exceeded: ${totalToolCalls}/${MAX_TOOL_CALLS} — triggering wind-down`);
-                    messages.push({
-                        role: 'user',
-                        content: '[System] Tool call limit reached. Stop using tools immediately. Summarize everything you have so far and provide your best answer now.',
-                    });
-                    try {
-                        const capResponse = await llm.chat({
-                            messages, system: systemPrompt, stream: true,
-                            onChunk: async (chunk) => {
-                                if (this.activeCommandId !== command.id)
-                                    return;
-                                await this.options.mqttClient.publishResult({ commandId: command.id, type: 'chunk', seq: this.chunkSeq++, content: chunk, timestamp: Date.now() });
-                            },
-                        });
-                        if (capResponse.usage) {
-                            totalTokensUsed += capResponse.usage.inputTokens + capResponse.usage.outputTokens;
-                            totalInputTokens += capResponse.usage.inputTokens;
-                            totalOutputTokens += capResponse.usage.outputTokens;
-                        }
-                    }
-                    catch (e) {
-                        console.error(`[token-cap] Wind-down LLM call failed: ${e.message}`);
-                    }
-                    break;
                 }
                 // If there are tool calls, publish them and continue the loop
                 if (response.toolCalls && response.toolCalls.length > 0) {
@@ -904,16 +690,13 @@ TOOL EFFICIENCY RULES:
                         const toolSummary = (0, approval_1.generateToolSummary)(toolCall.name, toolCall.arguments);
                         const toolLocation = extractToolLocation(toolCall.name, toolCall.arguments, commandToolContext.projectDir);
                         // Check permission before execution
-                        const permMode = index_1.CLI_PROVIDERS.has(this.options.provider)
-                            ? 'autopilot'
-                            : (this.options.permissionMode || 'autopilot');
-                        let approval = (0, approval_1.checkPermission)(toolCall.name, permMode, index_1.CLI_PROVIDERS.has(this.options.provider) ? undefined : this.options.enabledTools);
-                        // If tool was already denied once in this command, auto-deny without re-asking
-                        if (!approval.approved && deniedTools.has(toolCall.name)) {
-                            approval = { approved: false, reason: `Tool "${toolCall.name}" was already denied in this session.` };
-                        }
+                        const permMode = this.options.permissionMode || 'autopilot';
+                        const allowedToolNames = this.options.enabledTools !== undefined || this.options.enabledMcpTools !== undefined
+                            ? [...(this.options.enabledTools || []), ...(this.options.enabledMcpTools || [])]
+                            : undefined;
+                        let approval = (0, approval_1.checkPermission)(toolCall.name, permMode, allowedToolNames);
                         // If not auto-approved, request interactive approval via MQTT
-                        if (!approval.approved && permMode !== 'autopilot' && !deniedTools.has(toolCall.name)) {
+                        if (!approval.approved && permMode !== 'autopilot') {
                             console.log(chalk_1.default.yellow(`  🔐 Requesting user approval for: ${toolCall.name}`));
                             approval = await this.approvalManager.requestApproval(command.id, toolCall.name, toolCall.arguments, {
                                 onRequest: async (request) => {
@@ -945,7 +728,6 @@ TOOL EFFICIENCY RULES:
                             }
                         }
                         if (!approval.approved) {
-                            deniedTools.add(toolCall.name);
                             console.log(chalk_1.default.yellow(`  ⚠ Tool denied: ${approval.reason}`));
                             const deniedOutput = `PERMISSION_DENIED: ${approval.reason}`;
                             await this.options.mqttClient.publishResult({
@@ -988,62 +770,20 @@ TOOL EFFICIENCY RULES:
                             },
                             timestamp: Date.now(),
                         });
-                        // Check retry budget before execution (Optimization 2)
-                        const retryBlock = checkRetryBudget(toolCall.name, toolCall.arguments);
-                        if (retryBlock) {
-                            console.log(chalk_1.default.yellow(`  ⚠ Retry budget exceeded for ${toolCall.name}`));
-                            const retryOutput = `ERROR: ${retryBlock}`;
-                            await this.options.mqttClient.publishResult({
-                                commandId: command.id,
-                                type: 'tool_result',
-                                toolResult: {
-                                    callId: toolCall.id,
-                                    name: toolCall.name,
-                                    output: retryOutput,
-                                    isError: true,
-                                    durationMs: 0,
-                                },
-                                timestamp: Date.now(),
-                            });
-                            messages.push({
-                                role: 'tool',
-                                content: retryOutput,
-                                toolCallId: toolCall.id,
-                                toolName: toolCall.name,
-                            });
-                            continue;
-                        }
                         // Execute the tool (with MCP fallback)
-                        const toolStartMs = Date.now();
                         const rawResult = await (0, tools_1.executeToolWithMCP)({ id: toolCall.id, name: toolCall.name, arguments: toolCall.arguments }, commandToolContext, this.options.mcpManager);
                         const toolResult = await (0, verification_1.verifyToolResult)(rawResult, toolCall.arguments, commandToolContext);
-                        let resultOutput = toolResult.success
+                        const resultOutput = toolResult.success
                             ? toolResult.output
                             : `ERROR: ${toolResult.error || 'Unknown error'}`;
-                        // Bug 2 & 7: Cap tool result size to prevent context blowup
-                        const MAX_TOOL_RESULT_CHARS = 50_000;
-                        if (resultOutput.length > MAX_TOOL_RESULT_CHARS) {
-                            const originalLength = resultOutput.length;
-                            resultOutput = resultOutput.slice(0, MAX_TOOL_RESULT_CHARS) +
-                                `\n\n[OUTPUT TRUNCATED — was ${originalLength} chars. Use more specific commands to read smaller portions.]`;
-                        }
-                        // Track failures for retry budget (Optimization 2)
-                        if (!toolResult.success) {
-                            trackToolFailure(toolCall.name, toolCall.arguments);
-                        }
                         console.log(chalk_1.default.gray(`    Result: ${toolResult.success ? '✓' : '✗'} ${resultOutput.slice(0, 100)}${resultOutput.length > 100 ? '...' : ''}`));
-                        const toolDurationMs = Date.now() - toolStartMs;
-                        totalToolCallDurationMs += toolDurationMs;
-                        lastActivityMs = Date.now(); // Reset inactivity timer after tool completion
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'tool_result',
                             toolResult: {
                                 callId: toolCall.id,
-                                name: toolCall.name,
                                 output: resultOutput,
                                 isError: !toolResult.success,
-                                durationMs: toolDurationMs,
                                 success: toolResult.success,
                                 summary: summarizeToolResult(resultOutput, !toolResult.success),
                                 path: toolLocation.path,
@@ -1061,32 +801,15 @@ TOOL EFFICIENCY RULES:
                             toolCallId: toolCall.id,
                             toolName: toolCall.name,
                         });
-                        // Futility detection: track consecutive low-value results
-                        if (isLowValueResult(resultOutput)) {
-                            consecutiveEmptyResults++;
-                        }
-                        else {
-                            consecutiveEmptyResults = 0; // reset on any meaningful result
-                        }
-                    }
-                    // Futility check: if too many consecutive empty results, nudge the LLM to stop spinning
-                    if (consecutiveEmptyResults >= FUTILITY_THRESHOLD && !futilityNudgeInjected) {
-                        futilityNudgeInjected = true;
-                        console.log(chalk_1.default.yellow(`  ⚠ Futility detected: ${consecutiveEmptyResults} consecutive low-value tool results — nudging LLM`));
-                        messages.push({
-                            role: 'user',
-                            content: '[System] Your last several tool calls returned empty or no-match results. Stop searching and work with what you have. Summarize what you found (or could not find) and suggest next steps to the user. Do not make more search attempts.',
-                        });
                     }
                     // --- Rate limit checks ---
                     // Warn at 80% of tool call limit
                     if (totalToolCalls >= this.maxToolCallsPerMessage * 0.8 && totalToolCalls < this.maxToolCallsPerMessage) {
                         console.log(chalk_1.default.yellow(`  ⚠ Approaching tool call limit: ${totalToolCalls}/${this.maxToolCallsPerMessage}`));
                     }
-                    // Log context window usage for monitoring (no artificial cap — let the LLM
-                    // provider return its own error if context exceeds the model's real limit)
-                    if (response.usage?.inputTokens) {
-                        console.log(chalk_1.default.gray(`  [tokens] iteration ${iteration}: ${response.usage.inputTokens} input, ${response.usage.outputTokens} output`));
+                    // Warn at 80% of token limit
+                    if (totalTokensUsed >= this.maxTokensPerMessage * 0.8 && totalTokensUsed < this.maxTokensPerMessage) {
+                        console.log(chalk_1.default.yellow(`  ⚠ Approaching token limit: ${totalTokensUsed}/${this.maxTokensPerMessage}`));
                     }
                     // Check tool call limit
                     if (totalToolCalls >= this.maxToolCallsPerMessage) {
@@ -1103,7 +826,6 @@ TOOL EFFICIENCY RULES:
                                 await this.options.mqttClient.publishResult({
                                     commandId: command.id,
                                     type: 'chunk',
-                                    seq: this.chunkSeq++,
                                     content: chunk,
                                     timestamp: Date.now(),
                                 });
@@ -1114,74 +836,55 @@ TOOL EFFICIENCY RULES:
                         }
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
-                            type: 'stats',
-                            llmCalls: iteration,
-                            toolsUsed: totalToolCalls,
-                            inputTokens: totalInputTokens,
-                            outputTokens: totalOutputTokens,
-                            cacheReadTokens: totalCacheReadTokens || undefined,
-                            cacheCreationTokens: totalCacheCreationTokens || undefined,
-                            totalTokens: totalTokensUsed,
-                            latencyMs: Date.now() - commandStartMs,
-                            toolCallDurationMs: totalToolCallDurationMs || undefined,
-                            contextSections: contextSectionCount || undefined,
-                            model,
+                            type: 'complete',
+                            content: '',
                             timestamp: Date.now(),
                         });
+                        console.log(chalk_1.default.green(`  Command completed: ${iteration} iterations, ${totalToolCalls} tool calls, ~${totalTokensUsed} tokens`));
+                        break;
+                    }
+                    // Check token limit
+                    if (totalTokensUsed >= this.maxTokensPerMessage) {
+                        console.log(chalk_1.default.red(`  🛑 Token limit reached: ${totalTokensUsed}/${this.maxTokensPerMessage}`));
+                        messages.push({ role: 'user', content: 'Token limit reached. Please summarize what you\'ve done so far.' });
+                        const summaryResponse = await llm.chat({
+                            messages,
+                            system: systemPrompt,
+                            stream: true,
+                            onChunk: async (chunk) => {
+                                if (this.activeCommandId !== command.id)
+                                    return;
+                                await this.options.mqttClient.publishResult({
+                                    commandId: command.id,
+                                    type: 'chunk',
+                                    content: chunk,
+                                    timestamp: Date.now(),
+                                });
+                            },
+                        });
+                        if (summaryResponse.usage) {
+                            totalTokensUsed += summaryResponse.usage.inputTokens + summaryResponse.usage.outputTokens;
+                        }
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'complete',
-                            content: response.content || '',
+                            content: '',
                             timestamp: Date.now(),
                         });
                         console.log(chalk_1.default.green(`  Command completed: ${iteration} iterations, ${totalToolCalls} tool calls, ~${totalTokensUsed} tokens`));
                         break;
                     }
-                    // No artificial token limit — LLM providers return proper errors (400/413)
-                    // when context exceeds the model's real limit, and those are caught by the
-                    // error handler above which surfaces them to the user.
                     // Continue the loop for the next LLM call
                     continue;
                 }
                 // No tool calls - final response.
-                // Phase 2a: The 'complete' message includes the full response content.
-                // The server-side relay (mqtt-agent-relay.ts) prefers this over
-                // reassembled chunks for higher-fidelity persistence.
-                // Fix 1: Detect phantom tool use — LLM claims it did something but made 0 tool calls
-                const phantom = (0, response_guard_1.detectPhantomToolUse)(response.content || '', totalToolCalls);
-                if (phantom.detected) {
-                    console.log(chalk_1.default.yellow(`  ⚠ Phantom tool use detected — injecting correction`));
-                    // Stream the correction to the user
-                    await this.options.mqttClient.publishResult({
-                        commandId: command.id,
-                        type: 'chunk',
-                        seq: this.chunkSeq++,
-                        content: '\n\n---\n⚠️ ' + phantom.correction,
-                        timestamp: Date.now(),
-                    });
-                }
-                // Publish stats before complete
-                const latencyMs = Date.now() - commandStartMs;
-                await this.options.mqttClient.publishResult({
-                    commandId: command.id,
-                    type: 'stats',
-                    llmCalls: iteration,
-                    toolsUsed: totalToolCalls,
-                    inputTokens: totalInputTokens,
-                    outputTokens: totalOutputTokens,
-                    cacheReadTokens: totalCacheReadTokens || undefined,
-                    cacheCreationTokens: totalCacheCreationTokens || undefined,
-                    totalTokens: totalTokensUsed,
-                    latencyMs,
-                    toolCallDurationMs: totalToolCallDurationMs || undefined,
-                    contextSections: contextSectionCount || undefined,
-                    model,
-                    timestamp: Date.now(),
-                });
+                // DEDUP FIX: Content was already streamed via onChunk callbacks above.
+                // The 'complete' message signals end-of-response; we send empty content
+                // to avoid the receiver concatenating streamed chunks + full content.
                 await this.options.mqttClient.publishResult({
                     commandId: command.id,
                     type: 'complete',
-                    content: response.content || '',
+                    content: '',
                     timestamp: Date.now(),
                 });
                 // Local-first: save assistant response to SQLite + trigger funnel
@@ -1189,6 +892,7 @@ TOOL EFFICIENCY RULES:
                     try {
                         const localData = await Promise.resolve().then(() => __importStar(require('./local-data')));
                         localData.addMessage(localConvId, 'assistant', response.content || '', model);
+                        // Trigger background memory extraction
                         (0, local_funnel_1.scheduleFunnelProcessing)(localConvId);
                         // Track for session idle auto-organize
                         this.lastOrganizedConvId = localConvId;
@@ -1200,6 +904,7 @@ TOOL EFFICIENCY RULES:
                     }
                 }
                 console.log(chalk_1.default.white(`  Response: ${response.content?.slice(0, 200)}${(response.content?.length || 0) > 200 ? '...' : ''}`));
+                const latencyMs = Date.now() - commandStartMs;
                 console.log(`[agent-metrics] commandId=${command.id} contextSections=${contextSectionCount} toolCallsMade=${totalToolCalls} iterations=${iteration} totalTokens=${totalTokensUsed} latencyMs=${latencyMs}`);
                 console.log(chalk_1.default.green(`  Command completed: ${iteration} iterations, ${totalToolCalls} tool calls, ~${totalTokensUsed} tokens`));
                 break;
@@ -1209,22 +914,7 @@ TOOL EFFICIENCY RULES:
             }
         }
         catch (error) {
-            // Capture detailed provider error info for diagnosis
-            const details = [`  ✗ Error: ${error.message}`];
-            if (error.status)
-                details.push(`  ✗ HTTP status: ${error.status}`);
-            if (error.type)
-                details.push(`  ✗ Error type: ${error.type}`);
-            if (error.response?.body)
-                details.push(`  ✗ Response body: ${JSON.stringify(error.response.body).slice(0, 500)}`);
-            if (error.error?.type)
-                details.push(`  ✗ Provider error type: ${error.error.type}`);
-            if (error.cause)
-                details.push(`  ✗ Cause: ${error.cause}`);
-            // For Anthropic "terminated" / stop_reason issues
-            if (error.stop_reason)
-                details.push(`  ✗ Stop reason: ${error.stop_reason}`);
-            details.forEach(d => console.error(chalk_1.default.red(d)));
+            console.error(chalk_1.default.red(`  ✗ Error: ${error.message}`));
             await this.publishError(command.id, error.message);
         }
         finally {
@@ -1246,31 +936,10 @@ TOOL EFFICIENCY RULES:
     }
     /** Build system prompt manually (without clerk) — original logic */
     buildFallbackSystemPrompt(command) {
-        let systemPrompt = (0, prompt_template_1.buildDefaultSystemPrompt)({
-            botName: this.options.agentName,
-            model: this.options.model,
-            soulMd: command.context?.soulMd || this.options.systemPrompt,
-        });
-        // Auto-enumerate available tools so the bot always knows its capabilities
-        const toolDefs = (0, index_2.getToolDefinitions)();
-        const toolList = toolDefs.map(t => `- **${t.name}**: ${t.description.slice(0, 120)}`).join('\n');
-        systemPrompt += `\n\n## Your Available Tools\nYou have ${toolDefs.length} tools available. Use them proactively:\n${toolList}`;
-        systemPrompt += `\n\n## Working Style
-- You are autonomous — take action, don't just describe what you could do.
-- For complex tasks, use spawn_subagent to parallelize work.
-- Read project files to understand context before making changes.
-- Commit your work with git_commit when you've made meaningful progress.
-- Use web_search and web_fetch to research unfamiliar topics.
-- Write important context to files so you remember it across sessions.
-- If you're unsure about something destructive, ask first. Otherwise, just do it.`;
-        // Platform awareness — always present regardless of soulMd content
-        systemPrompt += `\n\n## Extending Your Capabilities
-- You have built-in tools (file ops, shell, git, web search, web fetch, tasks, sub-agents, memory search).
-- If the user asks you to do something you don't have a tool for (e.g. Google Drive, GitHub issues, Slack, email, databases), search the Funolio marketplace with \`search_marketplace\`.
-- If a matching MCP tool server exists, use \`request_mcp_install\` to request permission to install it.
-- You can discover and gain new capabilities on-the-fly through the marketplace.
-- **NEVER tell the user to "do it manually" or "upload it yourself"** — always check the marketplace first and offer to install the right tool.`;
-        systemPrompt += '\n\nIMPORTANT: When the user references a project, topic, or past work, use the relevant summaries and conversation history provided below. If no relevant context is available, say so honestly rather than guessing. Use your tools (file browsing, commands) to find project files on the local machine.';
+        let systemPrompt = command.context?.soulMd
+            || this.options.systemPrompt
+            || 'You are a Funolio AI agent running locally on the user\'s machine. You have access to their project files and can execute code.';
+        systemPrompt += '\n\nIMPORTANT: When the user references a project, topic, or past work, use the relevant memory/facts provided below. If no relevant facts are available, say so honestly rather than guessing. Use your tools (file browsing, commands) to find project files on the local machine.';
         systemPrompt += '\n\nIMPORTANT: If a Workspace Manifest or Recent Operational State section is present, use it before repeating discovery work. Check known local files and directories before fetching from external sources. Do not re-fetch from Drive, GitHub, or the web if the state context shows the artifact is already local unless the user explicitly asks for a fresh external copy.';
         systemPrompt += '\n\nDo not end with a deferred promise (for example: "Let me check..."). Return a final answer in this turn, or state exactly what is unavailable.';
         systemPrompt += '\n\n' + (0, clerk_model_1.buildTodoInstructions)(this.options.agentName || 'LLM');
@@ -1293,7 +962,13 @@ When a user asks to "use Opus" or "switch to GPT-4o", identify the right model I
             systemPrompt += '\n\n[Bot Memory]\n' + command.context.memoryMd;
         }
         const sc = command.context?.structuredContext;
-        if (sc && (sc.codeRefs?.length || sc.conversations?.length)) {
+        if (sc && (sc.decisions?.length || sc.memoryFacts?.length || sc.codeRefs?.length || sc.conversations?.length)) {
+            if (sc.decisions?.length) {
+                systemPrompt += '\n\n[Key Decisions]\n' + sc.decisions.map(d => `- ${d}`).join('\n');
+            }
+            if (sc.memoryFacts?.length) {
+                systemPrompt += '\n\n[Memory Facts]\n' + sc.memoryFacts.map(f => `- ${f}`).join('\n');
+            }
             if (sc.conversations?.length) {
                 systemPrompt += '\n\n[Relevant Conversations]\n' + sc.conversations.map(c => `- ${c}`).join('\n');
             }
@@ -1301,8 +976,11 @@ When a user asks to "use Opus" or "switch to GPT-4o", identify the right model I
                 systemPrompt += '\n\n[Code References]\n' + sc.codeRefs.map(r => `- ${r}`).join('\n');
             }
         }
+        else if (command.context?.facts?.length) {
+            systemPrompt += '\n\nRelevant memory/facts from the user\'s stored conversations:\n' + command.context.facts.map(f => `- ${f}`).join('\n');
+        }
         else {
-            systemPrompt += '\n\nNo relevant stored summaries were found for this query. If the user is asking about a specific project or past work, let them know you don\'t have stored context about it and offer to search their local files instead.';
+            systemPrompt += '\n\nNo relevant memories were found for this query. If the user is asking about a specific project or past work, let them know you don\'t have stored context about it and offer to search their local files instead.';
         }
         if (command.context?.files?.length) {
             systemPrompt += '\n\nRelevant files: ' + command.context.files.join(', ');
@@ -1345,18 +1023,19 @@ When a user asks to "use Opus" or "switch to GPT-4o", identify the right model I
             timestamp: Date.now(),
         });
     }
-    /** Update the API key used for requests */
+    /** Update the OAuth token used for requests (called by token refresh) */
     updateToken(token) {
-        this.options.apiKey = token;
+        this.options.oauthToken = token;
+        // Recreate the default provider with the new token
         const effectiveProvider = this.options.provider;
-        const authMode = this.options.authMode || (token.startsWith('sk-ant-oat') ? 'oauth-bearer' : 'api-key');
         this.llmProvider = (0, index_1.createProvider)(effectiveProvider, {
             apiKey: token,
             model: this.options.model,
-            authMode,
-            ...(this.options.baseUrl ? { baseUrl: this.options.baseUrl } : {}),
-            ...(this.options.apiStyle ? { apiStyle: this.options.apiStyle } : {}),
+            ...(token.startsWith('sk-ant-oat01-') ? { authMode: 'oauth-bearer' } : {}),
         });
+        if (token.startsWith('sk-ant-oat01-') && effectiveProvider === 'anthropic') {
+            this.resolveAndUpgradeAuth(token, this.options.model);
+        }
     }
 }
 exports.MessageLoop = MessageLoop;