funolio-agent 1.0.7 → 1.0.47

package/dist/message-loop.js

@@ -48,16 +48,14 @@ const local_db_1 = require("./local-db");
 const config_1 = require("./config");
 const auto_detect_1 = require("./auth/auto-detect");
 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 data = __importStar(require("./local-data"));
-const agent_config_1 = require("./agent-config");
-const subscription_runtime_1 = require("./auth/subscription-runtime");
 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)
@@ -72,11 +70,53 @@ function getCommandPriority(command) {
     return 'medium';
 }
 const PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
+function classifyToolName(toolName) {
+    switch (toolName) {
+        case 'read_file':
+            return 'file_read';
+        case 'list_directory':
+            return 'directory_scan';
+        case 'write_file':
+        case 'edit_file':
+            return 'file_write';
+        case 'run_command':
+        case 'git_status':
+        case 'git_diff':
+        case 'git_commit':
+            return 'command_run';
+        case 'web_fetch':
+            return 'web_fetch';
+        default:
+            return 'workspace_hint';
+    }
+}
+function extractToolLocation(toolName, args, projectDir) {
+    const path = typeof args.path === 'string'
+        ? args.path
+        : typeof args.filePath === 'string'
+            ? args.filePath
+            : typeof args.directory === 'string'
+                ? args.directory
+                : undefined;
+    const cwd = typeof args.cwd === 'string'
+        ? args.cwd
+        : toolName === 'run_command' || toolName.startsWith('git_')
+            ? projectDir
+            : undefined;
+    const url = typeof args.url === 'string' ? args.url : undefined;
+    return { path, cwd, url };
+}
+function summarizeToolResult(output, isError) {
+    const prefix = isError ? 'Tool failed: ' : 'Tool completed: ';
+    const compact = output.replace(/\s+/g, ' ').trim();
+    return `${prefix}${compact}`.slice(0, 240);
+}
 class MessageLoop {
     options;
     llmProvider;
     activeCommandId = null;
     activeCommandSource = null;
+    chunkSeq = 0;
     toolContext;
     toolDefinitions;
     builtinToolDefinitions;
@@ -97,34 +137,31 @@ class MessageLoop {
     static SCHEDULED_TASK_TIMEOUT_MS = 5 * 60 * 1000;
     scheduledTaskTimer = null;
     static IDLE_THRESHOLD_MS = 15 * 60 * 1000; // 15 minutes
-    static SERVER_SYNC_RETRY_MAX = 1;
     constructor(options) {
         this.options = options;
-        // DO NOT remap Claude CLI OAuth sessions to the public Anthropic runtime
-        // without explicit user approval.
-        const effectiveKey = options.oauthToken || options.apiKey || '';
+        const effectiveKey = options.apiKey || '';
         const effectiveProvider = options.provider;
-        const isOAuthToken = effectiveKey.startsWith('sk-ant-oat01-');
+        const llmAuthMode = options.authMode || (effectiveKey.startsWith('sk-ant-oat') ? 'oauth-bearer' : 'api-key');
         this.llmProvider = (0, index_1.createProvider)(effectiveProvider, {
             apiKey: effectiveKey,
             model: options.model,
-            ...(isOAuthToken ? { authMode: 'oauth-bearer' } : {}),
+            authMode: llmAuthMode,
+            ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
+            ...(options.apiStyle ? { apiStyle: options.apiStyle } : {}),
         });
-        // Async: attempt to resolve Anthropic subscription auth (create_api_key exchange)
-        if (isOAuthToken && effectiveProvider === 'anthropic') {
-            this.resolveAndUpgradeAuth(effectiveKey, options.model);
-        }
         // 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);
         this.toolContext = (0, index_2.createToolContext)(options.projectDir, {
             actorType: 'llm',
             actorId: options.agentName || options.userId,
             llmProvider: effectiveProvider,
             llmModel: options.model,
             llmApiKey: effectiveKey,
-            llmAuthMode: isOAuthToken ? 'oauth-bearer' : 'api-key',
+            llmAuthMode,
+            restrictFileAccessToProject: unrestrictedCliProvider ? false : undefined,
             apiKey: funoliApiKey,
             apiBaseUrl: funoliApiBaseUrl,
             botName: options.agentName || 'funolio-agent',
@@ -132,7 +169,7 @@ class MessageLoop {
         let allTools = (0, index_2.getAllToolDefinitions)(options.mcpManager);
         let builtinTools = (0, index_2.getToolDefinitions)();
         // Filter tools by enabledTools whitelist if specified
-        if (options.enabledTools && options.enabledTools.length > 0) {
+        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));
@@ -161,147 +198,6 @@ class MessageLoop {
         // 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 runtime = await (0, subscription_runtime_1.resolveClaudeSubscriptionRuntime)({
-                preferredModel: model,
-                inputCredential: {
-                    provider: 'anthropic',
-                    accessToken: oauthToken,
-                    refreshToken: this.options.resolvedAuth?.credential?.refreshToken || '',
-                    expiresAt: this.options.resolvedAuth?.credential?.expiresAt || 0,
-                },
-                inputSource: 'request:anthropic',
-                persistInputCredential: true,
-            });
-            if (!runtime)
-                return;
-            if (this.options.resolvedAuth?.credential && runtime.authMode === 'oauth-bearer') {
-                this.options.resolvedAuth.credential.accessToken = runtime.apiKey;
-            }
-            if (this.resolvedAuth?.credential && runtime.authMode === 'oauth-bearer') {
-                this.resolvedAuth.credential.accessToken = runtime.apiKey;
-                this.resolvedAuth.apiKey = runtime.apiKey;
-            }
-            if (runtime.authMode !== 'oauth-bearer') {
-                // 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: runtime.apiKey,
-                    model,
-                });
-            }
-            else {
-                // Bearer fallback — recreate provider with the (possibly refreshed) token
-                const currentToken = runtime.apiKey || 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);
-        }
-    }
-    async syncOAuthFromServer(reason) {
-        const providerId = this.options.provider;
-        if (!providerId || providerId.endsWith('-cli'))
-            return false;
-        const cfg = (0, config_1.loadConfig)();
-        const authToken = cfg.auth?.token;
-        if (!authToken)
-            return false;
-        try {
-            const res = await fetch(`${config_1.FUNOLIO_API_URL}/api/v1/agent/config`, {
-                headers: { Authorization: `Bearer ${authToken}` },
-            });
-            if (!res.ok)
-                return false;
-            const body = await res.json();
-            const provider = (body.providers || []).find((p) => p.id === providerId && p.connectionType === 'oauth');
-            if (!provider?.access_token)
-                return false;
-            const currentAccess = this.resolvedAuth?.credential?.accessToken || this.options.oauthToken || '';
-            const currentRefresh = this.resolvedAuth?.credential?.refreshToken || this.options.resolvedAuth?.credential?.refreshToken || '';
-            const currentExpiry = this.resolvedAuth?.credential?.expiresAt || this.options.resolvedAuth?.credential?.expiresAt || 0;
-            const nextExpiry = provider.expires_at || 0;
-            const changed = provider.access_token !== currentAccess
-                || (provider.refresh_token || '') !== currentRefresh
-                || nextExpiry > currentExpiry;
-            if (!changed)
-                return false;
-            if (this.resolvedAuth) {
-                this.resolvedAuth.apiKey = provider.access_token;
-                this.resolvedAuth.expired = false;
-                this.resolvedAuth.error = undefined;
-                if (this.resolvedAuth.credential) {
-                    this.resolvedAuth.credential.accessToken = provider.access_token;
-                    if (provider.refresh_token)
-                        this.resolvedAuth.credential.refreshToken = provider.refresh_token;
-                    if (provider.expires_at)
-                        this.resolvedAuth.credential.expiresAt = provider.expires_at;
-                }
-            }
-            if (this.options.resolvedAuth) {
-                this.options.resolvedAuth.apiKey = provider.access_token;
-                this.options.resolvedAuth.expired = false;
-                this.options.resolvedAuth.error = undefined;
-                if (this.options.resolvedAuth.credential) {
-                    this.options.resolvedAuth.credential.accessToken = provider.access_token;
-                    if (provider.refresh_token)
-                        this.options.resolvedAuth.credential.refreshToken = provider.refresh_token;
-                    if (provider.expires_at)
-                        this.options.resolvedAuth.credential.expiresAt = provider.expires_at;
-                }
-            }
-            this.options.oauthToken = provider.access_token;
-            const local = (0, config_1.loadConfig)();
-            if (!local.providers)
-                local.providers = [];
-            const idx = local.providers.findIndex((p) => p.id === providerId);
-            if (idx >= 0) {
-                local.providers[idx].authType = 'oauth';
-                local.providers[idx].oauthToken = provider.access_token;
-                if (provider.refresh_token)
-                    local.providers[idx].oauthRefreshToken = provider.refresh_token;
-                if (provider.expires_at)
-                    local.providers[idx].oauthExpiresAt = provider.expires_at;
-                if (provider.defaultModel)
-                    local.providers[idx].defaultModel = provider.defaultModel;
-            }
-            (0, config_1.saveConfig)(local);
-            if (this.options.agentName) {
-                const agentLocal = (0, agent_config_1.loadAgentConfig)(this.options.agentName);
-                if (agentLocal && agentLocal.provider === providerId) {
-                    agentLocal.oauthToken = provider.access_token;
-                    if (provider.refresh_token)
-                        agentLocal.oauthRefreshToken = provider.refresh_token;
-                    if (provider.expires_at)
-                        agentLocal.oauthExpiresAt = provider.expires_at;
-                    if (provider.defaultModel)
-                        agentLocal.model = provider.defaultModel;
-                    (0, agent_config_1.saveAgentConfig)(this.options.agentName, agentLocal);
-                }
-            }
-            this.updateToken(provider.access_token);
-            console.log(chalk_1.default.green(`  [auth] Synced updated ${providerId} OAuth credentials from server (${reason})`));
-            return true;
-        }
-        catch (err) {
-            console.log(chalk_1.default.gray(`  [auth] Server OAuth sync skipped (${reason}): ${err?.message || err}`));
-            return false;
-        }
-    }
     /** Check if a session has gone idle and trigger auto-organize */
     async checkIdleSession() {
         if (!this.lastMessageAt || !(0, auto_organizer_1.isAutoOrganizeEnabled)())
@@ -419,48 +315,19 @@ class MessageLoop {
         const overrideModel = command.model?.model;
         let provider = overrideProvider || this.options.provider;
         const model = overrideModel || this.options.model;
-        const apiKey = this.options.oauthToken || this.options.apiKey;
+        const apiKey = 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) {
-            // For overrides with OAuth tokens, try subscription auth resolution
-            if ((apiKey || '').startsWith('sk-ant-oat01-') && provider === 'anthropic') {
-                try {
-                    const runtime = await (0, subscription_runtime_1.resolveClaudeSubscriptionRuntime)({
-                        preferredModel: model,
-                        inputCredential: {
-                            provider: 'anthropic',
-                            accessToken: apiKey,
-                            refreshToken: this.options.resolvedAuth?.credential?.refreshToken || '',
-                            expiresAt: this.options.resolvedAuth?.credential?.expiresAt || 0,
-                        },
-                        inputSource: 'request:anthropic',
-                        persistInputCredential: true,
-                    });
-                    const resolvedKey = runtime?.apiKey || apiKey;
-                    const authMode = runtime?.authMode;
-                    if (this.options.resolvedAuth?.credential && authMode === 'oauth-bearer') {
-                        this.options.resolvedAuth.credential.accessToken = resolvedKey;
-                    }
-                    if (this.resolvedAuth?.credential && authMode === 'oauth-bearer') {
-                        this.resolvedAuth.credential.accessToken = resolvedKey;
-                        this.resolvedAuth.apiKey = resolvedKey;
-                    }
-                    llm = (0, index_1.createProvider)(provider, {
-                        apiKey: resolvedKey,
-                        model,
-                        ...(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 });
-            }
+            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 } : {}),
+            });
         }
         else {
             llm = this.llmProvider;
@@ -478,6 +345,7 @@ class MessageLoop {
         }
         this.activeCommandId = command.id;
         this.activeCommandSource = command.source || 'user';
+        this.chunkSeq = 0;
         this.processing = true;
         this.lastMessageAt = Date.now();
         const commandStartMs = Date.now();
@@ -545,6 +413,8 @@ class MessageLoop {
                 ...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
@@ -583,27 +453,33 @@ 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),
                         });
