funolio-agent 1.0.7 → 1.0.48

package/dist/local-server.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startLocalServer = startLocalServer;
 exports.stopLocalServer = stopLocalServer;
+exports.buildChatRuntimeForTest = buildChatRuntimeForTest;
 /**
  * Local HTTP server for desktop-first operation.
  *
@@ -50,7 +51,6 @@ const index_2 = require("./index");
 const approval_1 = require("./approval");
 const config_1 = require("./config");
 const data = __importStar(require("./local-data"));
-const local_funnel_1 = require("./local-funnel");
 const local_import_worker_1 = require("./local-import-worker");
 const clerk_model_1 = require("./clerk-model");
 const workflow_engine_1 = require("./workflow-engine");
@@ -72,9 +72,13 @@ const marketplace_1 = require("./mcp/marketplace");
 const claude_config_writer_1 = require("./mcp/claude-config-writer");
 const subscription_runtime_1 = require("./auth/subscription-runtime");
 const local_memory_search_1 = require("./local-memory-search");
+const local_funnel_1 = require("./local-funnel");
 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"));
@@ -96,6 +100,9 @@ function startLocalServer(opts) {
     const express = requireExpress();
     const app = express();
     const port = opts.port ?? LOCAL_PORT;
+    if ((0, storage_mode_1.isLocalStorageMode)()) {
+        data.purgeLegacyExtractionDataOnce();
+    }
     const cliNormalization = data.normalizeCliProviderConnections();
     if (cliNormalization.updatedIds.length > 0) {
         console.info(`[local-server] normalized ${cliNormalization.updatedIds.length} CLI provider connection(s): ${cliNormalization.updatedIds.join(', ')}`);
@@ -183,6 +190,15 @@ function startLocalServer(opts) {
     catch (err) {
         console.error(chalk_1.default.yellow(`  Failed to reconcile conversation/topic project consistency: ${err}`));
     }
+    try {
+        const interrupted = data.markRunningChatJobsInterrupted();
+        if (interrupted > 0) {
+            console.log(chalk_1.default.gray(`  Marked ${interrupted} interrupted chat job(s) as failed`));
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow(`  Failed to recover interrupted chat jobs: ${err}`));
+    }
     // ─── Health ──────────────────────────────────────────────────
     app.get('/api/health', (_req, res) => {
         try {
@@ -533,6 +549,181 @@ function startLocalServer(opts) {
     function isConnectedMode() {
         return (0, server_runtime_1.getRuntimeConnectionConfig)().connectionMode === 'server';
     }
+    function localTimestamp() {
+        return new Date().toISOString().replace('T', ' ').replace('Z', '');
+    }
+    const MAX_LOCAL_CHAT_JOBS = 3;
+    const runningChatJobControllers = new Map();
+    const finalizeCancelledChatJobMessage = (job) => {
+        const existing = data.getMessage(job.assistant_message_id);
+        const existingContent = (existing?.content || '').trim();
+        data.updateMessage(job.assistant_message_id, {
+            content: existingContent ? `${existingContent}\n\n[Stopped by user]` : '[Stopped by user]',
+            botId: job.bot_id,
+        });
+        data.touchConversationActivity(job.conversation_id);
+    };
+    const parseSsePayloads = async (response, handlers) => {
+        const reader = response.body?.getReader();
+        if (!reader)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentEvent = '';
+        let receivedDone = false;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('event: ')) {
+                    currentEvent = line.slice(7);
+                }
+                else if (line.startsWith('data: ') && currentEvent) {
+                    let dataPayload = null;
+                    try {
+                        dataPayload = JSON.parse(line.slice(6));
+                    }
+                    catch {
+                        currentEvent = '';
+                        continue;
+                    }
+                    if (currentEvent === 'done') {
+                        receivedDone = true;
+                        await handlers.onDone?.(dataPayload);
+                    }
+                    else if (currentEvent === 'error') {
+                        receivedDone = true;
+                        await handlers.onError?.(dataPayload);
+                    }
+                    currentEvent = '';
+                }
+            }
+        }
+        if (!receivedDone) {
+            await handlers.onDone?.({});
+        }
+    };
+    const runQueuedChatJobs = async () => {
+        if (isConnectedMode())
+            return;
+        while (runningChatJobControllers.size < MAX_LOCAL_CHAT_JOBS) {
+            const next = data.listQueuedChatJobs(1)[0];
+            if (!next)
+                return;
+            if (runningChatJobControllers.has(next.id))
+                return;
+            const controller = new AbortController();
+            runningChatJobControllers.set(next.id, controller);
+            data.updateChatJob(next.id, {
+                status: 'running',
+                startedAt: localTimestamp(),
+                error: null,
+            });
+            void (async () => {
+                try {
+                    const job = data.getChatJob(next.id);
+                    if (!job)
+                        return;
+                    const userMessage = data.getMessage(job.user_message_id);
+                    const requestPayload = (() => {
+                        try {
+                            return job.request_json ? JSON.parse(job.request_json) : {};
+                        }
+                        catch {
+                            return {};
+                        }
+                    })();
+                    const response = await fetch(`http://127.0.0.1:${port}/api/chat`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        signal: controller.signal,
+                        body: JSON.stringify({
+                            conversationId: job.conversation_id,
+                            message: userMessage?.content || '',
+                            botId: job.bot_id,
+                            skipUserMessage: true,
+                            pinnedMessageIds: Array.isArray(requestPayload?.pinnedMessageIds) ? requestPayload.pinnedMessageIds : undefined,
+                            topicId: requestPayload?.topicId || undefined,
+                            projectId: requestPayload?.projectId || undefined,
+                            orchestrationEnabled: requestPayload?.orchestrationEnabled !== false,
+                            chatJobId: job.id,
+                            assistantMessageId: job.assistant_message_id,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const body = await response.json().catch(() => ({ error: `HTTP ${response.status}` }));
+                        throw new Error(body.error || `HTTP ${response.status}`);
+                    }
+                    await parseSsePayloads(response, {
+                        onDone: async () => {
+                            const latest = data.getChatJob(next.id);
+                            if (!latest || latest.status === 'cancelled')
+                                return;
+                            data.updateChatJob(next.id, {
+                                status: 'completed',
+                                completedAt: localTimestamp(),
+                                error: null,
+                            });
+                            data.touchConversationActivity(next.conversation_id);
+                        },
+                        onError: async (payload) => {
+                            const latest = data.getChatJob(next.id);
+                            if (!latest || latest.status === 'cancelled')
+                                return;
+                            const errorText = String(payload?.error || 'Background chat failed');
+                            const existing = data.getMessage(next.assistant_message_id);
+                            const existingContent = (existing?.content || '').trim();
+                            data.updateMessage(next.assistant_message_id, {
+                                content: existingContent ? `${existingContent}\n\n**Error:** ${errorText}` : `**Error:** ${errorText}`,
+                                botId: next.bot_id,
+                            });
+                            data.updateChatJob(next.id, {
+                                status: 'failed',
+                                error: errorText,
+                                completedAt: localTimestamp(),
+                            });
+                            data.touchConversationActivity(next.conversation_id);
+                        },
+                    });
+                }
+                catch (err) {
+                    const latest = data.getChatJob(next.id);
+                    if (!latest)
+                        return;
+                    if (latest.status === 'cancelled' || err?.name === 'AbortError') {
+                        finalizeCancelledChatJobMessage(latest);
+                        data.updateChatJob(next.id, {
+                            status: 'cancelled',
+                            cancelledAt: latest.cancelled_at || localTimestamp(),
+                            completedAt: latest.completed_at || localTimestamp(),
+                        });
+                        return;
+                    }
+                    const errorText = err?.message || 'Background chat failed';
+                    const existing = data.getMessage(next.assistant_message_id);
+                    const existingContent = (existing?.content || '').trim();
+                    data.updateMessage(next.assistant_message_id, {
+                        content: existingContent ? `${existingContent}\n\n**Error:** ${errorText}` : `**Error:** ${errorText}`,
+                        botId: next.bot_id,
+                    });
+                    data.updateChatJob(next.id, {
+                        status: 'failed',
+                        error: errorText,
+                        completedAt: localTimestamp(),
+                    });
+                    data.touchConversationActivity(next.conversation_id);
+                }
+                finally {
+                    runningChatJobControllers.delete(next.id);
+                    void runQueuedChatJobs();
+                }
+            })();
+        }
+    };
     async function relayConnectedChat(req, res) {
         if (!isConnectedMode())
             return false;
@@ -678,6 +869,18 @@ function startLocalServer(opts) {
         });
         return state.global.auth;
     }
+    async function exchangeDesktopAuthCode(code, redirectUri) {
+        const response = await fetch(`${config_1.FUNOLIO_API_URL}/api/v1/agent/auth/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ code, redirectUri }),
+        });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            throw new Error(body.error || 'Code exchange failed');
+        }
+        return persistDesktopAuth(body);
+    }
     app.post('/api/auth/clear-session', (_req, res) => {
         try {
             const current = (0, wizard_state_1.loadWizardState)();
@@ -718,8 +921,8 @@ function startLocalServer(opts) {
     app.post('/api/auth/google/start', (_req, res) => {
         try {
             const state = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
-            const redirectUri = 'funolio://wizard?step=login';
-            const authUrl = `${config_1.FUNOLIO_API_URL}/auth/agent?state=${encodeURIComponent(state)}&redirect_uri=${encodeURIComponent(redirectUri)}`;
+            const redirectUri = `http://127.0.0.1:${port}/auth/complete`;
+            const authUrl = `${config_1.FUNOLIO_API_URL}/auth/agent-google?state=${encodeURIComponent(state)}&redirect_uri=${encodeURIComponent(redirectUri)}`;
             res.json({ authUrl, state, redirectUri });
         }
         catch (err) {
@@ -732,21 +935,55 @@ function startLocalServer(opts) {
             if (!code) {
                 return res.status(400).json({ error: 'Code is required' });
             }
-            const response = await fetch(`${config_1.FUNOLIO_API_URL}/api/v1/agent/auth/token`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ code, redirectUri: 'funolio://wizard?step=login' }),
-            });
-            const body = await response.json().catch(() => ({}));
-            if (!response.ok) {
-                return res.status(response.status).json({ error: body.error || 'Code exchange failed' });
-            }
-            res.json(await persistDesktopAuth(body));
+            res.json(await exchangeDesktopAuthCode(code, 'funolio://wizard?step=login'));
         }
         catch (err) {
             res.status(500).json({ error: err.message || 'Code exchange failed' });
         }
     });
+    app.get('/auth/complete', async (req, res) => {
+        const code = typeof req.query?.code === 'string' ? req.query.code.trim() : '';
+        const state = typeof req.query?.state === 'string' ? req.query.state.trim() : '';
+        const escapeHtml = (value) => value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+        if (!code) {
+            return res.status(400).send(`<!doctype html>
+<html><head><meta charset="utf-8" /><title>Funolio Login</title></head>
+<body style="font-family:system-ui,sans-serif;background:#0b1020;color:#f8fafc;display:flex;min-height:100vh;align-items:center;justify-content:center;padding:32px;">
+  <div style="max-width:480px;background:#111827;border:1px solid rgba(148,163,184,.2);border-radius:16px;padding:28px;text-align:center;">
+    <h1 style="margin:0 0 12px;font-size:24px;">Missing login code</h1>
+    <p style="margin:0;color:#cbd5e1;line-height:1.6;">Funolio did not receive an auth code from the website. Close this tab and try Google sign-in again.</p>
+  </div>
+</body></html>`);
+        }
+        try {
+            await exchangeDesktopAuthCode(code, `http://127.0.0.1:${port}/auth/complete`);
+            return res.send(`<!doctype html>
+<html><head><meta charset="utf-8" /><title>Funolio Login Complete</title></head>
+<body style="font-family:system-ui,sans-serif;background:#0b1020;color:#f8fafc;display:flex;min-height:100vh;align-items:center;justify-content:center;padding:32px;">
+  <div style="max-width:480px;background:#111827;border:1px solid rgba(148,163,184,.2);border-radius:16px;padding:28px;text-align:center;">
+    <h1 style="margin:0 0 12px;font-size:24px;">Funolio login complete</h1>
+    <p style="margin:0 0 16px;color:#cbd5e1;line-height:1.6;">Your desktop session is now authenticated${state ? ` for request <code style="color:#a78bfa;">${escapeHtml(state)}</code>` : ''}. Return to the Funolio app.</p>
+    <p style="margin:0;font-size:13px;color:#94a3b8;">You can close this browser tab.</p>
+  </div>
+</body></html>`);
+        }
+        catch (err) {
+            return res.status(500).send(`<!doctype html>
+<html><head><meta charset="utf-8" /><title>Funolio Login Failed</title></head>
+<body style="font-family:system-ui,sans-serif;background:#0b1020;color:#f8fafc;display:flex;min-height:100vh;align-items:center;justify-content:center;padding:32px;">
+  <div style="max-width:560px;background:#111827;border:1px solid rgba(239,68,68,.28);border-radius:16px;padding:28px;text-align:center;">
+    <h1 style="margin:0 0 12px;font-size:24px;color:#f87171;">Funolio login failed</h1>
+    <p style="margin:0 0 16px;color:#fecaca;line-height:1.6;">${escapeHtml(err?.message || 'Code exchange failed')}</p>
+    <p style="margin:0;font-size:13px;color:#94a3b8;">Close this tab and try again.</p>
+  </div>
+</body></html>`);
+        }
+    });
     app.post('/api/auth/forgot-password', async (req, res) => {
         try {
             const email = typeof req.body?.email === 'string' ? req.body.email.trim().toLowerCase() : '';
@@ -771,6 +1008,22 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message || 'Failed to send reset email' });
         }
     });
+    app.use(async (req, res, next) => {
+        const publicPrefixes = ['/api/health', '/api/runtime/', '/api/auth/', '/api/wizard/'];
+        if (publicPrefixes.some((prefix) => req.path === prefix || req.path.startsWith(prefix))) {
+            return next();
+        }
+        try {
+            const auth = await getHydratedDesktopAuth();
+            if (!auth?.hasSession || !auth?.token) {
+                return res.status(401).json({ error: 'Authentication required' });
+            }
+            return next();
+        }
+        catch (err) {
+            return res.status(500).json({ error: err.message || 'Authentication check failed' });
+        }
+    });
     app.get('/api/providers/catalog', (_req, res) => {
         try {
             res.json({ providers: (0, wizard_support_1.getProviderCatalog)() });
@@ -1113,13 +1366,25 @@ function startLocalServer(opts) {
                     const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
                     const auth = await getHydratedDesktopAuth();
                     const profile = await (0, server_adapter_1.getServerBot)(auth, runtime, req.params.id);
-                    return res.json({ profile, conversationCount: 0 });
+                    return res.json({ profile, conversationCount: 0, messageCount: 0, recentConversations: [] });
                 }
                 const profile = data.getAgentProfile(req.params.id);
                 if (!profile)
                     return res.status(404).json({ error: 'Not found' });
                 const convCount = data.countConversations(req.params.id);
-                res.json({ profile, conversationCount: convCount });
+                const messageCount = data.countMessagesForBot(req.params.id);
+                const recentConversations = data.listBotConversationActivity(req.params.id, 8).map((conversation) => ({
+                    id: conversation.id,
+                    agent_id: conversation.agent_id,
+                    title: conversation.title,
+                    updated_at: conversation.updated_at,
+                    created_at: conversation.created_at,
+                    message_count: conversation.message_count,
+                    bot_message_count: conversation.bot_message_count,
+                    bot_last_message_at: conversation.bot_last_message_at,
+                    project_name: conversation.project_name,
+                }));
+                res.json({ profile, conversationCount: convCount, messageCount, recentConversations });
             }
             catch (err) {
                 res.status(500).json({ error: err.message });
@@ -1565,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');
@@ -1774,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()) {
@@ -2064,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, {
@@ -2073,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
@@ -2141,11 +2437,161 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    app.post('/api/chat/jobs', async (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.status(501).json({ error: 'Background chat jobs are local-mode only' });
+            }
+            const { conversationId, message, botId, pinnedMessageIds, topicId, projectId, orchestrationEnabled, } = req.body || {};
+            if (!message || !String(message).trim()) {
+                return res.status(400).json({ error: 'message is required' });
+            }
+            let profile = botId ? data.getAgentProfile(String(botId)) : data.getDefaultAgentProfile();
+            if (!profile) {
+                return res.status(400).json({ error: 'No bot configured. Create one first.' });
+            }
+            const shouldUseOrchestratorMode = orchestrationEnabled !== false && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
+            if (shouldUseOrchestratorMode) {
+                return res.status(400).json({ error: 'Background chat jobs do not support orchestrator mode yet.' });
+            }
+            let convId = conversationId ? String(conversationId) : '';
+            if (convId) {
+                const latestJob = data.getLatestConversationChatJob(convId);
+                if (latestJob && (latestJob.status === 'queued' || latestJob.status === 'running')) {
+                    return res.status(409).json({ error: 'This conversation already has a pending response.' });
+                }
+            }
+            if (!convId) {
+                let topicProjectId = null;
+                if (topicId) {
+                    const topic = data.getTopic(String(topicId));
+                    topicProjectId = topic?.project_id ?? null;
+                }
+                const requestedProjectId = (projectId ? String(projectId) : null) || topicProjectId;
+                const conv = data.createConversation(profile.id, '', 'local', {
+                    projectId: requestedProjectId,
+                });
+                convId = conv.id;
+            }
+            if (topicId && convId) {
+                try {
+                    data.upsertConversationTopicSegment(convId, String(topicId));
+                }
+                catch { /* best effort */ }
+            }
+            if (!topicId && projectId && convId) {
+                const selectedProject = data.getProject(String(projectId));
+                if (selectedProject) {
+                    data.updateConversation(convId, {
+                        projectId: selectedProject.id,
+                        projectName: selectedProject.name,
+                    });
+                }
+            }
+            const savedUserMessage = data.addMessage(convId, 'user', String(message));
+            (0, context_window_1.incrementTurnCount)(convId);
+            const assistantMessage = data.addMessage(convId, 'assistant', '', profile.model || undefined, undefined, profile.id, profile.name);
+            const conv = data.getConversation(convId);
+            if (conv && !conv.title?.trim() && (conv.turn_count || 0) <= 1) {
+                const shortTitle = String(message).slice(0, 60).replace(/\n/g, ' ').trim();
+                data.updateConversation(convId, { title: shortTitle || 'New Chat' });
+            }
+            const job = data.createChatJob({
+                conversationId: convId,
+                userMessageId: savedUserMessage.id,
+                assistantMessageId: assistantMessage.id,
+                botId: profile.id,
+                status: 'queued',
+                requestJson: JSON.stringify({
+                    pinnedMessageIds: Array.isArray(pinnedMessageIds) ? pinnedMessageIds : [],
+                    topicId: topicId ? String(topicId) : null,
+                    projectId: projectId ? String(projectId) : null,
+                    orchestrationEnabled: orchestrationEnabled !== false,
+                }),
+            });
+            void runQueuedChatJobs();
+            res.status(201).json({
+                ok: true,
+                conversationId: convId,
+                userMessageId: savedUserMessage.id,
+                assistantMessageId: assistantMessage.id,
+                jobId: job.id,
+                status: job.status,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/chat/jobs/:id/cancel', async (req, res) => {
+        try {
+            const job = data.getChatJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Not found' });
+            if (job.status === 'completed' || job.status === 'failed' || job.status === 'cancelled') {
+                return res.json({ ok: true, status: job.status });
+            }
+            const ts = localTimestamp();
+            data.updateChatJob(job.id, {
+                status: 'cancelled',
+                cancelledAt: ts,
+                completedAt: ts,
+            });
+            const controller = runningChatJobControllers.get(job.id);
+            if (controller) {
+                controller.abort();
+            }
+            else {
+                finalizeCancelledChatJobMessage(job);
+                data.touchConversationActivity(job.conversation_id);
+            }
+            res.json({ ok: true, status: 'cancelled' });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // ─── Chat (SSE streaming) ──────────────────────────────────
+    app.post('/api/conversations/:id/chat-job/cancel', async (req, res) => {
+        try {
+            const latestJob = data.getLatestConversationChatJob(req.params.id);
+            if (!latestJob)
+                return res.status(404).json({ error: 'Chat job not found' });
+            if (latestJob.status === 'completed' || latestJob.status === 'failed' || latestJob.status === 'cancelled') {
+                return res.json({ ok: true, status: latestJob.status, jobId: latestJob.id });
+            }
+            const ts = localTimestamp();
+            data.updateChatJob(latestJob.id, {
+                status: 'cancelled',
+                cancelledAt: ts,
+                completedAt: ts,
+            });
+            const controller = runningChatJobControllers.get(latestJob.id);
+            if (controller) {
+                controller.abort();
+            }
+            else {
+                finalizeCancelledChatJobMessage(latestJob);
+                data.touchConversationActivity(latestJob.conversation_id);
+                void runQueuedChatJobs();
+            }
+            res.json({ ok: true, status: 'cancelled', jobId: latestJob.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.post('/api/chat', async (req, res) => {
         const activityErrorContext = {};
+        const routeAbortController = new AbortController();
+        let responseEnded = false;
+        const abortOnClientClose = () => {
+            responseEnded = true;
+            routeAbortController.abort();
+        };
+        req.on('close', abortOnClientClose);
         try {
-            const { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId } = 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)) {
@@ -2203,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;
@@ -2210,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,
@@ -2223,6 +2671,36 @@ function startLocalServer(opts) {
                     // Best effort only
                 }
             };
+            const workerBotByName = new Map();
+            const resolveWorkerBotId = (agentName) => {
+                const key = String(agentName || '').trim().toLowerCase();
+                if (!key)
+                    return null;
+                if (workerBotByName.has(key))
+                    return workerBotByName.get(key) || null;
+                const match = data.listAgentProfiles().find((agent) => agent.name.trim().toLowerCase() === key);
+                const resolved = match?.id || null;
+                workerBotByName.set(key, resolved || '');
+                return resolved;
+            };
+            const recordWorkerActivity = (activityType, event, payload, summary) => {
+                try {
+                    data.createMessageActivity({
+                        conversationId: convId,
+                        messageId: assistantMessageId ? String(assistantMessageId) : null,
+                        streamId: activityStreamId,
+                        botId: resolveWorkerBotId(event.agentName) || null,
+                        agentName: event.agentName || null,
+                        activityType,
+                        summary: summary || null,
+                        payload,
+                        expiresAt: activityExpiresAt,
+                    });
+                }
+                catch {
+                    // Best effort only
+                }
+            };
             // Save user message (skip if multi-bot call where first bot already saved it)
             let savedUserMessage = null;
             if (!skipUserMessage) {
@@ -2232,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)({
@@ -2251,9 +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 ─────────────────────────
-            if ((0, orchestrator_profile_1.isOrchestratorProfile)(profile)) {
-                const clerk = (0, clerk_model_1.getClerk)();
+            const shouldUseOrchestratorMode = orchestrationEnabled !== false && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
+            if (shouldUseOrchestratorMode) {
+                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({
@@ -2262,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);
@@ -2280,6 +2763,8 @@ function startLocalServer(opts) {
                     'X-Conversation-Id': convId,
                 });
                 const sendEvent = (event, payload) => {
+                    if (responseEnded)
+                        return;
                     res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
                 };
                 let orchestratorRuntimeLabel = '';
@@ -2290,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);
@@ -2302,6 +2787,7 @@ function startLocalServer(opts) {
                 let lastProgressChat = '';
                 let lastProgressActivity = '';
                 let selfExecuteStreamed = false;
+                let hasWorkerActivity = false;
                 try {
                     let lastInterimMessage = '';
                     const response = await orchestrator.handleUserMessage(message, convId, {
@@ -2311,21 +2797,102 @@ function startLocalServer(opts) {
                         workflowTemplateId: workflowTemplateId || undefined,
                         onWorkerChunk: (event) => {
                             if (event.type === 'step_start') {
+                                hasWorkerActivity = true;
+                                recordWorkerActivity('worker_step_start', event, {
+                                    stepId: event.stepId,
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                });
                                 sendEvent('worker_step_start', {
                                     stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
                                     agentName: event.agentName,
                                     description: event.description,
                                     stepIndex: event.stepIndex,
                                     totalSteps: event.totalSteps,
                                 });
                             }
+                            else if (event.type === 'worker_chunk') {
+                                hasWorkerActivity = true;
+                                recordWorkerActivity('worker_chunk', event, {
+                                    stepId: event.stepId,
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    text: event.text,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                });
+                                sendEvent('worker_chunk', {
+                                    stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    text: event.text,
+                                });
+                            }
+                            else if (event.type === 'worker_tool_call') {
+                                hasWorkerActivity = true;
+                                recordWorkerActivity('worker_tool_call', event, {
+                                    stepId: event.stepId,
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    toolCallId: event.toolCallId,
+                                    toolName: event.toolName,
+                                    toolArguments: event.toolArguments,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                });
+                                sendEvent('worker_tool_call', {
+                                    stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    toolCallId: event.toolCallId,
+                                    toolName: event.toolName,
+                                    toolArguments: event.toolArguments,
+                                });
+                            }
+                            else if (event.type === 'worker_tool_result') {
+                                hasWorkerActivity = true;
+                                recordWorkerActivity('worker_tool_result', event, {
+                                    stepId: event.stepId,
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    toolCallId: event.toolCallId,
+                                    toolName: event.toolName,
+                                    toolOutput: event.toolOutput,
+                                    toolIsError: event.toolIsError,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                });
+                                sendEvent('worker_tool_result', {
+                                    stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    toolCallId: event.toolCallId,
+                                    toolName: event.toolName,
+                                    toolOutput: event.toolOutput,
+                                    toolIsError: event.toolIsError,
+                                });
+                            }
                             else if (event.type === 'chunk') {
-                                // Stream all text directly to main bubble — no worker cards
                                 selfExecuteStreamed = true;
                                 sendEvent('chunk', { text: event.text });
                             }
                             else if (event.type === 'tool_call') {
-                                // Show tool activity inline in main bubble
                                 selfExecuteStreamed = true;
                                 sendEvent('chunk', { text: `\n> Running ${event.toolName}...\n` });
                             }
@@ -2334,7 +2901,27 @@ function startLocalServer(opts) {
                                 sendEvent('chunk', { text: `> [${icon}] ${event.toolName} completed\n` });
                             }
                             else if (event.type === 'step_done') {
-                                // Step lifecycle — no special handling needed
+                                hasWorkerActivity = true;
+                                recordWorkerActivity('worker_step_done', event, {
+                                    stepId: event.stepId,
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    status: event.status,
+                                    summary: event.summary,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                });
+                                sendEvent('worker_step_done', {
+                                    stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    status: event.status,
+                                    summary: event.summary,
+                                });
                             }
                         },
                         onProgress: (status) => {
@@ -2358,7 +2945,7 @@ function startLocalServer(opts) {
                                 sendEvent('orchestrator_message', {
                                     text: interimMessage,
                                     botId: profile.id,
-                                    agentName: profile.name || 'Project Manager',
+                                    agentName: 'Orchestrator',
                                 });
                             }
                         },
@@ -2369,40 +2956,73 @@ function startLocalServer(opts) {
                         },
                     });
                     // Save O's response (no incrementTurnCount — Fix #1: user message already incremented it)
-                    const savedMessage = data.addMessage(convId, 'assistant', response, orchestratorRuntimeLabel || undefined, undefined, profile.id, profile.name || 'Project Manager');
-                    data.attachMessageActivitiesToMessage(activityStreamId, savedMessage.id);
-                    data.createMessageActivity({
-                        conversationId: convId,
-                        messageId: savedMessage.id,
-                        botId: profile.id,
-                        agentName: profile.name || 'Project Manager',
-                        activityType: 'message',
-                        summary: 'Final orchestrator response',
-                        payload: { content: response },
-                        expiresAt: activityExpiresAt,
-                    });
+                    const responseMeta = orchestrator.getLastResponseMeta();
+                    const finalAgentName = responseMeta?.agentName || 'Orchestrator';
+                    const finalBotId = responseMeta?.botId || (finalAgentName === 'Orchestrator' ? profile.id : undefined);
+                    const finalModelLabel = responseMeta?.modelLabel || orchestratorRuntimeLabel || undefined;
+                    const splitFinalMessage = hasWorkerActivity && finalAgentName === 'Clerk';
+                    if (splitFinalMessage) {
+                        const orchestratorMessage = data.addMessage(convId, 'assistant', '', orchestratorRuntimeLabel || buildConfiguredMessageModel(profile), undefined, profile.id, 'Orchestrator');
+                        data.attachMessageActivitiesToMessage(activityStreamId, orchestratorMessage.id);
+                        const clerkMessage = data.addMessage(convId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
+                        data.createMessageActivity({
+                            conversationId: convId,
+                            messageId: clerkMessage.id,
+                            botId: finalBotId,
+                            agentName: finalAgentName,
+                            activityType: 'message',
+                            summary: 'Final assistant response',
+                            payload: { content: response },
+                            expiresAt: activityExpiresAt,
+                        });
+                    }
+                    else {
+                        const savedMessage = data.addMessage(convId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
+                        data.attachMessageActivitiesToMessage(activityStreamId, savedMessage.id);
+                        data.createMessageActivity({
+                            conversationId: convId,
+                            messageId: savedMessage.id,
+                            botId: finalBotId,
+                            agentName: finalAgentName,
+                            activityType: 'message',
+                            summary: 'Final orchestrator response',
+                            payload: { content: response },
+                            expiresAt: activityExpiresAt,
+                        });
+                    }
                     // Emit chunk + done events using the same SSE contract as normal chat
                     // Skip the final bulk chunk if we already streamed via worker_chunk (execute_self)
-                    if (!selfExecuteStreamed) {
+                    if (!selfExecuteStreamed && !splitFinalMessage) {
                         sendEvent('chunk', { text: response });
                     }
                     sendEvent('done', {
                         conversationId: convId,
                         content: response,
-                        ...(orchestratorRuntimePayload ? { runtime: orchestratorRuntimePayload } : {}),
+                        agentName: finalAgentName,
+                        botId: finalBotId,
+                        separateFinalMessage: splitFinalMessage,
+                        ...((responseMeta?.modelLabel || orchestratorRuntimePayload)
+                            ? {
+                                runtime: {
+                                    ...(orchestratorRuntimePayload || {}),
+                                    ...(responseMeta?.modelLabel ? { model: responseMeta.modelLabel } : {}),
+                                },
+                            }
+                            : {}),
                         tokenUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, isApproximate: true, source: 'heuristic' },
                     });
+                    responseEnded = true;
                     res.end();
-                    // Background post-response processing
-                    (0, local_funnel_1.scheduleFunnelProcessing)(convId);
                     if ((0, context_window_1.shouldSummarize)(convId)) {
                         const catalog = (0, backfill_1.buildProjectTopicCatalog)();
                         (0, summarization_pipeline_1.runSummarization)(convId, catalog).catch(err => console.error(chalk_1.default.yellow(`  [summarization] ${err.message}`)));
                     }
+                    (0, local_funnel_1.scheduleFunnelProcessing)(convId);
                 }
                 catch (orchErr) {
                     recordActivity('error', { error: orchErr.message }, orchErr.message);
                     sendEvent('error', { type: 'error', error: orchErr.message });
+                    responseEnded = true;
                     res.end();
                 }
                 return;
@@ -2414,15 +3034,18 @@ function startLocalServer(opts) {
             const effectiveTimezone = configuredTz && configuredTz.toLowerCase() !== 'system'
                 ? configuredTz
                 : Intl.DateTimeFormat().resolvedOptions().timeZone;
-            const allToolDefs = (0, index_2.getAllToolDefinitions)(mcpManager);
+            const unrestrictedCliProfile = index_1.CLI_PROVIDERS.has(profile.provider);
+            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 = expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredMcpTools);
+            const allowedToolNames = unrestrictedCliProfile
+                ? new Set(allToolDefs.map((tool) => tool.name))
+                : expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredMcpTools);
             const toolDefs = allToolDefs.filter((tool) => allowedToolNames.has(tool.name));
             // 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;
@@ -2443,14 +3066,15 @@ function startLocalServer(opts) {
                     availableTools: toolDefs.map((tool) => ({ name: tool.name, description: tool.description })),
                 });
                 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 {
                 // 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();
@@ -2508,8 +3132,11 @@ function startLocalServer(opts) {
                 }
                 catch { /* best-effort */ }
             }
-            // Resolve LLM runtime: for claude-cli/codex-cli, try Subscription-API first
-            // and fall back to Subscription-CLI automatically if API fails.
+            // Resolve LLM runtime.
+            // Desktop local mode intentionally supports only:
+            // - Subscription CLI
+            // - API Key
+            // We do not use subscription-token API routing for local CLI bots.
             const runtime = await buildChatRuntime(profile);
             let activeProviderName = runtime.providerName;
             let activeModelName = runtime.model;
@@ -2518,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.` });
             }
@@ -2537,12 +3171,17 @@ 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,
             });
             const toolManifest = toolDefs
                 .map(t => `- ${t.name}: ${t.description}`)
                 .join('\n');
             if (toolManifest.trim()) {
-                systemPrompt += '\n\n[Available Tools]\nOnly the following tools are enabled for this bot in the current runtime:\n' + toolManifest;
+                systemPrompt += unrestrictedCliProfile
+                    ? '\n\n[Available Tools]\nThe following tools are available in the current runtime:\n' + toolManifest
+                    : '\n\n[Available Tools]\nOnly the following tools are enabled for this bot in the current runtime:\n' + toolManifest;
             }
             // Inject pinned messages as context (user-selected cross-bot references)
             if (pinnedMessageIds && Array.isArray(pinnedMessageIds) && pinnedMessageIds.length > 0) {
@@ -2580,6 +3219,8 @@ function startLocalServer(opts) {
                 'X-Conversation-Id': convId,
             });
             const sendEvent = (event, payload) => {
+                if (responseEnded)
+                    return;
                 res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
             };
             const approxInputTokens = (0, token_counter_1.estimatePromptInputTokens)({
@@ -2591,6 +3232,7 @@ function startLocalServer(opts) {
             sendEvent('meta', {
                 conversationId: convId,
                 botId: profile.id,
+                assistantMessageId: assistantMessageId || null,
                 runtime: runtimePayload(),
                 tokenUsage: {
                     approxInputTokens,
@@ -2608,12 +3250,64 @@ 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 = () => {
+                if (!chatJobId)
+                    return;
+                const currentJob = data.getChatJob(String(chatJobId));
+                if (currentJob?.status === 'cancelled') {
+                    routeAbortController.abort();
+                    const abortErr = new Error('aborted');
+                    abortErr.name = 'AbortError';
+                    throw abortErr;
+                }
+            };
+            const persistAssistantPartial = (force = false) => {
+                if (!assistantMessageId)
+                    return;
+                const nowMs = Date.now();
+                const nextContent = streamedContent || '';
+                if (!force && nextContent === partialPersistedContent)
+                    return;
+                if (!force && nowMs - partialPersistedAt < 1500)
+                    return;
+                partialPersistedContent = nextContent;
+                partialPersistedAt = nowMs;
+                const modelWithRuntime = [
+                    activeModelName || profile.model || '',
+                    runtimeModeLabel(activeRuntimeMode, activeRuntimeSource),
+                ].filter(Boolean).join(' | ');
+                data.updateMessage(assistantMessageId, {
+                    content: nextContent,
+                    model: modelWithRuntime || null,
+                    botId: profile.id,
+                    agentName: profile.name,
+                });
+            };
             // Agentic loop
             let fullContent = '';
             let streamedContent = '';
             let streamedAnyChunk = false;
             let iteration = 0;
-            const MAX_ITERATIONS = 20;
+            const MAX_ITERATIONS = 10; // Phase 1d: reduced from 20
             let totalInputTokens = 0;
             let totalOutputTokens = 0;
             let hasExactUsage = false;
@@ -2621,250 +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;
-                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,
-                    thinkingEnabled,
-                    onChunk: async (chunk) => {
-                        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;
-                        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 (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.`));
+                        if (result.usage) {
+                            totalInputTokens += result.usage.inputTokens || 0;
+                            totalOutputTokens += result.usage.outputTokens || 0;
+                            hasExactUsage = true;
                         }
+                        fullContent = (result.content || '').trim();
+                        break;
+                    }
+                    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,
-                            runtime: runtimePayload(),
-                        });
-                        recordActivity('status', {
-                            phase: 'thinking',
-                            detail: fallbackMsg,
-                            runtime: runtimePayload(),
-                        }, fallbackMsg);
-                        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}...`);
+                        }, 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;
                     }
-                }
-                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) {
-                        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 = (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', {
@@ -2885,7 +3588,14 @@ function startLocalServer(opts) {
                 activeModelName || profile.model || '',
                 runtimeModeLabel(activeRuntimeMode, activeRuntimeSource),
             ].filter(Boolean).join(' | ');
-            const savedMessage = data.addMessage(convId, 'assistant', persistedContent, modelWithRuntime || undefined, undefined, profile.id, profile.name);
+            const savedMessage = assistantMessageId
+                ? (data.updateMessage(assistantMessageId, {
+                    content: persistedContent,
+                    model: modelWithRuntime || null,
+                    botId: profile.id,
+                    agentName: profile.name,
+                }) || data.addMessage(convId, 'assistant', persistedContent, modelWithRuntime || undefined, undefined, profile.id, profile.name))
+                : data.addMessage(convId, 'assistant', persistedContent, modelWithRuntime || undefined, undefined, profile.id, profile.name);
             data.attachMessageActivitiesToMessage(activityStreamId, savedMessage.id);
             data.createMessageActivity({
                 conversationId: convId,
@@ -2913,6 +3623,7 @@ function startLocalServer(opts) {
                     approxInputTokens,
                 },
             });
+            responseEnded = true;
             res.end();
             // Background processing: auto-title + funnel extraction
             const conv = data.getConversation(convId);
@@ -2926,13 +3637,13 @@ function startLocalServer(opts) {
                     autoTitleConversation(convId, message, persistedContent, activeProviderName, activeModelName, activeApiKey);
                 }
             }
-            (0, local_funnel_1.scheduleFunnelProcessing)(convId);
             // Summarization: trigger after every 5-turn boundary (fire-and-forget)
             // Includes topic creation/linking + project verification
             if ((0, context_window_1.shouldSummarize)(convId)) {
                 const catalog = (0, backfill_1.buildProjectTopicCatalog)();
                 (0, summarization_pipeline_1.runSummarization)(convId, catalog).catch(err => console.error(chalk_1.default.yellow(`  [summarization] ${err.message}`)));
             }
+            (0, local_funnel_1.scheduleFunnelProcessing)(convId);
         }
         catch (err) {
             console.error(chalk_1.default.red(`Chat error: ${err.message}`));
@@ -2940,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,
@@ -2969,64 +3681,19 @@ function startLocalServer(opts) {
                         providerId: err?.providerId || null,
                         cli: err?.cli || null,
                     })}\n\n`);
+                    responseEnded = true;
                     res.end();
                 }
                 catch { /* connection already closed */ }
             }
         }
+        finally {
+            req.off?.('close', abortOnClientClose);
+        }
     });
     // ─── Memory Facts ───────────────────────────────────────────
-    app.get('/api/memory/facts', (req, res) => {
-        try {
-            const { agentId, factType, limit, offset, search, groupByProject } = req.query;
-            const limitN = limit ? parseInt(limit) : 100;
-            const offsetN = offset ? parseInt(offset) : 0;
-            const grouped = groupByProject === '1' || groupByProject === 'true';
-            if (grouped) {
-                const db = data.getDb();
-                const wheres = [];
-                const params = [];
-                if (agentId) {
-                    wheres.push('f.agent_id = ?');
-                    params.push(agentId);
-                }
-                if (factType) {
-                    wheres.push('f.fact_type = ?');
-                    params.push(factType);
-                }
-                if (search) {
-                    wheres.push('(f.content LIKE ? OR COALESCE(c.title, \'\') LIKE ?)');
-                    params.push(`%${search}%`, `%${search}%`);
-                }
-                let sql = `
-          SELECT f.*, c.title as conversation_title, c.project_id,
-                 COALESCE(p.name, '${data.UNASSIGNED_PROJECT_NAME}') as project_name
-          FROM memory_fact f
-          LEFT JOIN conversation c ON f.conversation_id = c.id
-          LEFT JOIN project p ON c.project_id = p.id
-        `;
-                if (wheres.length > 0)
-                    sql += ` WHERE ${wheres.join(' AND ')}`;
-                sql += ' ORDER BY f.created_at DESC LIMIT ? OFFSET ?';
-                params.push(limitN, offsetN);
-                const rows = db.prepare(sql).all(...params);
-                return res.json(rows);
-            }
-            if (search && agentId) {
-                const facts = data.searchMemoryFacts(search, agentId, limitN);
-                return res.json(facts);
-            }
-            const facts = data.listMemoryFacts({
-                agentId: agentId || undefined,
-                factType: factType || undefined,
-                limit: limitN,
-                offset: offsetN,
-            });
-            res.json(facts);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.get('/api/memory/facts', (_req, res) => {
+        res.json([]);
     });
     app.get('/api/memory/search', (req, res) => {
         try {
@@ -3054,120 +3721,23 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
-    app.delete('/api/memory/facts/:id', (req, res) => {
-        try {
-            const deleted = data.deleteMemoryFact(req.params.id);
-            if (!deleted)
-                return res.status(404).json({ error: 'Not found' });
-            res.json({ ok: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.delete('/api/memory/facts/:id', (_req, res) => {
+        res.json({ ok: true });
     });
-    app.get('/api/memory/entities', (req, res) => {
-        try {
-            const { agentId } = req.query;
-            if (!agentId)
-                return res.status(400).json({ error: 'agentId required' });
-            const graph = data.getEntityGraph(agentId);
-            res.json(graph);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.get('/api/memory/entities', (_req, res) => {
+        res.json({ nodes: [], edges: [] });
     });
-    app.get('/api/memory/decisions', (req, res) => {
-        try {
-            const { conversationId, limit, groupByProject } = req.query;
-            const grouped = groupByProject === '1' || groupByProject === 'true';
-            if (grouped) {
-                const db = data.getDb();
-                const params = [];
-                let sql = `
-          SELECT d.*, c.title as conversation_title, c.project_id,
-                 COALESCE(p.name, '${data.UNASSIGNED_PROJECT_NAME}') as project_name
-          FROM decision d
-          LEFT JOIN conversation c ON d.conversation_id = c.id
-          LEFT JOIN project p ON c.project_id = p.id
-        `;
-                if (conversationId) {
-                    sql += ' WHERE d.conversation_id = ?';
-                    params.push(conversationId);
-                }
-                sql += ' ORDER BY d.created_at DESC LIMIT ?';
-                params.push(limit ? parseInt(limit) : 200);
-                const rows = db.prepare(sql).all(...params);
-                return res.json(rows);
-            }
-            const decisions = data.listDecisions({
-                conversationId: conversationId || undefined,
-                limit: limit ? parseInt(limit) : undefined,
-            });
-            res.json(decisions);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.get('/api/memory/decisions', (_req, res) => {
+        res.json([]);
     });
-    app.delete('/api/memory/decisions/:id', (req, res) => {
-        try {
-            const deleted = data.deleteDecision(req.params.id);
-            if (!deleted)
-                return res.status(404).json({ error: 'Not found' });
-            res.json({ ok: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.delete('/api/memory/decisions/:id', (_req, res) => {
+        res.json({ ok: true });
     });
-    app.get('/api/memory/action-items', (req, res) => {
-        try {
-            const { status, limit, groupByProject } = req.query;
-            const grouped = groupByProject === '1' || groupByProject === 'true';
-            if (grouped) {
-                const db = data.getDb();
-                const params = [];
-                const wheres = [];
-                if (status) {
-                    wheres.push('a.status = ?');
-                    params.push(status);
-                }
-                let sql = `
-          SELECT a.*, c.title as conversation_title, c.project_id,
-                 COALESCE(p.name, '${data.UNASSIGNED_PROJECT_NAME}') as project_name
-          FROM action_item a
-          LEFT JOIN conversation c ON a.conversation_id = c.id
-          LEFT JOIN project p ON c.project_id = p.id
-        `;
-                if (wheres.length > 0) {
-                    sql += ` WHERE ${wheres.join(' AND ')}`;
-                }
-                sql += ' ORDER BY a.created_at DESC LIMIT ?';
-                params.push(limit ? parseInt(limit) : 200);
-                const rows = db.prepare(sql).all(...params);
-                return res.json(rows);
-            }
-            const items = data.listActionItems({
-                status: status || undefined,
-                limit: limit ? parseInt(limit) : undefined,
-            });
-            res.json(items);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.get('/api/memory/action-items', (_req, res) => {
+        res.json([]);
     });
-    app.delete('/api/memory/action-items/:id', (req, res) => {
-        try {
-            const deleted = data.deleteActionItem(req.params.id);
-            if (!deleted)
-                return res.status(404).json({ error: 'Not found' });
-            res.json({ ok: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+    app.delete('/api/memory/action-items/:id', (_req, res) => {
+        res.json({ ok: true });
     });
     // ─── Settings ───────────────────────────────────────────────
     app.get('/api/settings', (_req, res) => {
@@ -3272,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();
@@ -3289,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();
@@ -3307,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();
@@ -3334,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',
@@ -3366,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);
         }
@@ -3376,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 });
         }
@@ -3610,24 +4181,9 @@ function startLocalServer(opts) {
             const ids = convIds.map(c => c.id);
             const placeholders = ids.map(() => '?').join(',');
             const result = {};
-            if (!type || type === 'decisions') {
-                result.decisions = db.prepare(`SELECT d.*, c.title as conversation_title FROM decision d
-           LEFT JOIN conversation c ON d.conversation_id = c.id
-           WHERE d.conversation_id IN (${placeholders})
-           ORDER BY d.created_at DESC`).all(...ids);
-            }
-            if (!type || type === 'actionItems') {
-                result.actionItems = db.prepare(`SELECT a.*, c.title as conversation_title FROM action_item a
-           LEFT JOIN conversation c ON a.conversation_id = c.id
-           WHERE a.conversation_id IN (${placeholders})
-           ORDER BY a.created_at DESC`).all(...ids);
-            }
-            if (!type || type === 'facts') {
-                result.facts = db.prepare(`SELECT f.*, c.title as conversation_title FROM memory_fact f
-           LEFT JOIN conversation c ON f.conversation_id = c.id
-           WHERE f.conversation_id IN (${placeholders})
-           ORDER BY f.created_at DESC`).all(...ids);
-            }
+            result.decisions = [];
+            result.actionItems = [];
+            result.facts = [];
             if (!type || type === 'summaries') {
                 result.summaries = db.prepare(`SELECT s.*, c.title as conversation_title FROM conversation_summary s
            LEFT JOIN conversation c ON s.conversation_id = c.id
@@ -4032,6 +4588,7 @@ function startLocalServer(opts) {
     mcpManager.autoLaunch().catch((err) => {
         console.error(chalk_1.default.yellow(`[MCP] Auto-launch error: ${err.message}`));
     });
+    void runQueuedChatJobs();
     /**
      * GET /api/mcp/catalog — full marketplace catalog with install status
      */
@@ -4121,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', () => {
@@ -4152,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',
     };
@@ -4196,16 +4748,17 @@ async function buildChatRuntime(profile) {
 function runtimeModeLabel(mode, runtimeSource) {
     if (mode === 'subscription-cli')
         return 'Subscription CLI';
+    if (mode === 'subscription-api')
+        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) {
@@ -4214,17 +4767,22 @@ function configuredRuntimeLabelForProfile(profile) {
     const directConnection = profile.provider_connection_id
         ? data.listProviderConnections().find((row) => row.id === profile.provider_connection_id)
         : undefined;
+    if (profile.provider === 'claude-cli' || profile.provider === 'codex-cli') {
+        return 'Subscription CLI';
+    }
     const connection = directConnection;
     if (connection) {
         if (connection.access_mode === 'cli')
             return 'Subscription CLI';
+        if (connection.access_mode === 'oauth')
+            return 'Subscription API (Token)';
         return 'API Key';
     }
-    if (profile.provider === 'claude-cli' || profile.provider === 'codex-cli') {
-        return 'Subscription CLI';
-    }
     return 'API Key';
 }
+async function buildChatRuntimeForTest(profile) {
+    return buildChatRuntime(profile);
+}
 function buildConfiguredMessageModel(profile) {
     if (!profile)
         return '';
@@ -4372,32 +4930,30 @@ 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
     if (profile.api_key_enc)
         return profile.api_key_enc;
+    // Prefer the bot's explicitly assigned provider connection when present.
+    if (profile.provider_connection_id) {
+        const directConnection = data.getProviderConnection(profile.provider_connection_id);
+        if (directConnection?.api_key_enc)
+            return directConnection.api_key_enc;
+    }
     // Fall back to DB-backed provider connections
     const providerConnection = data.findProviderConnection(profile.provider);
     if (providerConnection?.api_key_enc)
@@ -4461,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.',