funolio-agent 1.0.7 → 1.0.47

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,11 @@ 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 server_adapter_1 = require("./server-adapter");
 const wizard_support_1 = require("./wizard-support");
 const chalk_1 = __importDefault(require("chalk"));
@@ -96,6 +98,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 +188,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 +547,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 +867,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 +919,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 +933,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 +1006,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 +1364,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 });
@@ -2141,11 +2404,158 @@ 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 = () => routeAbortController.abort();
+        req.on('close', abortOnClientClose);
         try {
-            const { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId } = req.body;
+            const { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId, orchestrationEnabled, chatJobId, assistantMessageId, } = req.body;
             if (!message)
                 return res.status(400).json({ error: 'message is required' });
             if (await relayConnectedChat(req, res)) {
@@ -2223,6 +2633,35 @@ 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,
+                        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) {
@@ -2252,7 +2691,8 @@ function startLocalServer(opts) {
                 }
             }
             // ─── Orchestrator Mode Branch ─────────────────────────
-            if ((0, orchestrator_profile_1.isOrchestratorProfile)(profile)) {
+            const shouldUseOrchestratorMode = orchestrationEnabled !== false && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
+            if (shouldUseOrchestratorMode) {
                 const clerk = (0, clerk_model_1.getClerk)();
                 if (!clerk) {
                     // Fix #2: Do not silently fall through to direct chat — return a clear error
@@ -2280,6 +2720,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 = '';
@@ -2302,6 +2744,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 +2754,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 +2858,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 +2902,7 @@ function startLocalServer(opts) {
                                 sendEvent('orchestrator_message', {
                                     text: interimMessage,
                                     botId: profile.id,
-                                    agentName: profile.name || 'Project Manager',
+                                    agentName: 'Orchestrator',
                                 });
                             }
                         },
@@ -2369,40 +2913,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,10 +2991,13 @@ function startLocalServer(opts) {
             const effectiveTimezone = configuredTz && configuredTz.toLowerCase() !== 'system'
                 ? configuredTz
                 : Intl.DateTimeFormat().resolvedOptions().timeZone;
+            const unrestrictedCliProfile = index_1.CLI_PROVIDERS.has(profile.provider);
             const allToolDefs = (0, index_2.getAllToolDefinitions)(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;
@@ -2443,7 +3023,7 @@ 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
@@ -2508,8 +3088,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;
@@ -2537,12 +3120,16 @@ function startLocalServer(opts) {
                 projectId: convId ? (data.getConversation(convId)?.project_id ?? null) : null,
                 actorType: 'llm',
                 actorId: profile?.name || profile?.id || 'LLM',
+                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 +3167,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)({
@@ -2608,12 +3197,47 @@ function startLocalServer(opts) {
                 detail: `Sending request to ${activeProviderName}...`,
                 runtime: runtimePayload(),
             }, `Sending request to ${activeProviderName}...`);
+            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;
@@ -2624,6 +3248,7 @@ function startLocalServer(opts) {
             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...');
@@ -2635,8 +3260,10 @@ function startLocalServer(opts) {
                     stream: true,
                     tools: toolDefs,
                     cwd: llmSpawnCwd,
+                    abortSignal: routeAbortController.signal,
                     thinkingEnabled,
                     onChunk: async (chunk) => {
+                        throwIfChatJobCancelled();
                         if (iterationFirstChunk) {
                             iterationFirstChunk = false;
                             sendEvent('status', { phase: 'generating' });
@@ -2644,6 +3271,7 @@ function startLocalServer(opts) {
                         }
                         streamedAnyChunk = true;
                         streamedContent += chunk;
+                        persistAssistantPartial(false);
                         sendEvent('chunk', { text: chunk });
                     },
                     ...(thinkingEnabled ? {
@@ -2660,6 +3288,9 @@ function startLocalServer(opts) {
                     response = await activeLlm.chat(chatOptions);
                 }
                 catch (primaryErr) {
+                    if (routeAbortController.signal.aborted || primaryErr?.name === 'AbortError') {
+                        throw primaryErr;
+                    }
                     if (cliFallback && !switchedToCliFallback) {
                         switchedToCliFallback = true;
                         activeProviderName = cliFallback.providerName;
@@ -2770,6 +3401,7 @@ function startLocalServer(opts) {
                         throw primaryErr;
                     }
                 }
+                throwIfChatJobCancelled();
                 const authFailure = detectInteractiveAuthFailure(response?.content || '', activeProviderName, profile.provider);
                 if (authFailure && (!response?.toolCalls || response.toolCalls.length === 0)) {
                     sendEvent('status', {
@@ -2806,6 +3438,7 @@ function startLocalServer(opts) {
                         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}`);
@@ -2816,7 +3449,9 @@ function startLocalServer(opts) {
                             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'));
+                        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 });
@@ -2865,6 +3500,10 @@ function startLocalServer(opts) {
                 break;
             }
             const persistedContent = fullContent || streamedContent.trim();
+            if (!persistedContent) {
+                throw new Error('Assistant returned no final response');
+            }
+            persistAssistantPartial(true);
             // Emit thinking_done event if we accumulated any thinking
             if (accumulatedThinking) {
                 sendEvent('thinking_done', {
@@ -2885,7 +3524,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 +3559,7 @@ function startLocalServer(opts) {
                     approxInputTokens,
                 },
             });
+            responseEnded = true;
             res.end();
             // Background processing: auto-title + funnel extraction
             const conv = data.getConversation(convId);
@@ -2926,13 +3573,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}`));
@@ -2969,64 +3616,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 +3656,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) => {
@@ -3610,24 +4115,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 +4522,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
      */
@@ -4196,6 +4687,8 @@ 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) {
@@ -4214,17 +4707,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 '';
@@ -4398,6 +4896,12 @@ 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)