-                        // Save O's response to local DB
+                        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, undefined, undefined, activeProfile.id, 'Project Manager');
+                            localData.addMessage(localConvId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
                         }
                         // 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: '',
+                            content: response || '',
                             timestamp: Date.now(),
                         });
                     }
@@ -648,7 +524,7 @@ class MessageLoop {
                             includeKeyDecisions: false,
                         });
                         systemPrompt = built.systemPrompt;
-                        console.log(chalk_1.default.gray(`  [clerk] Context: ${built.injectedFacts} facts, ${built.injectedDecisions} decisions, ${built.injectedSummaries} summaries (${built.contextTokensUsed} tokens)`));
+                        console.log(chalk_1.default.gray(`  [clerk] Context: ${built.injectedSummaries} summaries (${built.contextTokensUsed} tokens)`));
                     }
                     else {
                         systemPrompt = this.buildFallbackSystemPrompt(command);
@@ -667,12 +543,12 @@ class MessageLoop {
                 systemPrompt += deadServerNote;
             }
             systemPrompt += `\n\nCONTEXT PRIORITY RULES:
-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.
+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.
 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 decisions..." or "From your conversation history...").
+3. When you use provided context, briefly cite the source (e.g. "Based on your stored summary..." 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:
@@ -680,7 +556,7 @@ 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 = ['[Key Decisions]', '[Memory Facts]', '[Relevant Conversations]', '[Code References]', '[Relevant Files]', '[Bot Memory]', '[Retrieved Context]']
+            const contextSectionCount = ['[Relevant Conversations]', '[Code References]', '[Relevant Files]', '[Bot Memory]', '[Retrieved Context]', '[Summaries]']
                 .filter(header => systemPrompt.includes(header)).length;
             // Add the current prompt (with image attachments if present)
             if (command.attachments && command.attachments.length > 0) {
@@ -717,15 +593,40 @@ TOOL EFFICIENCY RULES:
                 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 = `${name}:${getArgsHash(args)}`;
+                const key = `${getRetryKey(name, args)}:${getArgsHash(args)}`;
+                const retryKey = getRetryKey(name, args);
                 toolFailuresByKey.set(key, (toolFailuresByKey.get(key) || 0) + 1);
-                toolFailuresByName.set(name, (toolFailuresByName.get(name) || 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 = `${name}:${getArgsHash(args)}`;
+                const key = `${getRetryKey(name, args)}:${getArgsHash(args)}`;
+                const retryKey = getRetryKey(name, args);
                 const keyCount = toolFailuresByKey.get(key) || 0;
-                const nameCount = toolFailuresByName.get(name) || 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.`;
                 }
