funolio-agent 1.0.47 → 1.0.49

package/dist/local-server.js

@@ -77,6 +77,8 @@ const orchestrator_profile_1 = require("./orchestrator-profile");
 const policy_detection_1 = require("./policy-detection");
 const server_runtime_1 = require("./server-runtime");
 const storage_mode_1 = require("./storage-mode");
+const local_cli_pty_manager_1 = require("./local-cli-pty-manager");
+const cli_session_epoch_1 = require("./cli-session-epoch");
 const server_adapter_1 = require("./server-adapter");
 const wizard_support_1 = require("./wizard-support");
 const chalk_1 = __importDefault(require("chalk"));
@@ -1828,7 +1830,7 @@ function startLocalServer(opts) {
             if (msgs.length < 3)
                 return res.json({ suggestion: null, reason: 'Not enough messages' });
             const conv = data.getConversation(conversationId);
-            const clerk = (0, clerk_model_1.getClerk)();
+            const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
             if (!clerk) {
                 // Fallback: use first few words of first user message
                 const firstUser = msgs.find(m => m.role === 'user');
@@ -2037,6 +2039,28 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    app.patch('/api/messages/:id', (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.status(501).json({ error: 'Message updates are local-mode only' });
+            }
+            const updated = data.updateMessage(req.params.id, {
+                content: req.body?.content,
+                model: req.body?.model,
+                botId: req.body?.botId,
+                agentName: req.body?.agentName,
+                resultArtifact: req.body?.resultArtifact,
+                resultSummary: req.body?.resultSummary,
+                resultStatus: req.body?.resultStatus,
+            });
+            if (!updated)
+                return res.status(404).json({ error: 'Message not found' });
+            res.json(updated);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.get('/api/conversations/:id/orchestration-audit', (req, res) => {
         try {
             if (isConnectedMode()) {
@@ -2327,7 +2351,13 @@ function startLocalServer(opts) {
                 const limit = parseInt(req.query.limit, 10) || 25;
                 const beforeSeq = req.query.beforeSeq ? parseInt(req.query.beforeSeq, 10) : 0;
                 const rounds = req.query.rounds ? parseInt(req.query.rounds, 10) : 0;
+                const startSeq = req.query.startSeq ? parseInt(req.query.startSeq, 10) : 0;
+                const endSeq = req.query.endSeq ? parseInt(req.query.endSeq, 10) : 0;
+                const hasDirectRange = startSeq > 0 && endSeq >= startSeq;
                 if (isConnectedMode()) {
+                    if (hasDirectRange) {
+                        return res.status(400).json({ error: 'Direct message range fetch is only available in local storage mode' });
+                    }
                     const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
                     const auth = await getHydratedDesktopAuth();
                     const result = await (0, server_adapter_1.listServerConversationMessages)(auth, runtime, req.params.id, {
@@ -2336,6 +2366,9 @@ function startLocalServer(opts) {
                     });
                     return res.json(result.messages);
                 }
+                if (hasDirectRange) {
+                    return res.json(data.getMessagesInRange(req.params.id, startSeq, endSeq));
+                }
                 if (beforeSeq > 0) {
                     // Backward paging: get N rounds or messages before given seq, returned in ASC order
                     const msgs = rounds > 0
@@ -2552,10 +2585,13 @@ function startLocalServer(opts) {
         const activityErrorContext = {};
         const routeAbortController = new AbortController();
         let responseEnded = false;
-        const abortOnClientClose = () => routeAbortController.abort();
+        const abortOnClientClose = () => {
+            responseEnded = true;
+            routeAbortController.abort();
+        };
         req.on('close', abortOnClientClose);
         try {
-            const { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId, orchestrationEnabled, chatJobId, assistantMessageId, } = req.body;
+            let { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId, orchestrationEnabled, chatJobId, assistantMessageId, persistAssistantPlaceholder, } = req.body;
             if (!message)
                 return res.status(400).json({ error: 'message is required' });
             if (await relayConnectedChat(req, res)) {
@@ -2613,6 +2649,7 @@ function startLocalServer(opts) {
             const activityExpiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString().replace('T', ' ').replace('Z', '');
             activityErrorContext.conversationId = convId;
             activityErrorContext.streamId = activityStreamId;
+            activityErrorContext.messageId = assistantMessageId ? String(assistantMessageId) : null;
             activityErrorContext.botId = profile?.id ?? null;
             activityErrorContext.agentName = profile?.name ?? null;
             activityErrorContext.expiresAt = activityExpiresAt;
@@ -2620,6 +2657,7 @@ function startLocalServer(opts) {
                 try {
                     data.createMessageActivity({
                         conversationId: convId,
+                        messageId: assistantMessageId ? String(assistantMessageId) : null,
                         streamId: activityStreamId,
                         botId: profile?.id ?? null,
                         agentName: profile?.name ?? null,
@@ -2649,6 +2687,7 @@ function startLocalServer(opts) {
                 try {
                     data.createMessageActivity({
                         conversationId: convId,
+                        messageId: assistantMessageId ? String(assistantMessageId) : null,
                         streamId: activityStreamId,
                         botId: resolveWorkerBotId(event.agentName) || null,
                         agentName: event.agentName || null,
@@ -2671,7 +2710,7 @@ function startLocalServer(opts) {
                 const effectiveProjectId = projectId ? String(projectId) : (convForPolicy?.project_id || undefined);
                 const projectForPolicy = effectiveProjectId ? data.getProject(effectiveProjectId) : undefined;
                 const currentPolicy = data.getEffectiveOrchestrationPolicy(effectiveProjectId);
-                const clerkForPolicy = (0, clerk_model_1.getClerk)();
+                const clerkForPolicy = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
                 const agentNames = data.listAgentProfiles().map((agent) => agent.name);
                 if (clerkForPolicy && savedUserMessage) {
                     void (0, policy_detection_1.stagePolicyDetectionForMessage)({
@@ -2690,10 +2729,14 @@ function startLocalServer(opts) {
                     });
                 }
             }
+            if (!assistantMessageId && persistAssistantPlaceholder === true) {
+                const placeholder = data.addMessage(convId, 'assistant', '', buildConfiguredMessageModel(profile), undefined, profile?.id || undefined, profile?.name || undefined);
+                assistantMessageId = placeholder.id;
+            }
             // ─── Orchestrator Mode Branch ─────────────────────────
             const shouldUseOrchestratorMode = orchestrationEnabled !== false && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
             if (shouldUseOrchestratorMode) {
-                const clerk = (0, clerk_model_1.getClerk)();
+                const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
                 if (!clerk) {
                     // Fix #2: Do not silently fall through to direct chat — return a clear error
                     return res.status(400).json({
@@ -2702,7 +2745,7 @@ function startLocalServer(opts) {
                 }
                 const { OrchestratorAgent } = require('./orchestrator');
                 const { getWorkflowEngine } = require('./workflow-engine');
-                const workflowEngine = getWorkflowEngine(opts.projectDir);
+                const workflowEngine = getWorkflowEngine(opts.projectDir, 'local_desktop');
                 const orchestrator = new OrchestratorAgent(clerk, workflowEngine);
                 // Resolve effective project ID from request or existing conversation
                 const conv = data.getConversation(convId);
@@ -2732,7 +2775,7 @@ function startLocalServer(opts) {
                         orchestratorRuntime.model || profile.model || '',
                         runtimeModeLabel(orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource),
                     ].filter(Boolean).join(' | ');
-                    orchestratorRuntimePayload = runtimePayloadForDisplay(profile.provider, orchestratorRuntime.model || profile.model || null, orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource || null, false);
+                    orchestratorRuntimePayload = runtimePayloadForDisplay(profile.provider, orchestratorRuntime.model || profile.model || null, orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource || null);
                 }
                 catch {
                     orchestratorRuntimeLabel = buildConfiguredMessageModel(profile);
@@ -2992,7 +3035,7 @@ function startLocalServer(opts) {
                 ? configuredTz
                 : Intl.DateTimeFormat().resolvedOptions().timeZone;
             const unrestrictedCliProfile = index_1.CLI_PROVIDERS.has(profile.provider);
-            const allToolDefs = (0, index_2.getAllToolDefinitions)(mcpManager);
+            const allToolDefs = (0, index_2.getAllToolDefinitions)('local_desktop', mcpManager);
             const configuredBuiltinTools = parseToolSelectionJson(profile.enabled_builtin_tools_json);
             const configuredMcpTools = parseToolSelectionJson(profile.enabled_mcp_tools_json);
             const allowedToolNames = unrestrictedCliProfile
@@ -3002,7 +3045,7 @@ function startLocalServer(opts) {
             // Build system prompt via clerk (token-budgeted context injection)
             let systemPrompt;
             let llmSpawnCwd = opts.projectDir;
-            const clerk = (0, clerk_model_1.getClerk)();
+            const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
             if (clerk) {
                 const conv = data.getConversation(convId);
                 const topicTitle = topicId ? data.getTopic(topicId)?.title : undefined;
@@ -3028,9 +3071,10 @@ function startLocalServer(opts) {
             else {
                 // Fallback: manual prompt building
                 systemPrompt = '[Bot Identity]\n' + (profile.soul_md
-                    || 'You are a Funolio AI agent running locally. You have access to project files and can execute code.');
+                    || 'You are an AI assistant running locally. You have access to project files and can execute code.');
                 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\nWhen [Project Overview] is present, treat Project/Topic/Workspace values there as authoritative for the current turn and override stale prior-chat claims.';
+                systemPrompt += '\n\n[Response Style]\nWrite in short readable paragraphs. Put a blank line between distinct ideas. Use bullets when listing findings, steps, or issues. Do not return one dense wall of text. For progress updates, keep them compact and clearly separate what you checked, what you found, and what you are doing next.';
                 const convForFallback = data.getConversation(convId);
                 const projectForFallback = convForFallback?.project_id ? data.getProject(convForFallback.project_id) : undefined;
                 const workspaceForFallback = projectForFallback?.folder?.trim();
@@ -3101,18 +3145,25 @@ function startLocalServer(opts) {
             let activeRuntimeMode = runtime.runtimeMode;
             let activeRuntimeSource = runtime.runtimeSource;
             let activeIsCliProvider = index_1.CLI_PROVIDERS.has(activeProviderName);
-            const cliFallback = runtime.cliFallback;
-            const apiKeyFallback = runtime.apiKeyFallback;
-            let switchedToCliFallback = false;
-            let switchedToApiKeyFallback = false;
             const runtimePayload = () => ({
                 mode: activeRuntimeMode,
                 modeLabel: runtimeModeLabel(activeRuntimeMode, activeRuntimeSource),
                 provider: activeProviderName,
                 model: activeModelName || null,
                 source: activeRuntimeSource || null,
-                fallbackUsed: switchedToCliFallback || switchedToApiKeyFallback,
             });
+            const enableCliSessionEpoch = activeIsCliProvider
+                && !shouldUseOrchestratorMode
+                && !workflowTemplateId
+                && !!convId
+                && !!profile?.id;
+            const cliSessionEpochPlan = enableCliSessionEpoch
+                ? (0, cli_session_epoch_1.selectCliSessionEpoch)(convId, profile.id, activeProviderName)
+                : { existing: undefined, resumeSessionId: null, resetReason: null };
+            let activeCliSessionId = cliSessionEpochPlan.resumeSessionId;
+            const cliEpochStartedAt = cliSessionEpochPlan.resumeSessionId
+                ? (cliSessionEpochPlan.existing?.epoch_started_at || localTimestamp())
+                : localTimestamp();
             if (!activeApiKey) {
                 return res.status(400).json({ error: `No API key for provider ${profile.provider}. Configure one in Settings.` });
             }
@@ -3120,6 +3171,7 @@ function startLocalServer(opts) {
                 projectId: convId ? (data.getConversation(convId)?.project_id ?? null) : null,
                 actorType: 'llm',
                 actorId: profile?.name || profile?.id || 'LLM',
+                runtimeMode: 'local_desktop',
                 restrictFileAccessToProject: unrestrictedCliProfile ? false : undefined,
                 abortSignal: routeAbortController.signal,
             });
@@ -3180,6 +3232,7 @@ function startLocalServer(opts) {
             sendEvent('meta', {
                 conversationId: convId,
                 botId: profile.id,
+                assistantMessageId: assistantMessageId || null,
                 runtime: runtimePayload(),
                 tokenUsage: {
                     approxInputTokens,
@@ -3197,6 +3250,23 @@ function startLocalServer(opts) {
                 detail: `Sending request to ${activeProviderName}...`,
                 runtime: runtimePayload(),
             }, `Sending request to ${activeProviderName}...`);
+            if (cliSessionEpochPlan.resetReason && enableCliSessionEpoch) {
+                const resetDetail = cliSessionEpochPlan.resetReason === 'turn_limit'
+                    ? 'Resetting CLI session after reaching the turn limit.'
+                    : cliSessionEpochPlan.resetReason === 'token_limit'
+                        ? 'Resetting CLI session after reaching the context budget.'
+                        : 'Resetting CLI session because the runtime changed.';
+                sendEvent('status', {
+                    phase: 'thinking',
+                    detail: resetDetail,
+                    runtime: runtimePayload(),
+                });
+                recordActivity('status', {
+                    phase: 'thinking',
+                    detail: resetDetail,
+                    runtime: runtimePayload(),
+                }, resetDetail);
+            }
             let partialPersistedContent = '';
             let partialPersistedAt = 0;
             const throwIfChatJobCancelled = () => {
@@ -3245,265 +3315,259 @@ function startLocalServer(opts) {
             // Thinking/reasoning accumulator across multi-turn tool loops
             let accumulatedThinking = '';
             const thinkingEnabled = !!profile?.show_thinking;
-            while (iteration < MAX_ITERATIONS) {
-                iteration++;
-                let iterationFirstChunk = true;
-                throwIfChatJobCancelled();
-                if (iteration > 1) {
-                    sendEvent('status', { phase: 'thinking', detail: 'Processing tool results...' });
-                    recordActivity('status', { phase: 'thinking', detail: 'Processing tool results...' }, 'Processing tool results...');
-                }
-                let response;
-                const chatOptions = {
-                    messages: llmMessages,
-                    system: systemPrompt,
-                    stream: true,
-                    tools: toolDefs,
-                    cwd: llmSpawnCwd,
-                    abortSignal: routeAbortController.signal,
-                    thinkingEnabled,
-                    onChunk: async (chunk) => {
-                        throwIfChatJobCancelled();
-                        if (iterationFirstChunk) {
-                            iterationFirstChunk = false;
-                            sendEvent('status', { phase: 'generating' });
-                            recordActivity('status', { phase: 'generating' }, 'Generating response...');
+            let useInteractiveCliSession = enableCliSessionEpoch;
+            if (useInteractiveCliSession) {
+                const ptyManager = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)();
+                let ptyAttempt = 0;
+                while (true) {
+                    ptyAttempt++;
+                    try {
+                        const result = await ptyManager.runTurn({
+                            conversationId: convId,
+                            botId: profile.id,
+                            provider: activeProviderName,
+                            cwd: llmSpawnCwd,
+                            systemPrompt,
+                            messages: llmMessages,
+                            forceFreshSession: !cliSessionEpochPlan.resumeSessionId,
+                            onDetail: async (detail) => {
+                                sendEvent('status', {
+                                    phase: 'thinking',
+                                    detail,
+                                    runtime: runtimePayload(),
+                                });
+                                recordActivity('status', {
+                                    phase: 'thinking',
+                                    detail,
+                                    runtime: runtimePayload(),
+                                }, detail);
+                            },
+                        });
+                        if (result.sessionId) {
+                            activeCliSessionId = result.sessionId;
                         }
-                        streamedAnyChunk = true;
-                        streamedContent += chunk;
-                        persistAssistantPartial(false);
-                        sendEvent('chunk', { text: chunk });
-                    },
-                    ...(thinkingEnabled ? {
-                        onThinkingChunk: async (chunk) => {
-                            sendEvent('thinking_chunk', {
-                                text: chunk,
-                                botId: profile?.id || null,
-                                agentName: profile?.name || null,
-                            });
-                        },
-                    } : {}),
-                };
-                try {
-                    response = await activeLlm.chat(chatOptions);
-                }
-                catch (primaryErr) {
-                    if (routeAbortController.signal.aborted || primaryErr?.name === 'AbortError') {
-                        throw primaryErr;
+                        if (result.usage) {
+                            totalInputTokens += result.usage.inputTokens || 0;
+                            totalOutputTokens += result.usage.outputTokens || 0;
+                            hasExactUsage = true;
+                        }
+                        fullContent = (result.content || '').trim();
+                        break;
                     }
-                    if (cliFallback && !switchedToCliFallback) {
-                        switchedToCliFallback = true;
-                        activeProviderName = cliFallback.providerName;
-                        activeModelName = cliFallback.model;
-                        activeApiKey = cliFallback.apiKey;
-                        activeLlm = cliFallback.llm;
-                        activeRuntimeMode = cliFallback.runtimeMode;
-                        activeRuntimeSource = cliFallback.runtimeSource;
-                        activeIsCliProvider = true;
-                        const fallbackMsg = activeIsCliProvider
-                            ? `CLI auth failed (${primaryErr?.message || primaryErr}); switching to fallback...`
-                            : `Primary provider failed (${primaryErr?.message || primaryErr}); switching to fallback...`;
-                        console.warn(chalk_1.default.yellow(`  [chat] ${fallbackMsg}`));
-                        if (activeIsCliProvider) {
-                            console.warn(chalk_1.default.yellow(`  [chat] If CLI auth keeps failing, run 'claude' or 'codex' in your terminal to re-authenticate.`));
+                    catch (ptyErr) {
+                        if (ptyAttempt >= LOCAL_RUNTIME_RETRY_LIMIT || !shouldRetrySelectedLocalRuntime(ptyErr)) {
+                            throw ptyErr;
                         }
+                        const retryDetail = `Selected runtime failed (${ptyErr?.message || ptyErr}); retrying the same connection (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
+                        console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
                         sendEvent('status', {
                             phase: 'thinking',
-                            detail: fallbackMsg,
+                            detail: retryDetail,
                             runtime: runtimePayload(),
                         });
                         recordActivity('status', {
                             phase: 'thinking',
-                            detail: fallbackMsg,
+                            detail: retryDetail,
                             runtime: runtimePayload(),
-                        }, fallbackMsg);
-                        sendEvent('status', {
-                            phase: 'thinking',
-                            detail: `Sending request to ${activeProviderName}...`,
-                            runtime: runtimePayload(),
-                        });
-                        recordActivity('status', {
-                            phase: 'thinking',
-                            detail: `Sending request to ${activeProviderName}...`,
-                            runtime: runtimePayload(),
-                        }, `Sending request to ${activeProviderName}...`);
+                        }, retryDetail);
+                        await pauseLocalRuntimeRetry(ptyAttempt);
+                    }
+                }
+            }
+            if (!useInteractiveCliSession)
+                while (iteration < MAX_ITERATIONS) {
+                    iteration++;
+                    let iterationFirstChunk = true;
+                    throwIfChatJobCancelled();
+                    if (iteration > 1) {
+                        sendEvent('status', { phase: 'thinking', detail: 'Processing tool results...' });
+                        recordActivity('status', { phase: 'thinking', detail: 'Processing tool results...' }, 'Processing tool results...');
+                    }
+                    let response;
+                    const chatOptions = {
+                        messages: llmMessages,
+                        system: systemPrompt,
+                        stream: true,
+                        tools: toolDefs,
+                        cwd: llmSpawnCwd,
+                        abortSignal: routeAbortController.signal,
+                        resumeSessionId: enableCliSessionEpoch ? activeCliSessionId : null,
+                        persistSession: enableCliSessionEpoch,
+                        thinkingEnabled,
+                        onChunk: async (chunk) => {
+                            throwIfChatJobCancelled();
+                            if (iterationFirstChunk) {
+                                iterationFirstChunk = false;
+                                sendEvent('status', { phase: 'generating' });
+                                recordActivity('status', { phase: 'generating' }, 'Generating response...');
+                            }
+                            streamedAnyChunk = true;
+                            streamedContent += chunk;
+                            persistAssistantPartial(false);
+                            sendEvent('chunk', { text: chunk });
+                        },
+                        ...(thinkingEnabled ? {
+                            onThinkingChunk: async (chunk) => {
+                                sendEvent('thinking_chunk', {
+                                    text: chunk,
+                                    botId: profile?.id || null,
+                                    agentName: profile?.name || null,
+                                });
+                            },
+                        } : {}),
+                    };
+                    let chatAttempt = 0;
+                    while (true) {
+                        chatAttempt++;
                         try {
                             response = await activeLlm.chat(chatOptions);
+                            break;
                         }
-                        catch (cliErr) {
-                            if (!apiKeyFallback || switchedToApiKeyFallback)
-                                throw cliErr;
-                            switchedToApiKeyFallback = true;
-                            activeProviderName = apiKeyFallback.providerName;
-                            activeModelName = apiKeyFallback.model;
-                            activeApiKey = apiKeyFallback.apiKey;
-                            activeLlm = apiKeyFallback.llm;
-                            activeRuntimeMode = apiKeyFallback.runtimeMode;
-                            activeRuntimeSource = apiKeyFallback.runtimeSource;
-                            activeIsCliProvider = false;
-                            console.warn(chalk_1.default.yellow(`  [chat] CLI fallback failed (${cliErr?.message || cliErr}); switching to API key fallback (${activeProviderName})`));
-                            sendEvent('status', {
-                                phase: 'thinking',
-                                detail: 'CLI fallback unavailable; switching to API key fallback...',
-                                runtime: runtimePayload(),
-                            });
-                            recordActivity('status', {
-                                phase: 'thinking',
-                                detail: 'CLI fallback unavailable; switching to API key fallback...',
-                                runtime: runtimePayload(),
-                            }, 'CLI fallback unavailable; switching to API key fallback...');
+                        catch (primaryErr) {
+                            if (routeAbortController.signal.aborted || primaryErr?.name === 'AbortError') {
+                                throw primaryErr;
+                            }
+                            if (chatAttempt >= LOCAL_RUNTIME_RETRY_LIMIT || !shouldRetrySelectedLocalRuntime(primaryErr)) {
+                                throw primaryErr;
+                            }
+                            const retryDetail = `Selected runtime failed (${primaryErr?.message || primaryErr}); retrying the same connection (${chatAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
+                            console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
                             sendEvent('status', {
                                 phase: 'thinking',
-                                detail: `Sending request to ${activeProviderName}...`,
+                                detail: retryDetail,
                                 runtime: runtimePayload(),
                             });
                             recordActivity('status', {
                                 phase: 'thinking',
-                                detail: `Sending request to ${activeProviderName}...`,
+                                detail: retryDetail,
                                 runtime: runtimePayload(),
-                            }, `Sending request to ${activeProviderName}...`);
-                            response = await activeLlm.chat(chatOptions);
+                            }, retryDetail);
+                            await pauseLocalRuntimeRetry(chatAttempt);
                         }
                     }
-                    else if (apiKeyFallback && !switchedToApiKeyFallback) {
-                        switchedToApiKeyFallback = true;
-                        activeProviderName = apiKeyFallback.providerName;
-                        activeModelName = apiKeyFallback.model;
-                        activeApiKey = apiKeyFallback.apiKey;
-                        activeLlm = apiKeyFallback.llm;
-                        activeRuntimeMode = apiKeyFallback.runtimeMode;
-                        activeRuntimeSource = apiKeyFallback.runtimeSource;
-                        activeIsCliProvider = false;
-                        console.warn(chalk_1.default.yellow(`  [chat] Runtime failed (${primaryErr?.message || primaryErr}); switching to API key fallback (${activeProviderName})`));
-                        sendEvent('status', {
-                            phase: 'thinking',
-                            detail: 'Switching to API key fallback...',
-                            runtime: runtimePayload(),
-                        });
-                        recordActivity('status', {
-                            phase: 'thinking',
-                            detail: 'Switching to API key fallback...',
-                            runtime: runtimePayload(),
-                        }, 'Switching to API key fallback...');
+                    if (enableCliSessionEpoch && response?.session?.id) {
+                        activeCliSessionId = response.session.id;
+                    }
+                    throwIfChatJobCancelled();
+                    const authFailure = detectInteractiveAuthFailure(response?.content || '', activeProviderName, profile.provider);
+                    if (authFailure && (!response?.toolCalls || response.toolCalls.length === 0)) {
                         sendEvent('status', {
-                            phase: 'thinking',
-                            detail: `Sending request to ${activeProviderName}...`,
+                            phase: 'auth_required',
+                            detail: authFailure.detail,
                             runtime: runtimePayload(),
+                            auth: authFailure,
                         });
                         recordActivity('status', {
-                            phase: 'thinking',
-                            detail: `Sending request to ${activeProviderName}...`,
+                            phase: 'auth_required',
+                            detail: authFailure.detail,
                             runtime: runtimePayload(),
-                        }, `Sending request to ${activeProviderName}...`);
-                        response = await activeLlm.chat(chatOptions);
+                            auth: authFailure,
+                        }, authFailure.detail);
+                        const authErr = new Error(authFailure.message);
+                        authErr.authRequired = true;
+                        authErr.providerId = authFailure.providerId;
+                        authErr.cli = authFailure.cli;
+                        throw authErr;
                     }
-                    else {
-                        throw primaryErr;
+                    if (response.usage) {
+                        totalInputTokens += response.usage.inputTokens || 0;
+                        totalOutputTokens += response.usage.outputTokens || 0;
+                        hasExactUsage = true;
                     }
-                }
-                throwIfChatJobCancelled();
-                const authFailure = detectInteractiveAuthFailure(response?.content || '', activeProviderName, profile.provider);
-                if (authFailure && (!response?.toolCalls || response.toolCalls.length === 0)) {
-                    sendEvent('status', {
-                        phase: 'auth_required',
-                        detail: authFailure.detail,
-                        runtime: runtimePayload(),
-                        auth: authFailure,
-                    });
-                    recordActivity('status', {
-                        phase: 'auth_required',
-                        detail: authFailure.detail,
-                        runtime: runtimePayload(),
-                        auth: authFailure,
-                    }, authFailure.detail);
-                    const authErr = new Error(authFailure.message);
-                    authErr.authRequired = true;
-                    authErr.providerId = authFailure.providerId;
-                    authErr.cli = authFailure.cli;
-                    throw authErr;
-                }
-                if (response.usage) {
-                    totalInputTokens += response.usage.inputTokens || 0;
-                    totalOutputTokens += response.usage.outputTokens || 0;
-                    hasExactUsage = true;
-                }
-                // Accumulate thinking/reasoning across multi-turn tool loops
-                if (response.thinking) {
-                    accumulatedThinking += (accumulatedThinking ? '\n---\n' : '') + response.thinking;
-                }
-                if (response.toolCalls && response.toolCalls.length > 0) {
-                    llmMessages.push({
-                        role: 'assistant',
-                        content: response.content || '',
-                        toolCalls: response.toolCalls,
-                    });
-                    for (const tc of response.toolCalls) {
-                        throwIfChatJobCancelled();
-                        sendEvent('status', { phase: 'calling_tool', detail: `Running ${tc.name}...`, toolName: tc.name });
-                        sendEvent('tool_call', { id: tc.id, name: tc.name, arguments: tc.arguments });
-                        recordActivity('tool_call', { id: tc.id, name: tc.name, arguments: tc.arguments }, `Tool call: ${tc.name}`);
-                        if (!allowedToolNames.has(tc.name)) {
-                            const errMsg = `TOOL_DISABLED: ${tc.name} is not enabled for this bot.`;
-                            sendEvent('tool_result', { callId: tc.id, output: errMsg, isError: true });
-                            recordActivity('tool_result', { callId: tc.id, output: errMsg, isError: true }, `Tool failed: ${tc.name}`);
-                            llmMessages.push({ role: 'tool', content: errMsg, toolCallId: tc.id, toolName: tc.name });
-                            continue;
-                        }
-                        const approval = unrestrictedCliProfile
-                            ? { approved: true }
-                            : (0, approval_1.checkPermission)(tc.name, (profile.permission_mode || 'autopilot'));
-                        if (!approval.approved) {
-                            const errMsg = `PERMISSION_DENIED: ${approval.reason}`;
-                            sendEvent('tool_result', { callId: tc.id, output: errMsg, isError: true });
-                            recordActivity('tool_result', { callId: tc.id, output: errMsg, isError: true }, `Tool denied: ${tc.name}`);
-                            llmMessages.push({ role: 'tool', content: errMsg, toolCallId: tc.id, toolName: tc.name });
-                            continue;
-                        }
-                        let result;
-                        try {
-                            const raw = await (0, index_2.executeToolWithMCP)({ id: tc.id, name: tc.name, arguments: tc.arguments }, toolCtx, mcpManager);
-                            const verified = await (0, index_2.verifyToolResult)(raw, tc.arguments, toolCtx);
-                            result = {
-                                success: verified.success,
-                                output: verified.output,
-                                error: verified.error,
-                            };
-                        }
-                        catch (toolErr) {
-                            result = { success: false, output: '', error: toolErr.message || 'Tool execution failed' };
+                    // Accumulate thinking/reasoning across multi-turn tool loops
+                    if (response.thinking) {
+                        accumulatedThinking += (accumulatedThinking ? '\n---\n' : '') + response.thinking;
+                    }
+                    if (response.toolCalls && response.toolCalls.length > 0) {
+                        llmMessages.push({
+                            role: 'assistant',
+                            content: response.content || '',
+                            toolCalls: response.toolCalls,
+                        });
+                        for (const tc of response.toolCalls) {
+                            throwIfChatJobCancelled();
+                            sendEvent('status', { phase: 'calling_tool', detail: `Running ${tc.name}...`, toolName: tc.name });
+                            sendEvent('tool_call', { id: tc.id, name: tc.name, arguments: tc.arguments });
+                            recordActivity('tool_call', { id: tc.id, name: tc.name, arguments: tc.arguments }, `Tool call: ${tc.name}`);
+                            if (!allowedToolNames.has(tc.name)) {
+                                const errMsg = `TOOL_DISABLED: ${tc.name} is not enabled for this bot.`;
+                                sendEvent('tool_result', { callId: tc.id, output: errMsg, isError: true });
+                                recordActivity('tool_result', { callId: tc.id, output: errMsg, isError: true }, `Tool failed: ${tc.name}`);
+                                llmMessages.push({ role: 'tool', content: errMsg, toolCallId: tc.id, toolName: tc.name });
+                                continue;
+                            }
+                            const approval = unrestrictedCliProfile
+                                ? { approved: true }
+                                : (0, approval_1.checkPermission)(tc.name, (profile.permission_mode || 'autopilot'));
+                            if (!approval.approved) {
+                                const errMsg = `PERMISSION_DENIED: ${approval.reason}`;
+                                sendEvent('tool_result', { callId: tc.id, output: errMsg, isError: true });
+                                recordActivity('tool_result', { callId: tc.id, output: errMsg, isError: true }, `Tool denied: ${tc.name}`);
+                                llmMessages.push({ role: 'tool', content: errMsg, toolCallId: tc.id, toolName: tc.name });
+                                continue;
+                            }
+                            let result;
+                            try {
+                                const raw = await (0, index_2.executeToolWithMCP)({ id: tc.id, name: tc.name, arguments: tc.arguments }, toolCtx, mcpManager);
+                                const verified = await (0, index_2.verifyToolResult)(raw, tc.arguments, toolCtx);
+                                result = {
+                                    success: verified.success,
+                                    output: verified.output,
+                                    error: verified.error,
+                                };
+                            }
+                            catch (toolErr) {
+                                result = { success: false, output: '', error: toolErr.message || 'Tool execution failed' };
+                            }
+                            const output = result.success ? result.output : `ERROR: ${result.error || 'Unknown error'}`;
+                            sendEvent('tool_result', { callId: tc.id, output, isError: !result.success });
+                            recordActivity('tool_result', {
+                                callId: tc.id,
+                                output,
+                                isError: !result.success,
+                            }, `${result.success ? 'Tool completed' : 'Tool failed'}: ${tc.name}`);
+                            llmMessages.push({ role: 'tool', content: output, toolCallId: tc.id, toolName: tc.name });
                         }
-                        const output = result.success ? result.output : `ERROR: ${result.error || 'Unknown error'}`;
-                        sendEvent('tool_result', { callId: tc.id, output, isError: !result.success });
-                        recordActivity('tool_result', {
-                            callId: tc.id,
-                            output,
-                            isError: !result.success,
-                        }, `${result.success ? 'Tool completed' : 'Tool failed'}: ${tc.name}`);
-                        llmMessages.push({ role: 'tool', content: output, toolCallId: tc.id, toolName: tc.name });
+                        continue;
                     }
-                    continue;
-                }
-                // Final response (guard against defer-only filler)
-                const candidate = (response.content || '').trim();
-                if (!forcedFinalizationPass && (0, response_guard_1.isLikelyDeferredReply)(candidate)) {
-                    forcedFinalizationPass = true;
-                    llmMessages.push({ role: 'assistant', content: candidate });
-                    llmMessages.push({
-                        role: 'user',
-                        content: 'Provide the final answer now. Do not say you will check later. Either provide concrete results or explicitly say what is unavailable.',
-                    });
-                    sendEvent('status', { phase: 'thinking', detail: 'Finalizing response...' });
-                    recordActivity('status', { phase: 'thinking', detail: 'Finalizing response...' }, 'Finalizing response...');
-                    continue;
+                    // Final response (guard against defer-only filler)
+                    const candidate = (response.content || '').trim();
+                    if (!forcedFinalizationPass && (0, response_guard_1.isLikelyDeferredReply)(candidate)) {
+                        forcedFinalizationPass = true;
+                        llmMessages.push({ role: 'assistant', content: candidate });
+                        llmMessages.push({
+                            role: 'user',
+                            content: 'Provide the final answer now. Do not say you will check later. Either provide concrete results or explicitly say what is unavailable.',
+                        });
+                        sendEvent('status', { phase: 'thinking', detail: 'Finalizing response...' });
+                        recordActivity('status', { phase: 'thinking', detail: 'Finalizing response...' }, 'Finalizing response...');
+                        continue;
+                    }
+                    fullContent = candidate;
+                    break;
                 }
-                fullContent = candidate;
-                break;
-            }
             const persistedContent = fullContent || streamedContent.trim();
             if (!persistedContent) {
                 throw new Error('Assistant returned no final response');
             }
             persistAssistantPartial(true);
+            if (enableCliSessionEpoch && activeCliSessionId) {
+                const nextEpochTurnCount = cliSessionEpochPlan.resumeSessionId
+                    ? ((cliSessionEpochPlan.existing?.epoch_turn_count || 0) + 1)
+                    : 1;
+                data.upsertCliSessionEpoch({
+                    conversationId: convId,
+                    botId: profile.id,
+                    provider: activeProviderName,
+                    sessionId: activeCliSessionId,
+                    epochTurnCount: nextEpochTurnCount,
+                    lastInputTokens: hasExactUsage ? totalInputTokens : approxInputTokens,
+                    lastOutputTokens: hasExactUsage ? totalOutputTokens : 0,
+                    resetReason: cliSessionEpochPlan.resetReason,
+                    epochStartedAt: cliEpochStartedAt,
+                    lastUsedAt: localTimestamp(),
+                });
+            }
             // Emit thinking_done event if we accumulated any thinking
             if (accumulatedThinking) {
                 sendEvent('thinking_done', {
@@ -3587,6 +3651,7 @@ function startLocalServer(opts) {
                 if (activityErrorContext.conversationId) {
                     data.createMessageActivity({
                         conversationId: activityErrorContext.conversationId,
+                        messageId: activityErrorContext.messageId ?? null,
                         streamId: activityErrorContext.streamId ?? null,
                         botId: activityErrorContext.botId ?? null,
                         agentName: activityErrorContext.agentName ?? null,
@@ -3777,7 +3842,7 @@ function startLocalServer(opts) {
             const { prompt } = req.body;
             if (!prompt)
                 return res.status(400).json({ error: 'prompt is required' });
-            const clerk = (0, clerk_model_1.getClerk)();
+            const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
             if (!clerk)
                 return res.json({ routing: 'default', reason: 'No clerk configured' });
             const agents = data.listAgentProfiles();
@@ -3794,7 +3859,7 @@ function startLocalServer(opts) {
             const { prompt, conversationId, agentId, pinnedMessageIds } = req.body;
             if (!prompt)
                 return res.status(400).json({ error: 'prompt is required' });
-            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir);
+            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
             const profile = agentId
                 ? data.getAgentProfile(agentId)
                 : data.getDefaultAgentProfile();
@@ -3812,6 +3877,7 @@ function startLocalServer(opts) {
             const result = await engine.execute(prompt, conversationId || null, profile.id, {
                 onProgress: (p) => sendEvent('progress', p),
                 pinnedMessageIds: pinnedMessageIds || undefined,
+                runtimeMode: 'local_desktop',
             });
             sendEvent('done', result);
             res.end();
@@ -3839,7 +3905,7 @@ function startLocalServer(opts) {
                 return res.status(400).json({ error: 'template id is required' });
             if (!Number.isFinite(taskId) || taskId <= 0)
                 return res.status(400).json({ error: 'taskId is required' });
-            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir);
+            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
             res.writeHead(200, {
                 'Content-Type': 'text/event-stream',
                 'Cache-Control': 'no-cache',
@@ -3871,7 +3937,7 @@ function startLocalServer(opts) {
     });
     app.get('/api/workflow/active', (_req, res) => {
         try {
-            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir);
+            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
             const workflows = engine.getActiveWorkflows();
             res.json(workflows);
         }
@@ -3881,7 +3947,7 @@ function startLocalServer(opts) {
     });
     app.post('/api/workflow/:id/cancel', (req, res) => {
         try {
-            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir);
+            const engine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
             const cancelled = engine.cancel(req.params.id);
             res.json({ ok: cancelled });
         }
@@ -4612,7 +4678,7 @@ function startLocalServer(opts) {
         }
     });
     // Initialize workflow engine
-    (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir);
+    (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
     // Start server
     return new Promise((resolve, reject) => {
         _server = app.listen(port, '127.0.0.1', () => {
@@ -4643,43 +4709,38 @@ function stopLocalServer() {
         }
     });
 }
-function buildCliFallback(profile) {
-    const providerName = profile.provider;
-    const model = (profile.model || '').trim() || 'default';
-    return {
-        providerName,
-        apiKey: 'cli-auth',
-        model,
-        llm: (0, index_1.createProvider)(providerName, { apiKey: 'cli-auth', model }),
-        runtimeMode: 'subscription-cli',
-        runtimeSource: 'cli-direct',
-    };
-}
 async function buildChatRuntime(profile) {
     const providerName = profile.provider;
-    const cliModel = (profile.model || '').trim() || 'default';
-    const apiKeyFallback = buildApiKeyFallback(profile);
-    if (providerName === 'claude-cli' || providerName === 'codex-cli') {
+    const model = (profile.model || '').trim() || 'default';
+    if (providerName === 'claude-cli') {
         return {
             providerName,
             apiKey: 'cli-auth',
-            model: cliModel,
-            llm: (0, index_1.createProvider)(providerName, { apiKey: 'cli-auth', model: cliModel }),
+            model,
+            llm: (0, index_1.createProvider)(providerName, { apiKey: 'cli-auth', model, runtimeMode: 'local_desktop' }),
+            runtimeMode: 'subscription-cli',
+            runtimeSource: 'cli-direct',
+        };
+    }
+    if (providerName === 'codex-cli') {
+        return {
+            providerName,
+            apiKey: 'cli-auth',
+            model,
+            llm: (0, index_1.createProvider)(providerName, { apiKey: 'cli-auth', model, runtimeMode: 'local_desktop' }),
             runtimeMode: 'subscription-cli',
             runtimeSource: 'cli-direct',
-            apiKeyFallback,
         };
     }
     const apiKey = resolveApiKey(profile);
     if (!apiKey) {
         throw new Error(`No API key for provider ${profile.provider}. Configure one in Settings.`);
     }
-    const model = (profile.model || '').trim() || 'default';
     return {
         providerName,
         apiKey,
         model,
-        llm: (0, index_1.createProvider)(providerName, { apiKey, model }),
+        llm: (0, index_1.createProvider)(providerName, { apiKey, model, runtimeMode: 'local_desktop' }),
         runtimeMode: 'api-key',
         runtimeSource: 'api-key',
     };
@@ -4691,14 +4752,13 @@ function runtimeModeLabel(mode, runtimeSource) {
         return (0, subscription_runtime_1.claudeSubscriptionRuntimeLabel)(runtimeSource);
     return 'API Key';
 }
-function runtimePayloadForDisplay(providerName, model, runtimeMode, runtimeSource, fallbackUsed) {
+function runtimePayloadForDisplay(providerName, model, runtimeMode, runtimeSource) {
     return {
         mode: runtimeMode,
         modeLabel: runtimeModeLabel(runtimeMode, runtimeSource),
         provider: providerName,
         model: model || null,
         source: runtimeSource || null,
-        fallbackUsed,
     };
 }
 function configuredRuntimeLabelForProfile(profile) {
@@ -4870,27 +4930,19 @@ function detectInteractiveAuthFailure(text, activeProviderName, configuredProvid
         cli,
     };
 }
-function buildApiKeyFallback(profile) {
-    const providerName = profile.provider === 'codex-cli'
-        ? 'openai'
-        : profile.provider === 'claude-cli'
-            ? 'anthropic'
-            : profile.provider;
-    const configured = data.findProviderConnection(providerName);
-    const apiKey = configured?.api_key_enc || resolveApiKey({ ...profile, provider: providerName });
-    if (!apiKey)
-        return undefined;
-    const model = (0, subscription_runtime_1.resolveSubscriptionApiModel)(profile.model, configured?.default_model || undefined)
-        || (configured?.default_model || '').trim()
-        || 'default';
-    return {
-        providerName,
-        apiKey,
-        model,
-        llm: (0, index_1.createProvider)(providerName, { apiKey, model }),
-        runtimeMode: 'api-key',
-        runtimeSource: 'api-key-fallback',
-    };
+const LOCAL_RUNTIME_RETRY_LIMIT = 2;
+function shouldRetrySelectedLocalRuntime(err) {
+    const text = String(err?.message || err || '').toLowerCase();
+    if (!text)
+        return false;
+    if (/\b(no api key|configure one in settings|not available on this machine|not installed|please run \/login|not logged in|invalid api key)\b/i.test(text)) {
+        return false;
+    }
+    return /\b(429|rate limit|timeout|timed out|temporar|temporarily|econnreset|etimedout|enotfound|econnrefused|socket hang up|network|try again|overloaded|busy)\b/i.test(text);
+}
+async function pauseLocalRuntimeRetry(attempt) {
+    const delayMs = attempt <= 1 ? 750 : 1500;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
 }
 function resolveApiKey(profile) {
     // Check profile-stored key first
@@ -4965,7 +5017,7 @@ function expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredM
 }
 async function autoTitleConversation(convId, userMsg, assistantMsg, providerName, modelName, apiKey) {
     try {
-        const llm = (0, index_1.createProvider)(providerName, { apiKey, model: modelName || 'default' });
+        const llm = (0, index_1.createProvider)(providerName, { apiKey, model: modelName || 'default', runtimeMode: 'local_desktop' });
         const resp = await llm.chat({
             messages: [{ role: 'user', content: `Generate a short title (max 6 words, no quotes) for this conversation:\n\nUser: ${userMsg.slice(0, 200)}\nAssistant: ${assistantMsg.slice(0, 200)}` }],
             system: 'You generate short conversation titles. Return ONLY the title, nothing else.',