@@ -736,15 +637,20 @@ TOOL EFFICIENCY RULES:
             }
             // Agentic loop - keep calling LLM until no more tool calls
             let iteration = 0;
-            const MAX_ITERATIONS = 100;
-            const GLOBAL_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes wall-clock timeout
+            // 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();
             let totalTokensUsed = 0;
             let totalInputTokens = 0;
             let totalOutputTokens = 0;
             let totalCacheReadTokens = 0;
             let totalCacheCreationTokens = 0;
             let totalToolCallDurationMs = 0;
-            let serverSyncRetries = 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
@@ -765,16 +671,93 @@ TOOL EFFICIENCY RULES:
             catch { }
             while (iteration < MAX_ITERATIONS && this.activeCommandId === command.id) {
                 iteration++;
-                // Global wall-clock timeout check
-                if (Date.now() - commandStartMs > GLOBAL_TIMEOUT_MS) {
-                    console.log(chalk_1.default.red(`  ⏱ Global timeout exceeded (${GLOBAL_TIMEOUT_MS / 1000}s) — breaking out of loop`));
+                // Emit progress every 60 seconds
+                if (Date.now() - lastProgressMs >= 60_000) {
+                    lastProgressMs = Date.now();
                     await this.options.mqttClient.publishResult({
                         commandId: command.id,
-                        type: 'error',
-                        error: `Command execution exceeded the ${GLOBAL_TIMEOUT_MS / 60000} minute global timeout limit.`,
+                        type: 'progress',
+                        elapsed: Math.round((Date.now() - commandStartMs) / 1000),
+                        iteration,
+                        toolsUsed: totalToolCalls,
                         timestamp: Date.now(),
                     });
-                    commandAbortController.abort();
+                }
+                // 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
@@ -783,41 +766,24 @@ TOOL EFFICIENCY RULES:
                     await this.options.mqttClient.publishResult({
                         commandId: command.id,
                         type: 'chunk',
+                        seq: this.chunkSeq++,
                         content: '\n\n',
                         timestamp: Date.now(),
                     });
                 }
-                // Refresh OAuth token before each LLM call if needed
+                // API keys don't expire — ensureFreshToken is a no-op for api-key source
                 if (this.resolvedAuth) {
                     const refreshed = await (0, auto_detect_1.ensureFreshToken)(this.resolvedAuth);
-                    if (refreshed.expired) {
-                        if (serverSyncRetries < MessageLoop.SERVER_SYNC_RETRY_MAX) {
-                            const synced = await this.syncOAuthFromServer('refresh-failed');
-                            if (synced) {
-                                serverSyncRetries++;
-                                continue;
-                            }
-                        }
-                        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 = (0, tool_filter_1.filterToolsForMessage)(this.toolDefinitions, this.builtinToolDefinitions, command.prompt);
-                if (filteredTools.length < this.toolDefinitions.length) {
+                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) {
                     console.log(chalk_1.default.gray(`  [tool-filter] ${filteredTools.length}/${this.toolDefinitions.length} tools selected`));
                 }
                 // Compress context before sending to LLM (Optimizations 3+4)
@@ -838,6 +804,7 @@ TOOL EFFICIENCY RULES:
                             await this.options.mqttClient.publishResult({
                                 commandId: command.id,
                                 type: 'chunk',
+                                seq: this.chunkSeq++,
                                 content: chunk,
                                 timestamp: Date.now(),
                             });
@@ -848,26 +815,19 @@ TOOL EFFICIENCY RULES:
                     const msg = llmError?.message || String(llmError);
                     const isAuthError = /401|403|unauthorized|forbidden|authentication/i.test(msg);
                     if (isAuthError) {
-                        if (serverSyncRetries < MessageLoop.SERVER_SYNC_RETRY_MAX) {
-                            const synced = await this.syncOAuthFromServer('llm-auth-error');
-                            if (synced) {
-                                serverSyncRetries++;
-                                continue;
-                            }
-                        }
                         console.error(chalk_1.default.red(`  [auth] LLM API authentication failed: ${msg}`));
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'error',
-                            error: 'API authentication failed. Your token may have expired — run `funolio-agent login` to refresh.',
+                            error: 'API authentication failed. Check your API key or run `funolio-agent configure` to update it.',
                             timestamp: Date.now(),
                         });
                         break;
                     }
                     throw llmError;
                 }
-                // Any successful provider response clears one-shot sync retry budget
-                serverSyncRetries = 0;
+                // Reset inactivity timer after LLM response
+                lastActivityMs = Date.now();
                 // Track token usage across iterations
                 if (response.usage) {
                     totalTokensUsed += response.usage.inputTokens + response.usage.outputTokens;
@@ -876,6 +836,60 @@ TOOL EFFICIENCY RULES:
                     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) {
                     // Add assistant message with tool calls to history
@@ -887,9 +901,13 @@ TOOL EFFICIENCY RULES:
                     for (const toolCall of response.toolCalls) {
                         totalToolCalls++;
                         console.log(chalk_1.default.cyan(`  🔧 Tool: ${toolCall.name}(${JSON.stringify(toolCall.arguments).slice(0, 60)}...)`));
+                        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 = this.options.permissionMode || 'autopilot';
-                        let approval = (0, approval_1.checkPermission)(toolCall.name, permMode, this.options.enabledTools);
+                        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.` };
@@ -897,20 +915,29 @@ TOOL EFFICIENCY RULES:
                         // If not auto-approved, request interactive approval via MQTT
                         if (!approval.approved && permMode !== 'autopilot' && !deniedTools.has(toolCall.name)) {
                             console.log(chalk_1.default.yellow(`  🔐 Requesting user approval for: ${toolCall.name}`));
-                            // Generate requestId up front so the MQTT result and pending map use the same ID
-                            const approvalRequestId = require('crypto').randomUUID();
-                            await this.options.mqttClient.publishResult({
-                                commandId: command.id,
-                                type: 'approval_request',
-                                requestId: approvalRequestId,
-                                toolCall: {
-                                    id: toolCall.id,
-                                    name: toolCall.name,
-                                    arguments: toolCall.arguments,
+                            approval = await this.approvalManager.requestApproval(command.id, toolCall.name, toolCall.arguments, {
+                                onRequest: async (request) => {
+                                    await this.options.mqttClient.publishResult({
+                                        commandId: command.id,
+                                        type: 'approval_request',
+                                        requestId: request.requestId,
+                                        riskLevel: request.riskLevel,
+                                        summary: request.summary,
+                                        toolCall: {
+                                            id: toolCall.id,
+                                            name: toolCall.name,
+                                            arguments: toolCall.arguments,
+                                            classification: classifyToolName(toolCall.name),
+                                            summary: toolSummary,
+                                            path: toolLocation.path,
+                                            cwd: toolLocation.cwd,
+                                            url: toolLocation.url,
+                                            importance: request.riskLevel === 'destructive' ? 'high' : 'medium',
+                                        },
+                                        timestamp: Date.now(),
+                                    });
                                 },
-                                timestamp: Date.now(),
                             });
-                            approval = await this.approvalManager.requestApproval(command.id, toolCall.name, toolCall.arguments);
                             // If user chose "always allow", persist it
                             if (approval.approved && approval.remember) {
                                 (0, approval_1.rememberTool)(toolCall.name);
@@ -920,19 +947,26 @@ 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({
                                 commandId: command.id,
                                 type: 'tool_result',
                                 toolResult: {
                                     callId: toolCall.id,
-                                    output: `PERMISSION_DENIED: ${approval.reason}`,
+                                    output: deniedOutput,
                                     isError: true,
+                                    success: false,
+                                    summary: summarizeToolResult(deniedOutput, true),
+                                    path: toolLocation.path,
+                                    cwd: toolLocation.cwd,
+                                    url: toolLocation.url,
+                                    pathsTouched: toolLocation.path ? [toolLocation.path] : [],
                                 },
                                 timestamp: Date.now(),
                             });
                             messages.push({
                                 role: 'tool',
-                                content: `PERMISSION_DENIED: ${approval.reason}`,
+                                content: deniedOutput,
                                 toolCallId: toolCall.id,
                                 toolName: toolCall.name,
                             });
@@ -945,6 +979,12 @@ TOOL EFFICIENCY RULES:
                                 id: toolCall.id,
                                 name: toolCall.name,
                                 arguments: toolCall.arguments,
+                                classification: classifyToolName(toolCall.name),
+                                summary: toolSummary,
+                                path: toolLocation.path,
+                                cwd: toolLocation.cwd,
+                                url: toolLocation.url,
+                                importance: (0, approval_1.getRiskLevel)(toolCall.name) === 'destructive' ? 'high' : 'medium',
                             },
                             timestamp: Date.now(),
                         });
@@ -977,9 +1017,16 @@ TOOL EFFICIENCY RULES:
                         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);
-                        const resultOutput = toolResult.success
+                        let 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);
@@ -987,6 +1034,7 @@ TOOL EFFICIENCY RULES:
                         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',
@@ -996,6 +1044,13 @@ TOOL EFFICIENCY RULES:
                                 output: resultOutput,
                                 isError: !toolResult.success,
                                 durationMs: toolDurationMs,
+                                success: toolResult.success,
+                                summary: summarizeToolResult(resultOutput, !toolResult.success),
+                                path: toolLocation.path,
+                                cwd: toolLocation.cwd,
+                                url: toolLocation.url,
+                                pathsTouched: toolLocation.path ? [toolLocation.path] : [],
+                                exitCode: typeof toolResult.exit_code === 'number' ? toolResult.exit_code : undefined,
                             },
                             timestamp: Date.now(),
                         });
@@ -1006,6 +1061,22 @@ 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
@@ -1032,6 +1103,7 @@ TOOL EFFICIENCY RULES:
                                 await this.options.mqttClient.publishResult({
                                     commandId: command.id,
                                     type: 'chunk',
+                                    seq: this.chunkSeq++,
                                     content: chunk,
                                     timestamp: Date.now(),
                                 });
@@ -1059,7 +1131,7 @@ TOOL EFFICIENCY RULES:
                         await this.options.mqttClient.publishResult({
                             commandId: command.id,
                             type: 'complete',
-                            content: '',
+                            content: response.content || '',
                             timestamp: Date.now(),
                         });
                         console.log(chalk_1.default.green(`  Command completed: ${iteration} iterations, ${totalToolCalls} tool calls, ~${totalTokensUsed} tokens`));
@@ -1072,9 +1144,9 @@ TOOL EFFICIENCY RULES:
                     continue;
                 }
                 // No tool calls - final response.
-                // 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.
+                // 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) {
@@ -1083,6 +1155,7 @@ TOOL EFFICIENCY RULES:
                     await this.options.mqttClient.publishResult({
                         commandId: command.id,
                         type: 'chunk',
+                        seq: this.chunkSeq++,
                         content: '\n\n---\n⚠️ ' + phantom.correction,
                         timestamp: Date.now(),
                     });
@@ -1108,7 +1181,7 @@ TOOL EFFICIENCY RULES:
                 await this.options.mqttClient.publishResult({
                     commandId: command.id,
                     type: 'complete',
-                    content: '',
+                    content: response.content || '',
                     timestamp: Date.now(),
                 });
                 // Local-first: save assistant response to SQLite + trigger funnel
@@ -1116,7 +1189,6 @@ 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;
@@ -1137,7 +1209,22 @@ TOOL EFFICIENCY RULES:
             }
         }
         catch (error) {
-            console.error(chalk_1.default.red(`  ✗ Error: ${error.message}`));
+            // 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)));
             await this.publishError(command.id, error.message);
         }
         finally {
@@ -1183,7 +1270,8 @@ TOOL EFFICIENCY RULES:
 - 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 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: 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.';
+        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');
         // Inject model self-switch info
@@ -1205,13 +1293,7 @@ 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.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 && (sc.codeRefs?.length || sc.conversations?.length)) {
             if (sc.conversations?.length) {
                 systemPrompt += '\n\n[Relevant Conversations]\n' + sc.conversations.map(c => `- ${c}`).join('\n');
             }
@@ -1219,15 +1301,38 @@ 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 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.';
+            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.';
         }
         if (command.context?.files?.length) {
             systemPrompt += '\n\nRelevant files: ' + command.context.files.join(', ');
         }
+        if (command.context?.stateContext?.summaryText) {
+            systemPrompt += '\n\n[Recent Operational State]\n' + command.context.stateContext.summaryText;
+        }
+        if (command.context?.workspaceManifest) {
+            const manifestLines = [];
+            const manifest = command.context.workspaceManifest;
+            if (manifest.projectRoot)
+                manifestLines.push(`- Project root: ${manifest.projectRoot}`);
+            if (manifest.likelyWorkingDirectory)
+                manifestLines.push(`- Likely working directory: ${manifest.likelyWorkingDirectory}`);
+            if (manifest.recentlyReadFiles?.length)
+                manifestLines.push(`- Recently read files: ${manifest.recentlyReadFiles.join(', ')}`);
+            if (manifest.recentlyWrittenFiles?.length)
+                manifestLines.push(`- Recently written files: ${manifest.recentlyWrittenFiles.join(', ')}`);
+            if (manifest.recentlyScannedDirectories?.length)
+                manifestLines.push(`- Recently scanned directories: ${manifest.recentlyScannedDirectories.join(', ')}`);
+            if (manifest.recentDownloads?.length)
+                manifestLines.push(`- Recent downloads: ${manifest.recentDownloads.join(', ')}`);
+            if (manifest.recentFailures?.length)
+                manifestLines.push(`- Recent failures: ${manifest.recentFailures.join(' | ')}`);
+            if (manifest.startHereHints?.length)
+                manifestLines.push(`- Start here: ${manifest.startHereHints.join(', ')}`);
+            if (manifestLines.length) {
+                systemPrompt += '\n\n[Workspace Manifest]\n' + manifestLines.join('\n');
+            }
+        }
         return systemPrompt;
     }
     async publishError(commandId, error) {
@@ -1240,19 +1345,18 @@ When a user asks to "use Opus" or "switch to GPT-4o", identify the right model I
             timestamp: Date.now(),
         });
     }
-    /** Update the OAuth token used for requests (called by token refresh) */
+    /** Update the API key used for requests */
     updateToken(token) {
-        this.options.oauthToken = token;
-        // Recreate the default provider with the new token
+        this.options.apiKey = 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,
-            ...(token.startsWith('sk-ant-oat01-') ? { authMode: 'oauth-bearer' } : {}),
+            authMode,
+            ...(this.options.baseUrl ? { baseUrl: this.options.baseUrl } : {}),
+            ...(this.options.apiStyle ? { apiStyle: this.options.apiStyle } : {}),
         });
-        if (token.startsWith('sk-ant-oat01-') && effectiveProvider === 'anthropic') {
-            this.resolveAndUpgradeAuth(token, this.options.model);
-        }
     }
 }
 exports.MessageLoop = MessageLoop;