funolio-agent 1.0.75 → 1.1.65

package/dist/local-server.js

@@ -41,6 +41,10 @@ exports.stopLocalServer = stopLocalServer;
 exports.buildChatRuntimeForTest = buildChatRuntimeForTest;
 exports.resolveDirectCliSessionTransportForTest = resolveDirectCliSessionTransportForTest;
 exports.buildLocalDesktopDirectPromptForTest = buildLocalDesktopDirectPromptForTest;
+exports.resolveLocalDesktopPromptContextForTest = resolveLocalDesktopPromptContextForTest;
+exports.shouldSkipFreshCliBootstrapForTest = shouldSkipFreshCliBootstrapForTest;
+exports.buildLocalRuntimeUserFacingErrorForTest = buildLocalRuntimeUserFacingErrorForTest;
+exports.persistCliOauthSessionForTest = persistCliOauthSessionForTest;
 /**
  * Local HTTP server for desktop-first operation.
  *
@@ -53,11 +57,14 @@ const completion_marker_1 = require("./completion-marker");
 const index_2 = require("./index");
 const approval_1 = require("./approval");
 const config_1 = require("./config");
+const bench_prefix_1 = require("./bench-prefix");
+const usage_log_1 = require("./usage-log");
 const data = __importStar(require("./local-data"));
 const local_import_worker_1 = require("./local-import-worker");
 const clerk_model_1 = require("./clerk-model");
 const workflow_engine_1 = require("./workflow-engine");
 const context_window_1 = require("./context-window");
+const cli_bootstrap_history_1 = require("./cli-bootstrap-history");
 const summarization_pipeline_1 = require("./summarization-pipeline");
 const backfill_1 = require("./backfill");
 const config_cleanup_1 = require("./config-cleanup");
@@ -73,15 +80,23 @@ const registry_1 = require("./mcp/registry");
 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 credential_reader_1 = require("./auth/credential-reader");
+const token_refresh_1 = require("./auth/token-refresh");
 const local_memory_search_1 = require("./local-memory-search");
 const local_funnel_1 = require("./local-funnel");
 const orchestrator_profile_1 = require("./orchestrator-profile");
+const local_chat_execution_1 = require("./local-chat-execution");
+const chat_sync_1 = require("./chat-sync");
 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 codex_app_server_manager_1 = require("./codex-app-server-manager");
+const managed_process_registry_1 = require("./managed-process-registry");
 const cli_session_epoch_1 = require("./cli-session-epoch");
+const cli_models_1 = require("./cli-models");
+const slash_commands_1 = require("./slash-commands");
+const sync_cli_config_1 = require("./mcp/sync-cli-config");
 const server_adapter_1 = require("./server-adapter");
 const wizard_support_1 = require("./wizard-support");
 const chalk_1 = __importDefault(require("chalk"));
@@ -99,6 +114,351 @@ function requireExpress() {
         throw new Error('express is not installed. Run: npm install express');
     }
 }
+const MAX_INLINE_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+const MAX_PLAN_IMPORT_BYTES = 512 * 1024;
+/**
+ * Normalize an incoming `orchestration_roles_json` payload into a clean
+ * string[] for createAgentProfile / updateAgentProfile. Accepts:
+ *   - an array of strings (already in the target shape)
+ *   - a JSON-string of an array (wizard/UI sometimes serializes early)
+ *   - null / undefined → null (signals "clear the field")
+ * Anything else → null (defensive: never pass malformed data to the DB layer).
+ */
+function normalizeRolesArray(input) {
+    if (input == null)
+        return null;
+    if (Array.isArray(input)) {
+        const cleaned = input.map((v) => String(v ?? '').trim()).filter(Boolean);
+        return cleaned.length > 0 ? cleaned : null;
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return null;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                const cleaned = parsed.map((v) => String(v ?? '').trim()).filter(Boolean);
+                return cleaned.length > 0 ? cleaned : null;
+            }
+        }
+        catch {
+            // Not JSON — treat as a single role string for convenience.
+            return [trimmed];
+        }
+    }
+    return null;
+}
+function parseChatAttachmentInputs(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        const filename = String(entry?.filename || '').trim();
+        const mimeType = String(entry?.mimeType || entry?.mime_type || '').trim();
+        const dataUrl = typeof entry?.dataUrl === 'string'
+            ? entry.dataUrl
+            : typeof entry?.data_url === 'string'
+                ? entry.data_url
+                : undefined;
+        const sizeBytes = Number(entry?.sizeBytes ?? entry?.size_bytes ?? 0);
+        if (!filename || !mimeType || !Number.isFinite(sizeBytes) || sizeBytes < 0)
+            return [];
+        return [{
+                id: typeof entry?.id === 'string' ? entry.id : undefined,
+                filename,
+                mimeType,
+                sizeBytes,
+                dataUrl,
+            }];
+    });
+}
+function parseInlineDataUrl(dataUrl) {
+    const match = String(dataUrl || '').match(/^data:([^;]+);base64,(.+)$/);
+    if (!match)
+        return null;
+    return { mimeType: match[1], base64: match[2] };
+}
+function extensionForMimeType(mimeType, filename) {
+    const existing = path.extname(filename || '').trim();
+    if (existing)
+        return existing;
+    const normalized = String(mimeType || '').toLowerCase();
+    if (normalized === 'image/png')
+        return '.png';
+    if (normalized === 'image/jpeg')
+        return '.jpg';
+    if (normalized === 'image/webp')
+        return '.webp';
+    if (normalized === 'image/gif')
+        return '.gif';
+    return '';
+}
+function localFilesDir() {
+    const filesDir = path.join(os.homedir(), '.funolio', 'files');
+    if (!fs.existsSync(filesDir))
+        fs.mkdirSync(filesDir, { recursive: true });
+    return filesDir;
+}
+function persistInlineAttachments(conversationId, attachments) {
+    const filesDir = localFilesDir();
+    return attachments.flatMap((attachment) => {
+        if (!attachment.mimeType.startsWith('image/'))
+            return [];
+        if (!attachment.dataUrl)
+            return [];
+        const parsed = parseInlineDataUrl(attachment.dataUrl);
+        if (!parsed)
+            return [];
+        const buffer = Buffer.from(parsed.base64, 'base64');
+        if (buffer.length > MAX_INLINE_ATTACHMENT_BYTES) {
+            throw new Error(`Attachment "${attachment.filename}" exceeds max size of 10MB.`);
+        }
+        const fileId = require('crypto').randomUUID();
+        const ext = extensionForMimeType(parsed.mimeType, attachment.filename);
+        const storagePath = path.join(filesDir, `${fileId}${ext}`);
+        fs.writeFileSync(storagePath, buffer);
+        const chatFile = data.createChatFile({
+            conversationId,
+            filename: attachment.filename,
+            fileType: 'image',
+            mimeType: parsed.mimeType,
+            sizeBytes: buffer.length,
+            storagePath,
+            preview: attachment.dataUrl,
+        });
+        return [{
+                id: chatFile.id,
+                filename: chatFile.filename,
+                mimeType: chatFile.mime_type || parsed.mimeType,
+                sizeBytes: chatFile.size_bytes || buffer.length,
+                fileType: chatFile.file_type || 'image',
+                storagePath: chatFile.storage_path,
+            }];
+    });
+}
+function buildMessageContentWithAttachments(text, attachments) {
+    const parts = [];
+    for (const attachment of attachments) {
+        if (!attachment.mimeType.startsWith('image/') || !attachment.dataUrl)
+            continue;
+        const parsed = parseInlineDataUrl(attachment.dataUrl);
+        if (!parsed)
+            continue;
+        parts.push({ type: 'image', mimeType: parsed.mimeType, data: parsed.base64 });
+    }
+    if (parts.length === 0)
+        return text;
+    parts.push({ type: 'text', text });
+    return parts;
+}
+function buildMessageContentWithStoredAttachments(text, attachments) {
+    const parts = [];
+    for (const attachment of attachments) {
+        if (!attachment.mimeType.startsWith('image/') || !attachment.storagePath || !fs.existsSync(attachment.storagePath))
+            continue;
+        const data = fs.readFileSync(attachment.storagePath).toString('base64');
+        parts.push({ type: 'image', mimeType: attachment.mimeType, data });
+    }
+    if (parts.length === 0)
+        return text;
+    parts.push({ type: 'text', text });
+    return parts;
+}
+function parseStoredMessageAttachments(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function hydrateMessageAttachmentForClient(attachment, opts = {}) {
+    const chatFile = attachment.id ? data.getChatFile(attachment.id) : undefined;
+    const includeAttachmentData = opts.includeAttachmentData !== false;
+    let dataUrl;
+    if (includeAttachmentData) {
+        dataUrl = chatFile?.preview || undefined;
+        if (!dataUrl && attachment.mimeType.startsWith('image/') && chatFile?.storage_path && fs.existsSync(chatFile.storage_path)) {
+            const encoded = fs.readFileSync(chatFile.storage_path).toString('base64');
+            dataUrl = `data:${attachment.mimeType};base64,${encoded}`;
+        }
+    }
+    const hasPreview = !!chatFile?.preview || !!chatFile?.storage_path;
+    return {
+        id: attachment.id,
+        filename: attachment.filename,
+        fileType: attachment.fileType,
+        file_type: attachment.fileType,
+        mimeType: attachment.mimeType,
+        mime_type: attachment.mimeType,
+        sizeBytes: attachment.sizeBytes,
+        size_bytes: attachment.sizeBytes,
+        hasPreview,
+        has_preview: hasPreview,
+        dataUrl,
+        data_url: dataUrl,
+    };
+}
+function serializeMessageForClient(row, opts = {}) {
+    const attachments = parseStoredMessageAttachments(row.attachments_json);
+    const includeResultArtifact = opts.includeResultArtifact !== false;
+    const includeAttachmentData = opts.includeAttachmentData !== false;
+    const resultArtifact = includeResultArtifact ? row.result_artifact : undefined;
+    return {
+        ...row,
+        result_artifact: resultArtifact,
+        resultArtifact,
+        has_result_artifact: !includeResultArtifact && !!row.result_artifact,
+        hasResultArtifact: !includeResultArtifact && !!row.result_artifact,
+        result_artifact_bytes: !includeResultArtifact && row.result_artifact ? row.result_artifact.length : undefined,
+        resultArtifactBytes: !includeResultArtifact && row.result_artifact ? row.result_artifact.length : undefined,
+        attachments: attachments.length > 0
+            ? attachments.map((attachment) => hydrateMessageAttachmentForClient(attachment, { includeAttachmentData }))
+            : undefined,
+    };
+}
+function shouldUseLightweightMessageHistory(req) {
+    const relayHeader = String(req.headers?.['x-funolio-relay'] || '').trim();
+    const lightQuery = String(req.query?.light || '').trim().toLowerCase();
+    const includeDetailsQuery = String(req.query?.includeDetails || req.query?.include_details || '').trim().toLowerCase();
+    if (includeDetailsQuery === '1' || includeDetailsQuery === 'true')
+        return false;
+    return relayHeader === '1' || lightQuery === '1' || lightQuery === 'true';
+}
+function serializeMessageHistoryForRequest(req, rows) {
+    const light = shouldUseLightweightMessageHistory(req);
+    return rows.map((row) => serializeMessageForClient(row, {
+        includeResultArtifact: !light,
+        includeAttachmentData: !light,
+    }));
+}
+function findLatestUserMessageWithAttachments(conversationId, expectedText) {
+    const recent = data.getLastMessages(conversationId, 20);
+    const normalizedExpected = String(expectedText || '').trim();
+    for (let idx = recent.length - 1; idx >= 0; idx -= 1) {
+        const row = recent[idx];
+        if (row.role !== 'user' || !row.attachments_json)
+            continue;
+        if (!normalizedExpected || String(row.content || '').trim() === normalizedExpected) {
+            return row;
+        }
+    }
+    return recent.slice().reverse().find((row) => row.role === 'user' && !!row.attachments_json);
+}
+function resolveStoredAttachmentsForTurn(opts) {
+    if (opts.persistedAttachments && opts.persistedAttachments.length > 0) {
+        return opts.persistedAttachments;
+    }
+    if (!opts.skipUserMessage)
+        return [];
+    const job = opts.chatJobId ? data.getChatJob(String(opts.chatJobId)) : undefined;
+    const jobUserMessage = job ? data.getMessage(job.user_message_id) : undefined;
+    const attachedViaJob = parseStoredMessageAttachments(jobUserMessage?.attachments_json);
+    if (attachedViaJob.length > 0)
+        return attachedViaJob;
+    const latestUser = findLatestUserMessageWithAttachments(opts.conversationId, opts.message);
+    return parseStoredMessageAttachments(latestUser?.attachments_json);
+}
+function supportsNativeImageInput(providerName) {
+    const normalized = String(providerName || '').trim().toLowerCase();
+    return normalized === 'anthropic' || normalized === 'openai' || normalized === 'google' || normalized === 'codex-cli' || normalized === 'claude-cli';
+}
+function buildAttachmentContextBlock(summaries) {
+    if (summaries.length === 0)
+        return '';
+    return [
+        '',
+        '[Attached Images]',
+        ...summaries.map((summary, index) => `Image ${index + 1}:\n${summary}`),
+        '',
+    ].join('\n');
+}
+function resolveImageAnalysisConfig(preferredProfile) {
+    if (preferredProfile) {
+        const provider = String(preferredProfile.provider || '').trim().toLowerCase();
+        const apiKey = resolveApiKey(preferredProfile);
+        if ((provider === 'openai' || provider === 'anthropic') && apiKey) {
+            return { provider: provider, apiKey };
+        }
+    }
+    const clerkConfig = data.getResolvedClerkConfigInfo();
+    const clerkProvider = String(clerkConfig.provider || '').trim().toLowerCase();
+    if (clerkProvider === 'openai' || clerkProvider === 'anthropic') {
+        const clerkConn = clerkConfig.providerConnectionId
+            ? data.getProviderConnection(clerkConfig.providerConnectionId)
+            : data.findProviderConnection(clerkProvider);
+        if (clerkConn?.api_key_enc) {
+            return {
+                provider: clerkProvider,
+                apiKey: clerkConn.api_key_enc,
+                authMode: clerkConn.access_mode === 'oauth' && clerkProvider === 'anthropic' ? 'oauth-bearer' : 'api-key',
+            };
+        }
+    }
+    const openaiConn = data.findProviderConnection('openai');
+    if (openaiConn?.api_key_enc)
+        return { provider: 'openai', apiKey: openaiConn.api_key_enc };
+    if (process.env.OPENAI_API_KEY)
+        return { provider: 'openai', apiKey: process.env.OPENAI_API_KEY };
+    const anthropicConn = data.findProviderConnection('anthropic');
+    if (anthropicConn?.api_key_enc) {
+        return {
+            provider: 'anthropic',
+            apiKey: anthropicConn.api_key_enc,
+            authMode: anthropicConn.access_mode === 'oauth' ? 'oauth-bearer' : 'api-key',
+        };
+    }
+    if (process.env.ANTHROPIC_API_KEY)
+        return { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY };
+    return null;
+}
+async function summarizeStoredAttachmentsForTextRuntime(opts) {
+    if (!opts.attachments.length)
+        return '';
+    const analysisConfig = resolveImageAnalysisConfig(opts.preferredProfile);
+    const summaries = [];
+    for (const attachment of opts.attachments) {
+        if (!attachment.mimeType.startsWith('image/'))
+            continue;
+        if (!attachment.storagePath || !fs.existsSync(attachment.storagePath)) {
+            summaries.push(`[${attachment.filename}] Attached image is missing from local storage.`);
+            continue;
+        }
+        if (!analysisConfig) {
+            summaries.push(`[${attachment.filename}] Attached image is available locally at: ${attachment.storagePath}`);
+            continue;
+        }
+        const toolCtx = (0, index_2.createToolContext)(opts.workspacePath, {
+            runtimeMode: 'local_desktop',
+            actorType: 'llm',
+            actorId: opts.preferredProfile?.name || opts.preferredProfile?.id || 'ImageAnalyzer',
+            llmProvider: analysisConfig.provider,
+            llmApiKey: analysisConfig.apiKey,
+            llmAuthMode: analysisConfig.authMode,
+        });
+        const result = await (0, index_2.executeToolWithMCP)({
+            id: `image-analysis-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            name: 'analyze_image',
+            arguments: {
+                image_path: attachment.storagePath,
+                prompt: `Describe this image for a text-only assistant. Focus on details relevant to the user's request.\n\nUser request:\n${opts.userPrompt}`,
+            },
+        }, toolCtx);
+        if (result.success && result.output.trim()) {
+            summaries.push(`[${attachment.filename}] ${result.output.trim()}`);
+        }
+        else if (result.error?.trim()) {
+            summaries.push(`[${attachment.filename}] Image analysis failed: ${result.error.trim()}`);
+        }
+        else {
+            summaries.push(`[${attachment.filename}] Image attached at local path: ${attachment.storagePath}`);
+        }
+    }
+    return buildAttachmentContextBlock(summaries);
+}
 function startLocalServer(opts) {
     const express = requireExpress();
     const app = express();
@@ -106,6 +466,16 @@ function startLocalServer(opts) {
     if ((0, storage_mode_1.isLocalStorageMode)()) {
         data.purgeLegacyExtractionDataOnce();
     }
+    // Sweep orphan managed processes from previous crashes
+    try {
+        const orphanResult = (0, managed_process_registry_1.sweepOrphans)();
+        if (orphanResult.reaped > 0 || orphanResult.skipped > 0) {
+            console.info(`[managed-process] startup orphan sweep: reaped=${orphanResult.reaped} skipped=${orphanResult.skipped}`);
+        }
+    }
+    catch (err) {
+        console.warn(`[managed-process] startup orphan sweep failed: ${err.message}`);
+    }
     const cliNormalization = data.normalizeCliProviderConnections();
     if (cliNormalization.updatedIds.length > 0) {
         console.info(`[local-server] normalized ${cliNormalization.updatedIds.length} CLI provider connection(s): ${cliNormalization.updatedIds.join(', ')}`);
@@ -138,6 +508,553 @@ function startLocalServer(opts) {
         }
         return res.status(500).json({ error: message });
     }
+    function syncCliBotConfigFiles(profile) {
+        if (!profile)
+            return;
+        noteCliBotConfigWrite(profile.id);
+        if (profile.provider === 'claude-cli') {
+            let parsedPermissions = null;
+            if (profile.claude_permissions_json) {
+                try {
+                    parsedPermissions = JSON.parse(profile.claude_permissions_json);
+                }
+                catch {
+                    parsedPermissions = null;
+                }
+            }
+            (0, sync_cli_config_1.writeClaudeBotSettings)(profile.id, {
+                model: profile.model,
+                effortLevel: profile.claude_effort_level,
+                outputStyle: profile.claude_output_style,
+                fastMode: profile.claude_fast_mode === 1,
+                permissions: parsedPermissions,
+            });
+            return;
+        }
+        if (profile.provider === 'codex-cli') {
+            (0, sync_cli_config_1.writeCodexBotConfig)(profile.id, {
+                model: profile.model,
+                modelReasoningEffort: profile.codex_reasoning_effort,
+                personality: profile.codex_personality,
+                serviceTier: profile.codex_service_tier,
+                sandbox: profile.codex_sandbox_policy,
+                approvalPolicy: profile.codex_approval_policy,
+            });
+        }
+    }
+    async function refreshCliOAuthTokensIfNeeded(reason) {
+        const candidates = [
+            { provider: 'anthropic', credential: (0, credential_reader_1.readClaudeCredentials)() },
+            { provider: 'openai', credential: (0, credential_reader_1.readCodexCredentials)() },
+        ];
+        for (const candidate of candidates) {
+            const credential = candidate.credential;
+            if (!credential?.accessToken || !credential.refreshToken || !credential.expiresAt)
+                continue;
+            if (!(0, token_refresh_1.needsRefresh)(credential))
+                continue;
+            try {
+                const refreshed = await (0, token_refresh_1.refreshToken)(credential);
+                console.info(`[token-refresh] proactive_refresh_success provider=${candidate.provider} reason=${reason} expiresAt=${new Date(refreshed.credential.expiresAt).toISOString()}`);
+                (0, credential_reader_1.clearCache)();
+                if (candidate.provider === 'anthropic') {
+                    for (const profile of data.listAgentProfiles().filter((agent) => agent.provider === 'claude-cli')) {
+                        syncCliBotConfigFiles(profile);
+                    }
+                    const closedIdleSessions = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeIdleClaudeSessions();
+                    if (closedIdleSessions > 0) {
+                        console.info(`[claude-auth] evicted ${closedIdleSessions} idle Claude PTY session(s) after proactive refresh`);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`[token-refresh] proactive_refresh_failed provider=${candidate.provider} reason=${reason} message=${JSON.stringify(err?.message || String(err))}`);
+            }
+        }
+    }
+    void refreshCliOAuthTokensIfNeeded('startup');
+    const proactiveTokenRefreshTimer = setInterval(() => {
+        void refreshCliOAuthTokensIfNeeded('interval');
+    }, 60 * 60_000);
+    proactiveTokenRefreshTimer.unref?.();
+    function reapCliBotSessions(botId) {
+        (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeSessionsByBotId(botId);
+        (0, codex_app_server_manager_1.getCodexAppServerManager)().closeSessionsByBotId(botId);
+    }
+    function closeIdleManagedSession(sessionKey) {
+        (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeSessionByKey(sessionKey);
+        (0, codex_app_server_manager_1.getCodexAppServerManager)().closeSessionByKey(sessionKey);
+    }
+    function handleIdleSweepClose(sessionKey, provider) {
+        if (provider === 'codex-app-server') {
+            (0, codex_app_server_manager_1.getCodexAppServerManager)().closeSessionByKey(sessionKey);
+        }
+        else {
+            (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeSessionByKey(sessionKey);
+        }
+    }
+    function logCliWarmEvent(event, fields) {
+        const suffix = Object.entries(fields)
+            .filter(([, value]) => value !== undefined && value !== null && value !== '')
+            .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+            .join(' ');
+        console.info(`[cli-warm] ${event}${suffix ? ` ${suffix}` : ''}`);
+    }
+    function normalizeCliWarmTrigger(value) {
+        return value === 'bot_selection' ? 'bot_selection' : 'first_keystroke';
+    }
+    function normalizeCliWarmRequestRuntimeMode(value) {
+        return value === 'server' ? 'server' : 'local_desktop';
+    }
+    function buildCliWarmFailureReason(err) {
+        const error = err;
+        if (error?.code === 'CLI_WARM_TIMEOUT' || error?.code === 'CODEX_APP_SERVER_WARM_TIMEOUT') {
+            return 'warm_timeout';
+        }
+        if (error?.authRequired === true)
+            return 'auth_required';
+        if (error?.code === 'CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT')
+            return 'warm_startup_timeout';
+        if (error?.name === 'AbortError')
+            return 'warm_aborted';
+        const message = String(error?.message || '').toLowerCase();
+        if (message.includes('closed before it was ready'))
+            return 'session_closed_before_ready';
+        return 'warm_failed';
+    }
+    function recordCliWarmSkip(skipped, context, entry) {
+        skipped.push({ botId: entry.botId, reason: entry.reason });
+        logCliWarmEvent('warm_skipped', {
+            conversationId: context.conversationId,
+            topicId: context.topicId,
+            trigger: context.trigger,
+            runtimeMode: context.runtimeMode,
+            botId: entry.botId,
+            provider: entry.provider,
+            skipReason: entry.reason,
+        });
+    }
+    const CODEX_HIDDEN_WARM_PRIMER = 'This is a hidden background warm-up turn for a new conversation. Internalize the current project, topic, workspace, and bot instructions. There is no user-visible request yet. Reply with exactly READY and nothing else.';
+    function closeCliSessionsForConversation(conversationId, reason) {
+        const ptyClosed = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeSessionsByConversation(conversationId);
+        const appServerClosed = (0, codex_app_server_manager_1.getCodexAppServerManager)().closeSessionsByConversation(conversationId);
+        if (ptyClosed > 0 || appServerClosed > 0) {
+            logCliWarmEvent('warm_evicted', { conversationId, reason, ptyClosed, appServerClosed });
+        }
+    }
+    function closeWarmCliSessionsForConversation(conversationId, reason) {
+        const ptyClosed = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeWarmSessionsByConversation(conversationId);
+        const appServerClosed = (0, codex_app_server_manager_1.getCodexAppServerManager)().closeWarmSessionsByConversation(conversationId);
+        if (ptyClosed > 0 || appServerClosed > 0) {
+            logCliWarmEvent(reason === 'expired' ? 'warm_expired' : 'warm_evicted', {
+                conversationId,
+                reason,
+                ptyClosed,
+                appServerClosed,
+            });
+        }
+    }
+    function resolveConversationCwd(conversation) {
+        const project = conversation?.project_id ? data.getProject(conversation.project_id) : undefined;
+        const workspacePath = project?.folder?.trim() || undefined;
+        return workspacePath && fs.existsSync(workspacePath) ? workspacePath : opts.projectDir;
+    }
+    async function warmCliSessionsForConversation(input) {
+        const conversation = data.getConversation(input.conversationId);
+        if (!conversation) {
+            return {
+                ok: false,
+                warmed: [],
+                skipped: [],
+                failed: [{ botId: '*', error: 'Conversation not found' }],
+            };
+        }
+        const cwd = resolveConversationCwd(conversation);
+        const uniqueBotIds = [...new Set((input.botIds || []).map(String).filter(Boolean))];
+        const warmed = [];
+        const skipped = [];
+        const failed = [];
+        const trigger = normalizeCliWarmTrigger(input.trigger);
+        const runtimeMode = normalizeCliWarmRequestRuntimeMode(input.runtimeMode);
+        await Promise.all(uniqueBotIds.map(async (botId) => {
+            const profile = data.getAgentProfile(botId);
+            if (!profile) {
+                recordCliWarmSkip(skipped, {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    trigger,
+                    runtimeMode,
+                }, { botId, reason: 'bot_not_found' });
+                return;
+            }
+            if (profile.is_active === 0) {
+                recordCliWarmSkip(skipped, {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    trigger,
+                    runtimeMode,
+                }, { botId, provider: profile.provider, reason: 'bot_inactive' });
+                return;
+            }
+            let runtime;
+            let createdEpochSessionId;
+            try {
+                runtime = await buildChatRuntime(profile);
+            }
+            catch {
+                recordCliWarmSkip(skipped, {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    trigger,
+                    runtimeMode,
+                }, { botId, provider: profile.provider, reason: 'runtime_build_failed' });
+                return;
+            }
+            if (!index_1.CLI_PROVIDERS.has(runtime.providerName)) {
+                recordCliWarmSkip(skipped, {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    trigger,
+                    runtimeMode,
+                }, { botId, provider: runtime.providerName, reason: 'not_cli_provider' });
+                return;
+            }
+            const transport = resolveDirectCliSessionTransport(runtime.providerName, true, (0, storage_mode_1.isLocalStorageMode)());
+            const cliSessionEpochPlan = (0, cli_session_epoch_1.selectCliSessionEpoch)(input.conversationId, profile.id, runtime.providerName);
+            logCliWarmEvent('warm_requested', {
+                conversationId: input.conversationId,
+                topicId: input.topicId,
+                botId,
+                provider: runtime.providerName,
+                trigger,
+                runtimeMode,
+            });
+            try {
+                if (transport === 'codex-app-server') {
+                    // Build the same systemPrompt the send path will use so warm can
+                    // pre-create the Codex thread under the correct fingerprint. If
+                    // anything drifts between warm and Send (e.g. user edits soul_md
+                    // mid-typing), the fingerprint check in codex-app-server-manager
+                    // invalidates the warm thread and Send falls back to a fresh
+                    // thread/start — same as today's uncarmed behavior.
+                    const allToolDefs = (0, index_2.getAllToolDefinitions)('local_desktop', mcpManager);
+                    const unrestrictedCliProfile = index_1.CLI_PROVIDERS.has(profile.provider);
+                    const configuredBuiltinTools = parseToolSelectionJson(profile.enabled_builtin_tools_json);
+                    const configuredMcpTools = parseToolSelectionJson(profile.enabled_mcp_tools_json);
+                    const allowedToolNames = unrestrictedCliProfile
+                        ? new Set(allToolDefs.map((tool) => tool.name))
+                        : expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredMcpTools);
+                    const toolDefs = allToolDefs.filter((tool) => allowedToolNames.has(tool.name));
+                    const configuredTz = (data.getSetting('timezone') || '').trim();
+                    const effectiveTimezone = configuredTz && configuredTz.toLowerCase() !== 'system'
+                        ? configuredTz
+                        : Intl.DateTimeFormat().resolvedOptions().timeZone;
+                    const promptContextWindow = (0, context_window_1.getPromptContextWindow)(input.conversationId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS, {
+                        targetBotId: profile.id,
+                        targetBotName: profile.name,
+                    });
+                    const promptContext = resolveLocalDesktopPromptContext({
+                        conversationId: input.conversationId,
+                        conversation,
+                        explicitTopicId: input.topicId,
+                        fallbackCwd: cwd,
+                    });
+                    const directPrompt = buildLocalDesktopDirectPrompt({
+                        conversationId: input.conversationId,
+                        currentBotId: profile.id,
+                        currentBotName: profile.name,
+                        currentProvider: runtime.providerName,
+                        userPrompt: '',
+                        soulMd: profile.soul_md
+                            || 'You are an AI assistant running locally. You have access to project files and can execute code.',
+                        projectName: promptContext.projectName,
+                        topicTitle: promptContext.topicTitle,
+                        workspacePath: promptContext.workspacePath,
+                        timezone: effectiveTimezone,
+                        availableTools: toolDefs.map((tool) => ({ name: tool.name, description: tool.description })),
+                        isCliRecurring: !!cliSessionEpochPlan.resumeSessionId,
+                        cliHistoryFilePath: null,
+                        crossBotTurn: promptContextWindow.lastCrossBotTurn,
+                        forceInlinePromptContext: transport === 'codex-app-server' && !cliSessionEpochPlan.resumeSessionId,
+                        useCompletionSentinel: false,
+                    });
+                    const shouldPrimeFreshCodex = runtime.providerName === 'codex-cli'
+                        && !cliSessionEpochPlan.resumeSessionId
+                        && (conversation.turn_count || 0) === 0;
+                    const result = await (0, codex_app_server_manager_1.getCodexAppServerManager)().warmSession({
+                        runtimeMode: 'local_desktop',
+                        conversationId: input.conversationId,
+                        botId: profile.id,
+                        botName: profile.name,
+                        cwd,
+                        projectId: conversation.project_id ?? null,
+                        timeoutMs: 30_000,
+                        systemPrompt: directPrompt.systemPrompt,
+                        model: runtime.model || profile.model || null,
+                        codexSettings: {
+                            reasoningEffort: profile.codex_reasoning_effort,
+                            reasoningSummary: profile.codex_reasoning_summary,
+                            personality: profile.codex_personality,
+                            serviceTier: profile.codex_service_tier,
+                            sandboxPolicy: profile.codex_sandbox_policy,
+                            approvalPolicy: profile.codex_approval_policy,
+                        },
+                        resumeSessionId: cliSessionEpochPlan.resumeSessionId || undefined,
+                        primerMessages: shouldPrimeFreshCodex
+                            ? [{ role: 'user', content: CODEX_HIDDEN_WARM_PRIMER }]
+                            : undefined,
+                    });
+                    if (shouldPrimeFreshCodex && result.hiddenPrimerCompleted && result.sessionId) {
+                        data.upsertCliSessionEpoch({
+                            conversationId: input.conversationId,
+                            botId: profile.id,
+                            provider: runtime.providerName,
+                            sessionId: result.sessionId,
+                            epochTurnCount: 1,
+                            epochStartedAt: localTimestamp(),
+                            lastUsedAt: localTimestamp(),
+                            resetReason: null,
+                        });
+                    }
+                    warmed.push({
+                        botId,
+                        provider: runtime.providerName,
+                        reusedExistingSession: result.reusedExistingSession,
+                        readyAgeMs: result.readyAgeMs,
+                    });
+                    logCliWarmEvent('warm_ready', {
+                        conversationId: input.conversationId,
+                        topicId: input.topicId,
+                        botId,
+                        provider: runtime.providerName,
+                        trigger,
+                        runtimeMode,
+                        reusedExistingSession: result.reusedExistingSession,
+                        readyAgeMs: result.readyAgeMs,
+                    });
+                    return;
+                }
+                if (transport !== 'pty') {
+                    recordCliWarmSkip(skipped, {
+                        conversationId: input.conversationId,
+                        topicId: input.topicId,
+                        trigger,
+                        runtimeMode,
+                    }, { botId, provider: runtime.providerName, reason: 'transport_not_warmable' });
+                    return;
+                }
+                const isFreshClaude = runtime.providerName === 'claude-cli' && !cliSessionEpochPlan.resumeSessionId;
+                const newSessionId = isFreshClaude ? data.generateNextSessionId() : undefined;
+                const result = await (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().warmSession({
+                    conversationId: input.conversationId,
+                    botId: profile.id,
+                    provider: runtime.providerName,
+                    botSettings: {
+                        claude: runtime.providerName === 'claude-cli'
+                            ? {
+                                model: runtime.model || profile.model,
+                                effortLevel: profile.claude_effort_level,
+                                outputStyle: profile.claude_output_style,
+                                fastMode: profile.claude_fast_mode === 1,
+                                permissionsJson: profile.claude_permissions_json,
+                            }
+                            : undefined,
+                        codex: runtime.providerName === 'codex-cli'
+                            ? {
+                                model: runtime.model || profile.model,
+                                reasoningEffort: profile.codex_reasoning_effort,
+                                personality: profile.codex_personality,
+                                serviceTier: profile.codex_service_tier,
+                                sandboxPolicy: profile.codex_sandbox_policy,
+                                approvalPolicy: profile.codex_approval_policy,
+                            }
+                            : undefined,
+                    },
+                    cwd,
+                    toolActorId: profile.name,
+                    toolProjectId: conversation.project_id ?? null,
+                    topicId: input.topicId,
+                    runtimeMode,
+                    resumeSessionId: cliSessionEpochPlan.resumeSessionId || undefined,
+                    newSessionId,
+                    useConpty: input.orchestrationMode ? process.platform !== 'win32' : undefined,
+                    timeoutMs: 10_000,
+                });
+                if (!result.reusedExistingSession && newSessionId) {
+                    createdEpochSessionId = newSessionId;
+                    data.upsertCliSessionEpoch({
+                        conversationId: input.conversationId,
+                        botId: profile.id,
+                        provider: runtime.providerName,
+                        sessionId: newSessionId,
+                        epochTurnCount: 0,
+                        lastInputTokens: 0,
+                        lastOutputTokens: 0,
+                        resetReason: cliSessionEpochPlan.resetReason || 'prewarm',
+                        epochStartedAt: localTimestamp(),
+                        lastUsedAt: localTimestamp(),
+                    });
+                }
+                warmed.push({
+                    botId,
+                    provider: runtime.providerName,
+                    reusedExistingSession: result.reusedExistingSession,
+                    readyAgeMs: result.readyAgeMs,
+                });
+                logCliWarmEvent('warm_ready', {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    botId,
+                    provider: runtime.providerName,
+                    trigger,
+                    runtimeMode,
+                    reusedExistingSession: result.reusedExistingSession,
+                    readyAgeMs: result.readyAgeMs,
+                });
+            }
+            catch (err) {
+                if (createdEpochSessionId) {
+                    data.deleteCliSessionEpoch(input.conversationId, profile.id);
+                }
+                const message = err?.message || String(err);
+                const failureReason = buildCliWarmFailureReason(err);
+                const timeout = failureReason === 'warm_timeout';
+                const timeoutMs = err?.code === 'CODEX_APP_SERVER_WARM_TIMEOUT'
+                    ? 30_000
+                    : err?.code === 'CLI_WARM_TIMEOUT'
+                        ? 10_000
+                        : undefined;
+                failed.push({ botId, provider: runtime.providerName, error: message, timeout });
+                logCliWarmEvent(timeout ? 'warm_timeout' : 'warm_failed', {
+                    conversationId: input.conversationId,
+                    topicId: input.topicId,
+                    botId,
+                    provider: runtime.providerName,
+                    trigger,
+                    runtimeMode,
+                    timeoutMs,
+                    failureReason,
+                });
+            }
+        }));
+        return {
+            ok: failed.length === 0,
+            warmed,
+            skipped,
+            failed,
+        };
+    }
+    const cliBotConfigWatchers = new Map();
+    function noteCliBotConfigWrite(botId) {
+        const existing = cliBotConfigWatchers.get(botId);
+        if (!existing)
+            return;
+        existing.suppressUntilMs = Date.now() + 1_500;
+    }
+    function closeCliBotConfigWatcher(botId) {
+        const existing = cliBotConfigWatchers.get(botId);
+        if (!existing)
+            return;
+        if (existing.debounceTimer)
+            clearTimeout(existing.debounceTimer);
+        try {
+            existing.watcher.close();
+        }
+        catch {
+            // best effort
+        }
+        cliBotConfigWatchers.delete(botId);
+    }
+    function buildCliBotConfigUpdateFromDisk(profile) {
+        if (profile.provider === 'claude-cli') {
+            const disk = (0, sync_cli_config_1.readClaudeBotSettings)(profile.id);
+            const nextPermissionsJson = disk.permissions ? JSON.stringify(disk.permissions) : null;
+            const fields = {};
+            const nextModel = (disk.model || '').trim();
+            if (nextModel && nextModel !== profile.model)
+                fields.model = nextModel;
+            const nextEffort = (disk.effortLevel || 'auto').trim() || 'auto';
+            if (nextEffort !== profile.claude_effort_level)
+                fields.claudeEffortLevel = nextEffort;
+            const nextOutputStyle = (disk.outputStyle || 'default').trim() || 'default';
+            if (nextOutputStyle !== profile.claude_output_style)
+                fields.claudeOutputStyle = nextOutputStyle;
+            const nextFastMode = disk.fastMode === true;
+            if ((nextFastMode ? 1 : 0) !== profile.claude_fast_mode)
+                fields.claudeFastMode = nextFastMode;
+            if ((nextPermissionsJson || null) !== (profile.claude_permissions_json || null)) {
+                fields.claudePermissionsJson = nextPermissionsJson;
+            }
+            return Object.keys(fields).length > 0 ? fields : null;
+        }
+        if (profile.provider === 'codex-cli') {
+            const disk = (0, sync_cli_config_1.readCodexBotConfig)(profile.id);
+            const fields = {};
+            const nextModel = (disk.model || '').trim();
+            if (nextModel && nextModel !== profile.model)
+                fields.model = nextModel;
+            const nextReasoning = (disk.modelReasoningEffort || 'high').trim() || 'high';
+            if (nextReasoning !== profile.codex_reasoning_effort)
+                fields.codexReasoningEffort = nextReasoning;
+            const nextPersonality = (disk.personality || 'friendly').trim() || 'friendly';
+            if (nextPersonality !== profile.codex_personality)
+                fields.codexPersonality = nextPersonality;
+            const nextServiceTier = (disk.serviceTier || 'fast').trim() || 'fast';
+            if (nextServiceTier !== profile.codex_service_tier)
+                fields.codexServiceTier = nextServiceTier;
+            const nextSandbox = (disk.sandbox || 'danger-full-access').trim() || 'danger-full-access';
+            if (nextSandbox !== profile.codex_sandbox_policy)
+                fields.codexSandboxPolicy = nextSandbox;
+            const nextApproval = (disk.approvalPolicy || 'never').trim() || 'never';
+            if (nextApproval !== profile.codex_approval_policy)
+                fields.codexApprovalPolicy = nextApproval;
+            return Object.keys(fields).length > 0 ? fields : null;
+        }
+        return null;
+    }
+    function applyCliBotConfigUpdateFromDisk(botId) {
+        const profile = data.getAgentProfile(botId);
+        if (!profile || (profile.provider !== 'claude-cli' && profile.provider !== 'codex-cli'))
+            return;
+        const fields = buildCliBotConfigUpdateFromDisk(profile);
+        if (!fields)
+            return;
+        data.updateAgentProfile(botId, fields);
+        reapCliBotSessions(botId);
+    }
+    function watchCliBotConfig(profile) {
+        if (!profile || (profile.provider !== 'claude-cli' && profile.provider !== 'codex-cli'))
+            return;
+        closeCliBotConfigWatcher(profile.id);
+        const configPath = profile.provider === 'claude-cli'
+            ? (0, sync_cli_config_1.claudeBotSettingsPath)(profile.id)
+            : (0, sync_cli_config_1.codexConfigPath)((0, sync_cli_config_1.getCliBotSessionHome)('codex-cli', profile.id));
+        const watchDir = path.dirname(configPath);
+        if (!fs.existsSync(watchDir))
+            return;
+        try {
+            const state = {
+                watcher: fs.watch(watchDir, () => {
+                    const current = cliBotConfigWatchers.get(profile.id);
+                    if (!current)
+                        return;
+                    if (current.debounceTimer)
+                        clearTimeout(current.debounceTimer);
+                    current.debounceTimer = setTimeout(() => {
+                        if (Date.now() < current.suppressUntilMs)
+                            return;
+                        applyCliBotConfigUpdateFromDisk(profile.id);
+                    }, 200);
+                }),
+                debounceTimer: null,
+                suppressUntilMs: 0,
+            };
+            cliBotConfigWatchers.set(profile.id, state);
+        }
+        catch {
+            // best effort only
+        }
+    }
     // Auto-seed agent profiles from DB-backed provider connections after legacy migration.
     try {
         const migration = (0, wizard_state_1.migrateLegacyConfigToDb)();
@@ -194,14 +1111,70 @@ function startLocalServer(opts) {
         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`));
+        const recovery = data.recoverInterruptedChatJobs();
+        if (recovery.totalRecovered > 0) {
+            console.log(chalk_1.default.gray(`  Recovered ${recovery.totalRecovered} interrupted chat job(s)`));
+        }
+        console.log(JSON.stringify({
+            ts: new Date().toISOString(),
+            level: 'info',
+            event: 'CRASH_RECOVERY',
+            recoveredCount: recovery.totalRecovered,
+        }));
+        for (const job of recovery.recoveredJobs) {
+            console.log(JSON.stringify({
+                ts: new Date().toISOString(),
+                level: 'info',
+                event: 'CRASH_RECOVERY_JOB',
+                jobId: job.jobId,
+                previousStatus: job.previousStatus,
+            }));
         }
     }
     catch (err) {
         console.error(chalk_1.default.yellow(`  Failed to recover interrupted chat jobs: ${err}`));
     }
+    try {
+        const workflowRecovery = data.recoverInterruptedWorkflowRuns();
+        if (workflowRecovery.totalRecovered > 0) {
+            console.log(chalk_1.default.gray(`  Recovered ${workflowRecovery.totalRecovered} interrupted workflow item(s)`));
+        }
+        console.log(JSON.stringify({
+            ts: new Date().toISOString(),
+            level: 'info',
+            event: 'WORKFLOW_CRASH_RECOVERY',
+            recoveredCount: workflowRecovery.totalRecovered,
+            recoveredWorkflowExecutions: workflowRecovery.recoveredWorkflowExecutions.length,
+            recoveredImportedPlanRuns: workflowRecovery.recoveredImportedPlanRuns.length,
+        }));
+        for (const workflow of workflowRecovery.recoveredWorkflowExecutions) {
+            console.log(JSON.stringify({
+                ts: new Date().toISOString(),
+                level: 'info',
+                event: 'WORKFLOW_CRASH_RECOVERY_EXECUTION',
+                workflowId: workflow.workflowId,
+                conversationId: workflow.conversationId,
+                previousStatus: workflow.previousStatus,
+            }));
+        }
+        for (const run of workflowRecovery.recoveredImportedPlanRuns) {
+            console.log(JSON.stringify({
+                ts: new Date().toISOString(),
+                level: 'info',
+                event: 'WORKFLOW_CRASH_RECOVERY_IMPORTED_PLAN',
+                runId: run.runId,
+                conversationId: run.conversationId,
+                previousStatus: run.previousStatus,
+                remainingTaskCount: run.remainingTaskCount,
+            }));
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.yellow(`  Failed to recover interrupted workflow runs: ${err}`));
+    }
+    for (const profile of data.listAgentProfiles()) {
+        watchCliBotConfig(profile);
+    }
     // ─── Health ──────────────────────────────────────────────────
     app.get('/api/health', (_req, res) => {
         try {
@@ -212,12 +1185,37 @@ function startLocalServer(opts) {
                 db: stats,
                 version: require('../package.json').version,
                 runtime,
+                systemInfo: {
+                    hostname: os.hostname(),
+                    platform: os.platform(),
+                    arch: os.arch(),
+                },
             });
         }
         catch (err) {
             res.status(500).json({ status: 'error', error: err.message });
         }
     });
+    // ─── Diagnostics: Managed Sessions ─────────────────────────
+    app.get('/api/diagnostics/sessions', (_req, res) => {
+        try {
+            const sessions = (0, managed_process_registry_1.getDiagnostics)();
+            res.json({ sessions });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/diagnostics/sessions/:sessionKey/close', (req, res) => {
+        try {
+            const sessionKey = decodeURIComponent(req.params.sessionKey);
+            closeIdleManagedSession(sessionKey);
+            res.json({ ok: true, sessionKey });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.get('/api/runtime/config', async (_req, res) => {
         try {
             const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
@@ -234,6 +1232,49 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    app.post('/api/cli-sessions/warm', async (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.json({ ok: true, warmed: [], skipped: [{ botId: '*', reason: 'connected_mode' }], failed: [] });
+            }
+            const conversationId = String(req.body?.conversationId || '').trim();
+            const botIds = Array.isArray(req.body?.botIds) ? req.body.botIds.map(String) : [];
+            if (!conversationId)
+                return res.status(400).json({ error: 'conversationId is required' });
+            if (botIds.length === 0)
+                return res.json({ ok: true, warmed: [], skipped: [], failed: [] });
+            const result = await warmCliSessionsForConversation({
+                conversationId,
+                botIds,
+                topicId: typeof req.body?.topicId === 'string' ? req.body.topicId : undefined,
+                trigger: typeof req.body?.trigger === 'string' ? req.body.trigger : undefined,
+                runtimeMode: typeof req.body?.runtimeMode === 'string' ? req.body.runtimeMode : undefined,
+                orchestrationMode: req.body?.orchestrationMode === true,
+            });
+            if (!result.ok && result.failed.some((entry) => entry.error === 'Conversation not found')) {
+                return res.status(404).json(result);
+            }
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/cli-sessions/warm/close', async (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.json({ ok: true });
+            }
+            const conversationId = String(req.body?.conversationId || '').trim();
+            if (!conversationId)
+                return res.status(400).json({ error: 'conversationId is required' });
+            closeWarmCliSessionsForConversation(conversationId, String(req.body?.reason || 'expired'));
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.get('/api/runtime/agents', async (_req, res) => {
         try {
             const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
@@ -555,6 +1596,36 @@ function startLocalServer(opts) {
     function localTimestamp() {
         return new Date().toISOString().replace('T', ' ').replace('Z', '');
     }
+    function emitConversationSyncEvents(conversationId, events, opts) {
+        const revision = typeof opts?.revision === 'number'
+            ? opts.revision
+            : data.bumpConversationSyncRevision(conversationId, opts?.updatedAt || undefined);
+        const updatedAt = opts?.updatedAt || localTimestamp();
+        for (const event of events) {
+            (0, chat_sync_1.emitChatSyncEvent)({
+                change: event.change,
+                conversationId,
+                messageId: event.messageId ?? null,
+                jobId: event.jobId ?? null,
+                jobStatus: event.jobStatus ?? null,
+                revision,
+                updatedAt,
+                source: event.source ?? 'agent.local',
+            });
+        }
+        return revision;
+    }
+    function emitDeletedConversationSyncEvent(conversation) {
+        (0, chat_sync_1.emitChatSyncEvent)({
+            change: 'conversation.deleted',
+            conversationId: conversation.id,
+            revision: Number(conversation.sync_revision || 0) + 1,
+            projectId: conversation.project_id ?? null,
+            topicId: data.getPrimaryTopicIdForConversation(conversation.id),
+            updatedAt: localTimestamp(),
+            source: 'agent.local',
+        });
+    }
     const MAX_LOCAL_CHAT_JOBS = 3;
     const runningChatJobControllers = new Map();
     const finalizeCancelledChatJobMessage = (job) => {
@@ -610,8 +1681,8 @@ function startLocalServer(opts) {
             await handlers.onDone?.({});
         }
     };
-    const runQueuedChatJobs = async () => {
-        if (isConnectedMode())
+    const runQueuedChatJobs = async (opts) => {
+        if (isConnectedMode() && !opts?.force)
             return;
         while (runningChatJobControllers.size < MAX_LOCAL_CHAT_JOBS) {
             const runningKeys = new Set(data.listRunningChatJobs(MAX_LOCAL_CHAT_JOBS + 20).map((job) => `${job.conversation_id}::${job.bot_id}`));
@@ -624,11 +1695,15 @@ function startLocalServer(opts) {
                 return;
             const controller = new AbortController();
             runningChatJobControllers.set(next.id, controller);
+            const runningAt = localTimestamp();
             data.updateChatJob(next.id, {
                 status: 'running',
-                startedAt: localTimestamp(),
+                startedAt: runningAt,
                 error: null,
             });
+            emitConversationSyncEvents(next.conversation_id, [
+                { change: 'job.running', jobId: next.id, jobStatus: 'running' },
+            ], { updatedAt: runningAt });
             void (async () => {
                 try {
                     const job = data.getChatJob(next.id);
@@ -652,6 +1727,7 @@ function startLocalServer(opts) {
                             message: userMessage?.content || '',
                             botId: job.bot_id,
                             skipUserMessage: true,
+                            attachments: Array.isArray(requestPayload?.attachments) ? requestPayload.attachments : undefined,
                             pinnedMessageIds: Array.isArray(requestPayload?.pinnedMessageIds) ? requestPayload.pinnedMessageIds : undefined,
                             topicId: requestPayload?.topicId || undefined,
                             projectId: requestPayload?.projectId || undefined,
@@ -669,12 +1745,17 @@ function startLocalServer(opts) {
                             const latest = data.getChatJob(next.id);
                             if (!latest || latest.status === 'cancelled')
                                 return;
+                            const completedAt = localTimestamp();
                             data.updateChatJob(next.id, {
                                 status: 'completed',
-                                completedAt: localTimestamp(),
+                                completedAt,
                                 error: null,
                             });
-                            data.touchConversationActivity(next.conversation_id);
+                            data.touchConversationActivity(next.conversation_id, completedAt);
+                            emitConversationSyncEvents(next.conversation_id, [
+                                { change: 'message.updated', messageId: next.assistant_message_id },
+                                { change: 'job.completed', jobId: next.id, jobStatus: 'completed' },
+                            ], { updatedAt: completedAt });
                         },
                         onError: async (payload) => {
                             const latest = data.getChatJob(next.id);
@@ -687,12 +1768,17 @@ function startLocalServer(opts) {
                                 content: existingContent ? `${existingContent}\n\n**Error:** ${errorText}` : `**Error:** ${errorText}`,
                                 botId: next.bot_id,
                             });
+                            const failedAt = localTimestamp();
                             data.updateChatJob(next.id, {
                                 status: 'failed',
                                 error: errorText,
-                                completedAt: localTimestamp(),
+                                completedAt: failedAt,
                             });
-                            data.touchConversationActivity(next.conversation_id);
+                            data.touchConversationActivity(next.conversation_id, failedAt);
+                            emitConversationSyncEvents(next.conversation_id, [
+                                { change: 'message.updated', messageId: next.assistant_message_id },
+                                { change: 'job.failed', jobId: next.id, jobStatus: 'failed' },
+                            ], { updatedAt: failedAt });
                         },
                     });
                 }
@@ -702,11 +1788,16 @@ function startLocalServer(opts) {
                         return;
                     if (latest.status === 'cancelled' || err?.name === 'AbortError') {
                         finalizeCancelledChatJobMessage(latest);
+                        const cancelledAt = latest.cancelled_at || localTimestamp();
                         data.updateChatJob(next.id, {
                             status: 'cancelled',
-                            cancelledAt: latest.cancelled_at || localTimestamp(),
-                            completedAt: latest.completed_at || localTimestamp(),
+                            cancelledAt,
+                            completedAt: latest.completed_at || cancelledAt,
                         });
+                        emitConversationSyncEvents(next.conversation_id, [
+                            { change: 'message.updated', messageId: next.assistant_message_id },
+                            { change: 'job.cancelled', jobId: next.id, jobStatus: 'cancelled' },
+                        ], { updatedAt: cancelledAt });
                         return;
                     }
                     const errorText = err?.message || 'Background chat failed';
@@ -716,12 +1807,17 @@ function startLocalServer(opts) {
                         content: existingContent ? `${existingContent}\n\n**Error:** ${errorText}` : `**Error:** ${errorText}`,
                         botId: next.bot_id,
                     });
+                    const failedAt = localTimestamp();
                     data.updateChatJob(next.id, {
                         status: 'failed',
                         error: errorText,
-                        completedAt: localTimestamp(),
+                        completedAt: failedAt,
                     });
-                    data.touchConversationActivity(next.conversation_id);
+                    data.touchConversationActivity(next.conversation_id, failedAt);
+                    emitConversationSyncEvents(next.conversation_id, [
+                        { change: 'message.updated', messageId: next.assistant_message_id },
+                        { change: 'job.failed', jobId: next.id, jobStatus: 'failed' },
+                    ], { updatedAt: failedAt });
                 }
                 finally {
                     runningChatJobControllers.delete(next.id);
@@ -751,6 +1847,7 @@ function startLocalServer(opts) {
                 conversationId: req.body?.conversationId || undefined,
                 projectId: req.body?.projectId || undefined,
                 botId: req.body?.botId || undefined,
+                attachments: Array.isArray(req.body?.attachments) ? req.body.attachments : undefined,
                 targetAgentId,
                 stream: true,
                 skipUserMessage: !!req.body?.skipUserMessage,
@@ -1078,6 +2175,10 @@ function startLocalServer(opts) {
             if (!isCliProvider) {
                 return res.status(400).json({ error: 'Desktop auth refresh only supports Claude CLI or Codex CLI sessions.' });
             }
+            const persisted = persistCliOauthSession(effectiveProviderId, accessToken, refreshToken, expiresAt);
+            if (!persisted) {
+                return res.status(500).json({ error: `Failed to persist ${effectiveProviderId} OAuth credentials locally.` });
+            }
             const metadataJson = JSON.stringify({
                 source: cli ? `desktop-cli:${cli}` : 'desktop-cli',
             });
@@ -1107,6 +2208,12 @@ function startLocalServer(opts) {
                     metadataJson,
                 });
             });
+            if (effectiveProviderId === 'claude-cli') {
+                const closedIdleSessions = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().closeIdleClaudeSessions();
+                if (closedIdleSessions > 0) {
+                    console.info(`[claude-auth] evicted ${closedIdleSessions} idle Claude PTY session(s) after reauth`);
+                }
+            }
             res.json({ ok: true, updated });
         }
         catch (err) {
@@ -1236,10 +2343,22 @@ function startLocalServer(opts) {
             }
         })();
     });
+    app.get('/api/cli/model-options', (req, res) => {
+        try {
+            const provider = String(req.query.provider || '').trim();
+            if (provider !== 'claude-cli' && provider !== 'codex-cli') {
+                return res.status(400).json({ error: 'provider must be claude-cli or codex-cli' });
+            }
+            res.json({ provider, models: (0, cli_models_1.getCliModelOptions)(provider) });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.post('/api/bots', (req, res) => {
         (async () => {
             try {
-                const { provider, model, name, soulMd, memoryMd, toolsMd, skillsMd, apiKeyEnc, permissionMode, isDefault, roleLabel, roleClass, isActive, priority, isOrchestrator, is_orchestrator, codexReasoningEffort, codex_reasoning_effort, codexReasoningSummary, codex_reasoning_summary, codexPersonality, codex_personality, codexServiceTier, codex_service_tier, codexSandboxPolicy, codex_sandbox_policy, codexApprovalPolicy, codex_approval_policy, } = req.body;
+                const { provider, model, name, soulMd, memoryMd, toolsMd, skillsMd, apiKeyEnc, permissionMode, isDefault, roleLabel, roleClass, orchestrationRoleLabel, orchestration_role_label, orchestrationRoleClass, orchestration_role_class, orchestrationIncludeUserPrompt, orchestration_include_user_prompt, isActive, priority, isOrchestrator, is_orchestrator, color, codexReasoningEffort, codex_reasoning_effort, codexReasoningSummary, codex_reasoning_summary, codexPersonality, codex_personality, codexServiceTier, codex_service_tier, codexSandboxPolicy, codex_sandbox_policy, codexApprovalPolicy, codex_approval_policy, claudeEffortLevel, claude_effort_level, claudeOutputStyle, claude_output_style, claudeFastMode, claude_fast_mode, claudePermissionsJson, claude_permissions_json, orchestrationRolesJson, orchestration_roles_json, } = req.body;
                 if (!provider || !model || !name) {
                     return res.status(400).json({ error: 'provider, model, and name are required' });
                 }
@@ -1266,8 +2385,12 @@ function startLocalServer(opts) {
                     isDefault,
                     roleLabel,
                     roleClass,
+                    orchestrationRoleLabel: orchestrationRoleLabel ?? orchestration_role_label,
+                    orchestrationRoleClass: orchestrationRoleClass ?? orchestration_role_class,
+                    orchestrationIncludeUserPrompt: orchestrationIncludeUserPrompt ?? orchestration_include_user_prompt,
                     isActive,
                     priority,
+                    color,
                     isOrchestrator: isOrchestrator ?? is_orchestrator,
                     codexReasoningEffort: codexReasoningEffort ?? codex_reasoning_effort,
                     codexReasoningSummary: codexReasoningSummary ?? codex_reasoning_summary,
@@ -1275,7 +2398,15 @@ function startLocalServer(opts) {
                     codexServiceTier: codexServiceTier ?? codex_service_tier,
                     codexSandboxPolicy: codexSandboxPolicy ?? codex_sandbox_policy,
                     codexApprovalPolicy: codexApprovalPolicy ?? codex_approval_policy,
+                    claudeEffortLevel: claudeEffortLevel ?? claude_effort_level,
+                    claudeOutputStyle: claudeOutputStyle ?? claude_output_style,
+                    claudeFastMode: claudeFastMode ?? claude_fast_mode,
+                    claudePermissionsJson: claudePermissionsJson ?? claude_permissions_json,
+                    orchestrationRolesJson: normalizeRolesArray(orchestrationRolesJson ?? orchestration_roles_json),
                 });
+                syncCliBotConfigFiles(profile);
+                reapCliBotSessions(profile.id);
+                watchCliBotConfig(profile);
                 res.status(201).json(profile);
             }
             catch (err) {
@@ -1313,10 +2444,20 @@ function startLocalServer(opts) {
                     fields.roleLabel = b.roleLabel ?? b.role_label;
                 if (b.roleClass !== undefined || b.role_class !== undefined)
                     fields.roleClass = b.roleClass ?? b.role_class;
+                if (b.orchestrationRoleLabel !== undefined || b.orchestration_role_label !== undefined)
+                    fields.orchestrationRoleLabel = b.orchestrationRoleLabel ?? b.orchestration_role_label;
+                if (b.orchestrationRoleClass !== undefined || b.orchestration_role_class !== undefined)
+                    fields.orchestrationRoleClass = b.orchestrationRoleClass ?? b.orchestration_role_class;
+                if (b.orchestrationIncludeUserPrompt !== undefined || b.orchestration_include_user_prompt !== undefined)
+                    fields.orchestrationIncludeUserPrompt = b.orchestrationIncludeUserPrompt ?? b.orchestration_include_user_prompt;
                 if (b.isActive !== undefined || b.is_active !== undefined)
                     fields.isActive = b.isActive ?? b.is_active;
                 if (b.priority !== undefined)
                     fields.priority = b.priority;
+                if (b.color !== undefined)
+                    fields.color = b.color;
+                if (b.purposeMd !== undefined || b.purpose_md !== undefined)
+                    fields.purposeMd = b.purposeMd ?? b.purpose_md;
                 if (b.showThinking !== undefined || b.show_thinking !== undefined)
                     fields.showThinking = b.showThinking ?? b.show_thinking;
                 if (b.isOrchestrator !== undefined || b.is_orchestrator !== undefined)
@@ -1333,14 +2474,33 @@ function startLocalServer(opts) {
                     fields.codexSandboxPolicy = b.codexSandboxPolicy ?? b.codex_sandbox_policy;
                 if (b.codexApprovalPolicy !== undefined || b.codex_approval_policy !== undefined)
                     fields.codexApprovalPolicy = b.codexApprovalPolicy ?? b.codex_approval_policy;
+                if (b.claudeEffortLevel !== undefined || b.claude_effort_level !== undefined)
+                    fields.claudeEffortLevel = b.claudeEffortLevel ?? b.claude_effort_level;
+                if (b.claudeOutputStyle !== undefined || b.claude_output_style !== undefined)
+                    fields.claudeOutputStyle = b.claudeOutputStyle ?? b.claude_output_style;
+                if (b.claudeFastMode !== undefined || b.claude_fast_mode !== undefined)
+                    fields.claudeFastMode = b.claudeFastMode ?? b.claude_fast_mode;
+                if (b.claudePermissionsJson !== undefined || b.claude_permissions_json !== undefined)
+                    fields.claudePermissionsJson = b.claudePermissionsJson ?? b.claude_permissions_json;
+                if (b.orchestrationRolesJson !== undefined || b.orchestration_roles_json !== undefined) {
+                    fields.orchestrationRolesJson = normalizeRolesArray(b.orchestrationRolesJson ?? b.orchestration_roles_json);
+                }
                 if (isConnectedMode()) {
                     const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
                     const auth = await getHydratedDesktopAuth();
                     return res.json(await (0, server_adapter_1.updateServerBot)(auth, runtime, req.params.id, fields));
                 }
+                const previous = data.getAgentProfile(req.params.id);
                 const updated = data.updateAgentProfile(req.params.id, fields);
                 if (!updated)
                     return res.status(404).json({ error: 'Not found' });
+                syncCliBotConfigFiles(updated);
+                reapCliBotSessions(updated.id);
+                watchCliBotConfig(updated);
+                if (previous && previous.id !== updated.id) {
+                    reapCliBotSessions(previous.id);
+                    closeCliBotConfigWatcher(previous.id);
+                }
                 res.json(updated);
             }
             catch (err) {
@@ -1376,6 +2536,8 @@ function startLocalServer(opts) {
                 const deleted = data.deleteAgentProfile(req.params.id);
                 if (!deleted)
                     return res.status(404).json({ error: 'Not found' });
+                closeCliBotConfigWatcher(req.params.id);
+                reapCliBotSessions(req.params.id);
                 res.json({ ok: true });
             }
             catch (err) {
@@ -1397,18 +2559,52 @@ function startLocalServer(opts) {
                     return res.status(404).json({ error: 'Not found' });
                 const convCount = data.countConversations(req.params.id);
                 const messageCount = data.countMessagesForBot(req.params.id);
+                const now = new Date();
+                const todayStart = new Date(now);
+                todayStart.setHours(0, 0, 0, 0);
+                const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+                const twoWeeksAgo = new Date(now.getTime() - 14 * 24 * 60 * 60 * 1000);
+                const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+                const decisionCount = data.countDecisionsForBot(req.params.id);
+                const messagesToday = data.countMessagesForBotSince(req.params.id, todayStart.toISOString());
+                const convsThisWeek = data.countBotConversationsUpdatedBetween(req.params.id, oneWeekAgo.toISOString());
+                const convsPrevWeek = data.countBotConversationsUpdatedBetween(req.params.id, twoWeeksAgo.toISOString(), oneWeekAgo.toISOString());
+                const tokenUsage = data.sumBotTokenUsageSince(req.params.id, monthStart.toISOString());
+                const activeDays = data.countBotActiveDays(req.params.id);
+                const createdAt = profile.created_at || now.toISOString();
+                const daysSinceCreation = Math.max(1, Math.ceil((now.getTime() - new Date(createdAt).getTime()) / (24 * 60 * 60 * 1000)));
+                const uptimePercent = Math.min(100, Math.round((activeDays / daysSinceCreation) * 100));
+                const convTrend = convsThisWeek > convsPrevWeek ? 'up' : convsThisWeek < convsPrevWeek ? 'down' : 'flat';
+                const estimatedCost = Math.round(tokenUsage * 0.000003 * 100) / 100;
                 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,
+                    updatedAt: conversation.updated_at,
+                    createdAt: conversation.created_at,
+                    messageCount: conversation.message_count,
+                    botMessageCount: conversation.bot_message_count,
+                    botLastMessageAt: conversation.bot_last_message_at,
+                    projectName: conversation.project_name,
                 }));
-                res.json({ profile, conversationCount: convCount, messageCount, recentConversations });
+                const lastActivityAt = recentConversations[0]?.botLastMessageAt || recentConversations[0]?.updatedAt || null;
+                res.json({
+                    botId: req.params.id,
+                    botName: profile.name || profile.id,
+                    status: profile.is_active === 0 ? 'inactive' : 'active',
+                    createdAt,
+                    totalConversations: convCount,
+                    totalMessages: messageCount,
+                    totalDecisions: decisionCount,
+                    messagesToday,
+                    lastActivityAt,
+                    uptimePercent,
+                    avgResponseTime: null,
+                    convTrend,
+                    tokenUsage,
+                    estimatedCost,
+                    recentConversations,
+                    profile,
+                });
             }
             catch (err) {
                 res.status(500).json({ error: err.message });
@@ -1447,7 +2643,7 @@ function startLocalServer(opts) {
     app.post('/api/conversations', (req, res) => {
         (async () => {
             try {
-                const { agentId, title, source, projectId, projectName } = req.body;
+                const { agentId, botIds, initialBotId, title, source, projectId, projectName, topicId } = req.body;
                 if (isConnectedMode()) {
                     const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
                     const auth = await getHydratedDesktopAuth();
@@ -1462,12 +2658,27 @@ function startLocalServer(opts) {
                         ...(projectName ? { project_name: projectName } : {}),
                     });
                 }
-                if (!agentId)
-                    return res.status(400).json({ error: 'agentId is required' });
-                const conv = data.createConversation(agentId, title, source, {
+                const normalizedBotIds = Array.isArray(botIds)
+                    ? botIds.map((value) => String(value || '').trim()).filter(Boolean)
+                    : [];
+                const resolvedInitialBotId = String(initialBotId || agentId || normalizedBotIds[0] || '').trim();
+                if (!resolvedInitialBotId)
+                    return res.status(400).json({ error: 'agentId or botIds is required' });
+                const conv = data.createConversation(resolvedInitialBotId, title, source, {
                     projectId: projectId ?? null,
                     projectName: projectName ?? null,
+                    botIds: normalizedBotIds,
+                    initialBotId: resolvedInitialBotId,
                 });
+                if (topicId) {
+                    try {
+                        data.upsertConversationTopicSegment(conv.id, String(topicId));
+                    }
+                    catch { /* best-effort */ }
+                }
+                emitConversationSyncEvents(conv.id, [
+                    { change: 'conversation.created' },
+                ]);
                 res.status(201).json(conv);
             }
             catch (err) {
@@ -1512,9 +2723,14 @@ function startLocalServer(opts) {
                     const auth = await getHydratedDesktopAuth();
                     return res.json(await (0, server_adapter_1.deleteServerConversation)(auth, runtime, req.params.id));
                 }
+                const existing = data.getConversation(req.params.id);
+                if (!existing)
+                    return res.status(404).json({ error: 'Not found' });
+                closeCliSessionsForConversation(req.params.id, 'conversation_deleted');
                 const deleted = data.deleteConversation(req.params.id);
                 if (!deleted)
                     return res.status(404).json({ error: 'Not found' });
+                emitDeletedConversationSyncEvent(existing);
                 res.json({ ok: true });
             }
             catch (err) {
@@ -1534,6 +2750,9 @@ function startLocalServer(opts) {
                 if (!conv)
                     return res.status(404).json({ error: 'Not found' });
                 data.updateConversation(req.params.id, req.body);
+                emitConversationSyncEvents(req.params.id, [
+                    { change: 'conversation.updated' },
+                ]);
                 res.json(data.getConversation(req.params.id));
             }
             catch (err) {
@@ -1638,6 +2857,12 @@ function startLocalServer(opts) {
                     const auth = await getHydratedDesktopAuth();
                     return res.json(await (0, server_adapter_1.deleteServerProject)(auth, runtime, req.params.id));
                 }
+                const projectConversationIds = data.listConversations({ limit: 100000 })
+                    .filter((conv) => conv.project_id === req.params.id)
+                    .map((conv) => conv.id);
+                for (const conversationId of projectConversationIds) {
+                    closeCliSessionsForConversation(conversationId, 'project_deleted');
+                }
                 const deleted = data.deleteProject(req.params.id);
                 if (!deleted)
                     return res.status(404).json({ error: 'Not found' });
@@ -1801,6 +3026,10 @@ function startLocalServer(opts) {
                     const auth = await getHydratedDesktopAuth();
                     return res.json(await (0, server_adapter_1.deleteServerTopic)(auth, runtime, req.params.id));
                 }
+                const topic = data.getTopic(req.params.id);
+                for (const segment of topic?.segments || []) {
+                    closeCliSessionsForConversation(segment.conversation_id, 'topic_deleted');
+                }
                 const deleted = data.deleteTopic(req.params.id);
                 if (!deleted)
                     return res.status(404).json({ error: 'Not found' });
@@ -2022,6 +3251,9 @@ function startLocalServer(opts) {
                 const botId = req.body?.botId ? String(req.body.botId) : undefined;
                 const agentName = req.body?.agentName ? String(req.body.agentName) : undefined;
                 const msg = data.addMessage(req.params.id, role, content, model, undefined, botId, agentName);
+                emitConversationSyncEvents(req.params.id, [
+                    { change: 'message.created', messageId: msg.id },
+                ]);
                 res.status(201).json(msg);
             }
             catch (err) {
@@ -2079,6 +3311,9 @@ function startLocalServer(opts) {
             });
             if (!updated)
                 return res.status(404).json({ error: 'Message not found' });
+            emitConversationSyncEvents(updated.conversation_id, [
+                { change: 'message.updated', messageId: updated.id },
+            ]);
             res.json(updated);
         }
         catch (err) {
@@ -2225,11 +3460,18 @@ function startLocalServer(opts) {
     app.post('/api/todo/:id/worker-complete', (req, res) => {
         try {
             const taskId = Number(req.params.id);
-            const { outputSummary, artifactRefs, handoffPrompt, insertTask, expectedVersion, expectedLastUpdated, } = req.body || {};
+            const { outputSummary, artifactRefs, handoffPrompt, qaResult, findings, requiresFixTask, insertTask, expectedVersion, expectedLastUpdated, } = req.body || {};
+            const rawQaResult = qaResult === undefined ? undefined : String(qaResult).trim().toLowerCase();
+            const normalizedQaResult = rawQaResult === 'pass' || rawQaResult === 'fail' || rawQaResult === 'not_applicable'
+                ? rawQaResult
+                : undefined;
             const result = data.completeTodoTaskByWorker(taskId, {
                 outputSummary: outputSummary === undefined ? undefined : String(outputSummary),
                 artifactRefs: Array.isArray(artifactRefs) ? artifactRefs : undefined,
                 handoffPrompt: handoffPrompt === undefined ? undefined : String(handoffPrompt),
+                qaResult: normalizedQaResult,
+                findings: Array.isArray(findings) ? findings.map((v) => String(v || '').trim()).filter(Boolean) : undefined,
+                requiresFixTask: requiresFixTask === undefined ? undefined : Boolean(requiresFixTask),
                 insertTask: insertTask ? {
                     title: String(insertTask.title || ''),
                     prompt: String(insertTask.prompt || ''),
@@ -2391,19 +3633,19 @@ function startLocalServer(opts) {
                     return res.json(result.messages);
                 }
                 if (hasDirectRange) {
-                    return res.json(data.getMessagesInRange(req.params.id, startSeq, endSeq));
+                    return res.json(serializeMessageHistoryForRequest(req, 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
                         ? data.getMessageRoundsBefore(req.params.id, beforeSeq, rounds)
                         : data.getMessagesBefore(req.params.id, beforeSeq, limit);
-                    res.json(msgs);
+                    res.json(serializeMessageHistoryForRequest(req, msgs));
                 }
                 else {
                     const offset = parseInt(req.query.offset, 10) || 0;
                     const msgs = data.getMessages(req.params.id, { limit, offset });
-                    res.json(msgs);
+                    res.json(serializeMessageHistoryForRequest(req, msgs));
                 }
             }
             catch (err) {
@@ -2461,90 +3703,51 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ─── Chat job gateway (shared by POST + GET endpoints) ────
+    const chatGateway = new local_chat_execution_1.LocalChatExecution({
+        runQueuedChatJobs,
+        runningChatJobControllers,
+        finalizeCancelledChatJobMessage,
+        persistInlineAttachments,
+    });
     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 && (data.isClerkOrchestratorEnabled() || (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.getLatestConversationBotChatJob(convId, profile.id);
-                if (latestJob && (latestJob.status === 'queued' || latestJob.status === 'running')) {
-                    return res.status(409).json({ error: 'This bot already has a pending response in this conversation.' });
-                }
-            }
-            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 isRelay = req.headers?.['x-funolio-relay'] === '1';
+            if (isConnectedMode() && !isRelay) {
+                const runtime = (0, server_runtime_1.getRuntimeConnectionConfig)();
+                const auth = await getHydratedDesktopAuth();
+                const result = await (0, server_adapter_1.createServerChatJob)(auth, runtime, req.body || {});
+                return res.status(201).json(result);
             }
-            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 result = await chatGateway.createJob(req.body || {});
+            const canonicalResponse = {
+                conversationId: result.conversationId,
+                jobs: result.jobs.map((j) => ({ id: j.id, botId: j.botId, status: j.status })),
+            };
+            if (isRelay) {
+                // In connected mode, the dep call inside chatGateway.createJob() is
+                // a no-op (isConnectedMode() guard). Force-run the queue so the
+                // relay-created job actually starts local execution.
+                runQueuedChatJobs({ force: true });
+                console.log(JSON.stringify({
+                    ts: new Date().toISOString(),
+                    level: 'info',
+                    event: 'JOB_CREATED_VIA_RELAY',
+                    jobId: result.jobs[0]?.id,
+                    conversationId: result.conversationId,
+                }));
             }
-            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,
-            });
+            res.status(201).json(canonicalResponse);
         }
         catch (err) {
-            res.status(500).json({ error: err.message });
+            const msg = err.message || '';
+            if (msg === 'message is required' || msg.startsWith('No bot configured')) {
+                return res.status(400).json({ error: msg });
+            }
+            if (msg.includes('already has a pending response')) {
+                return res.status(409).json({ error: msg });
+            }
+            res.status(500).json({ error: msg });
         }
     });
     app.post('/api/chat/jobs/:id/cancel', async (req, res) => {
@@ -2567,7 +3770,11 @@ function startLocalServer(opts) {
             }
             else {
                 finalizeCancelledChatJobMessage(job);
-                data.touchConversationActivity(job.conversation_id);
+                data.touchConversationActivity(job.conversation_id, ts);
+                emitConversationSyncEvents(job.conversation_id, [
+                    { change: 'message.updated', messageId: job.assistant_message_id },
+                    { change: 'job.cancelled', jobId: job.id, jobStatus: 'cancelled' },
+                ], { updatedAt: ts });
             }
             res.json({ ok: true, status: 'cancelled' });
         }
@@ -2575,7 +3782,95 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ─── Chat job GET endpoints ────────────────────────────────
+    app.get('/api/chat/jobs', async (req, res) => {
+        try {
+            const conversationId = req.query?.conversationId;
+            if (!conversationId || typeof conversationId !== 'string') {
+                return res.status(400).json({ error: 'conversationId query parameter is required' });
+            }
+            const result = await chatGateway.listJobs(conversationId);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/chat/jobs/:id', async (req, res) => {
+        try {
+            const result = await chatGateway.getJobStatus(req.params.id);
+            res.json(result);
+        }
+        catch (err) {
+            if (err.message === 'Job not found') {
+                return res.status(404).json({ error: 'Job not found' });
+            }
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/chat/jobs/:id/stream', async (req, res) => {
+        try {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+            });
+            let closed = false;
+            req.on('close', () => { closed = true; });
+            for await (const event of chatGateway.streamJob(req.params.id)) {
+                if (closed)
+                    break;
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+            if (!closed) {
+                res.write('data: [DONE]\n\n');
+                res.end();
+            }
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                if (err.message === 'Job not found') {
+                    return res.status(404).json({ error: 'Job not found' });
+                }
+                res.status(500).json({ error: err.message });
+            }
+            else {
+                res.write(`data: ${JSON.stringify({ type: 'error', error: err.message })}\n\n`);
+                res.write('data: [DONE]\n\n');
+                res.end();
+            }
+        }
+    });
     // ─── Chat (SSE streaming) ──────────────────────────────────
+    app.get('/api/chat/sync/stream', async (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        });
+        res.write(`event: ready\ndata: ${JSON.stringify({ ok: true })}\n\n`);
+        const heartbeat = setInterval(() => {
+            try {
+                res.write(`event: ping\ndata: ${JSON.stringify({ ts: Date.now() })}\n\n`);
+            }
+            catch {
+                // Connection cleanup handled below.
+            }
+        }, 15000);
+        const unsubscribe = (0, chat_sync_1.subscribeChatSync)((event) => {
+            try {
+                res.write(`event: sync\ndata: ${JSON.stringify(event)}\n\n`);
+            }
+            catch {
+                // Connection cleanup handled below.
+            }
+        });
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+            res.end();
+        });
+    });
     app.post('/api/conversations/:id/chat-job/cancel', async (req, res) => {
         try {
             const requestedBotId = String(req.body?.botId || '').trim();
@@ -2599,7 +3894,11 @@ function startLocalServer(opts) {
             }
             else {
                 finalizeCancelledChatJobMessage(latestJob);
-                data.touchConversationActivity(latestJob.conversation_id);
+                data.touchConversationActivity(latestJob.conversation_id, ts);
+                emitConversationSyncEvents(latestJob.conversation_id, [
+                    { change: 'message.updated', messageId: latestJob.assistant_message_id },
+                    { change: 'job.cancelled', jobId: latestJob.id, jobStatus: 'cancelled' },
+                ], { updatedAt: ts });
                 void runQueuedChatJobs();
             }
             res.json({ ok: true, status: 'cancelled', jobId: latestJob.id });
@@ -2619,14 +3918,42 @@ function startLocalServer(opts) {
         req.on('close', abortOnClientClose);
         res.on('close', abortOnClientClose);
         try {
-            let { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId, orchestrationEnabled, chatJobId, assistantMessageId, persistAssistantPlaceholder, } = req.body;
+            let { conversationId, message, botId, skipUserMessage, pinnedMessageIds, topicId, projectId, workflowTemplateId, orchestrationEnabled, chatJobId, assistantMessageId, persistAssistantPlaceholder, botIds, attachments, } = req.body;
             if (!message)
                 return res.status(400).json({ error: 'message is required' });
+            const requestedBotIds = [
+                typeof botId === 'string' ? botId : '',
+                ...(Array.isArray(botIds) ? botIds : []),
+            ]
+                .map((value) => String(value || '').trim())
+                .filter((value, index, list) => !!value && list.indexOf(value) === index);
+            const resolvedBotId = requestedBotIds[0] || null;
+            const normalizedOrchestrationEnabled = typeof orchestrationEnabled === 'boolean'
+                ? orchestrationEnabled
+                : typeof req.body?.orchestrate === 'boolean'
+                    ? req.body.orchestrate
+                    : true;
+            // ─── token.txt §6: bench-prefix tagging ─────────────────────────
+            // Detect [bench:<id>] at the start of the user message OR
+            // X-Test-Run-Id header. If present, strip the prefix from the
+            // message (so the LLM never sees it / token counts aren't
+            // inflated) and remember testRunId + turnIndex for the
+            // LlmUsageLog row written after the LLM call returns.
+            const __benchHeader = String(req.headers?.['x-test-run-id'] || '').trim();
+            const __turnIndexHeader = String(req.headers?.['x-test-turn-index'] || '').trim();
+            const __turnIndexParsed = __turnIndexHeader ? parseInt(__turnIndexHeader, 10) : null;
+            const __benchResult = (0, bench_prefix_1.extractBenchPrefix)(typeof message === 'string' ? message : '');
+            const __testRunId = __benchHeader || __benchResult.testRunId || null;
+            if (__benchResult.testRunId && typeof message === 'string') {
+                message = __benchResult.cleanMessage;
+            }
+            const __benchUserMessage = typeof message === 'string' ? message : null;
+            // ─── end bench-prefix block ─────────────────────────────────────
             if (await relayConnectedChat(req, res)) {
                 return;
             }
             // Resolve bot
-            let profile = botId ? data.getAgentProfile(botId) : data.getDefaultAgentProfile();
+            let profile = resolvedBotId ? data.getAgentProfile(resolvedBotId) : data.getDefaultAgentProfile();
             if (!profile) {
                 // Auto-create a default profile from the DB-backed provider connection if available.
                 const providerConnection = data.listProviderConnections().find((conn) => conn.access_mode === 'cli' || !!conn.api_key_enc);
@@ -2642,7 +3969,11 @@ function startLocalServer(opts) {
                 if (!profile)
                     return res.status(400).json({ error: 'No bot configured. Create one first.' });
             }
+            const incomingAttachments = parseChatAttachmentInputs(attachments);
+            const shouldUseOrchestratorMode = normalizedOrchestrationEnabled !== false && (data.isClerkOrchestratorEnabled() || (0, orchestrator_profile_1.isOrchestratorProfile)(profile));
             // Resolve or create conversation
+            let conversationCreated = false;
+            let turnStartSyncRevision = null;
             let convId = conversationId;
             if (!convId) {
                 // Create with empty title so auto-title can fill it in after first response
@@ -2654,8 +3985,14 @@ function startLocalServer(opts) {
                 const requestedProjectId = (projectId ? String(projectId) : null) || topicProjectId;
                 const conv = data.createConversation(profile.id, '', 'local', {
                     projectId: requestedProjectId,
+                    botIds: requestedBotIds.length > 0 ? requestedBotIds : [profile.id],
+                    initialBotId: profile.id,
                 });
                 convId = conv.id;
+                conversationCreated = true;
+            }
+            if (convId) {
+                data.syncConversationParticipants(convId, requestedBotIds.length > 0 ? requestedBotIds : [profile.id], { initialBotId: profile.id, replace: true });
             }
             // Link conversation to topic if topicId provided
             if (topicId && convId) {
@@ -2731,8 +4068,12 @@ function startLocalServer(opts) {
             };
             // Save user message (skip if multi-bot call where first bot already saved it)
             let savedUserMessage = null;
+            let persistedAttachments = [];
             if (!skipUserMessage) {
-                savedUserMessage = data.addMessage(convId, 'user', message);
+                persistedAttachments = incomingAttachments.length > 0
+                    ? persistInlineAttachments(convId, incomingAttachments)
+                    : [];
+                savedUserMessage = data.addMessage(convId, 'user', message, undefined, undefined, undefined, undefined, undefined, persistedAttachments.length > 0 ? JSON.stringify(persistedAttachments) : null);
                 (0, context_window_1.incrementTurnCount)(convId);
                 const convForPolicy = data.getConversation(convId);
                 const effectiveProjectId = projectId ? String(projectId) : (convForPolicy?.project_id || undefined);
@@ -2757,24 +4098,229 @@ function startLocalServer(opts) {
                     });
                 }
             }
-            if (!assistantMessageId && persistAssistantPlaceholder === true) {
+            if (savedUserMessage) {
+                turnStartSyncRevision = emitConversationSyncEvents(convId, [
+                    ...(conversationCreated ? [{ change: 'conversation.created' }] : []),
+                    { change: 'message.created', messageId: savedUserMessage.id },
+                ]);
+            }
+            const interceptedSlashCommand = (0, slash_commands_1.classifySlashCommand)(message, profile?.provider);
+            if (interceptedSlashCommand) {
+                if (!assistantMessageId && persistAssistantPlaceholder === true) {
+                    const placeholder = data.addMessage(convId, 'assistant', '', buildConfiguredMessageModel(profile), undefined, profile?.id || undefined, profile?.name || undefined);
+                    assistantMessageId = placeholder.id;
+                    turnStartSyncRevision = emitConversationSyncEvents(convId, [
+                        { change: 'message.created', messageId: placeholder.id },
+                    ], turnStartSyncRevision ? { revision: turnStartSyncRevision } : undefined);
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'X-Conversation-Id': convId,
+                });
+                const sendSlashEvent = (event, payload) => {
+                    if (responseEnded)
+                        return;
+                    res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+                };
+                sendSlashEvent('meta', {
+                    conversationId: convId,
+                    botId: profile.id,
+                    assistantMessageId: assistantMessageId || null,
+                });
+                if (interceptedSlashCommand.kind === 'rotate') {
+                    data.upsertCliSessionEpoch({
+                        conversationId: convId,
+                        botId: profile.id,
+                        provider: profile.provider,
+                        sessionId: '',
+                        epochTurnCount: 0,
+                        lastInputTokens: 0,
+                        lastOutputTokens: 0,
+                        resetReason: interceptedSlashCommand.resetReason,
+                        epochStartedAt: localTimestamp(),
+                        lastUsedAt: localTimestamp(),
+                    });
+                    reapCliBotSessions(profile.id);
+                    if (assistantMessageId) {
+                        data.updateMessage(assistantMessageId, {
+                            content: interceptedSlashCommand.summary,
+                            model: buildConfiguredMessageModel(profile),
+                            botId: profile.id,
+                            agentName: profile.name,
+                        });
+                        emitConversationSyncEvents(convId, [
+                            { change: 'message.updated', messageId: assistantMessageId },
+                        ]);
+                    }
+                    sendSlashEvent('done', {
+                        content: interceptedSlashCommand.summary,
+                    });
+                    responseEnded = true;
+                    res.end();
+                    return;
+                }
+                if (interceptedSlashCommand.kind === 'settings-ui') {
+                    sendSlashEvent('slash_command', {
+                        kind: interceptedSlashCommand.kind,
+                        command: interceptedSlashCommand.command,
+                        provider: interceptedSlashCommand.provider,
+                        botId: profile.id,
+                        conversationId: convId,
+                        assistantMessageId: assistantMessageId || null,
+                        summary: interceptedSlashCommand.summary,
+                    });
+                    if (assistantMessageId) {
+                        data.updateMessage(assistantMessageId, {
+                            content: interceptedSlashCommand.summary,
+                            model: buildConfiguredMessageModel(profile),
+                            botId: profile.id,
+                            agentName: profile.name,
+                        });
+                        emitConversationSyncEvents(convId, [
+                            { change: 'message.updated', messageId: assistantMessageId },
+                        ]);
+                    }
+                    sendSlashEvent('done', {
+                        content: interceptedSlashCommand.summary,
+                    });
+                    responseEnded = true;
+                    res.end();
+                    return;
+                }
+                const workspaceForSlashCommand = (() => {
+                    const conversation = data.getConversation(convId);
+                    const project = conversation?.project_id ? data.getProject(conversation.project_id) : undefined;
+                    const workspacePath = project?.folder?.trim() || undefined;
+                    return workspacePath && fs.existsSync(workspacePath) ? workspacePath : opts.projectDir;
+                })();
+                try {
+                    const passthroughResult = await (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)().runPassthroughCommand({
+                        conversationId: convId,
+                        botId: profile.id,
+                        provider: interceptedSlashCommand.provider,
+                        botSettings: {
+                            claude: interceptedSlashCommand.provider === 'claude-cli'
+                                ? {
+                                    model: profile.model,
+                                    effortLevel: profile.claude_effort_level,
+                                    outputStyle: profile.claude_output_style,
+                                    fastMode: profile.claude_fast_mode === 1,
+                                    permissionsJson: profile.claude_permissions_json,
+                                }
+                                : null,
+                            codex: interceptedSlashCommand.provider === 'codex-cli'
+                                ? {
+                                    model: profile.model,
+                                    reasoningEffort: profile.codex_reasoning_effort,
+                                    personality: profile.codex_personality,
+                                    serviceTier: profile.codex_service_tier,
+                                    sandboxPolicy: profile.codex_sandbox_policy,
+                                    approvalPolicy: profile.codex_approval_policy,
+                                }
+                                : null,
+                        },
+                        cwd: workspaceForSlashCommand,
+                        command: interceptedSlashCommand.command,
+                        abortSignal: routeAbortController.signal,
+                        onRawChunk: async (chunk) => {
+                            sendSlashEvent('terminal_chunk', {
+                                text: chunk,
+                                provider: interceptedSlashCommand.provider,
+                                botId: profile.id,
+                                agentName: profile.name,
+                            });
+                        },
+                    });
+                    const finalContent = passthroughResult.content.trim() || interceptedSlashCommand.summary;
+                    if (assistantMessageId) {
+                        data.updateMessage(assistantMessageId, {
+                            content: finalContent,
+                            model: buildConfiguredMessageModel(profile),
+                            botId: profile.id,
+                            agentName: profile.name,
+                        });
+                        emitConversationSyncEvents(convId, [
+                            { change: 'message.updated', messageId: assistantMessageId },
+                        ]);
+                    }
+                    sendSlashEvent('done', {
+                        content: finalContent,
+                    });
+                    responseEnded = true;
+                    res.end();
+                    return;
+                }
+                catch (slashErr) {
+                    const errorMessage = slashErr?.message || `Failed to run ${interceptedSlashCommand.command}`;
+                    if (assistantMessageId) {
+                        data.updateMessage(assistantMessageId, {
+                            content: `Error: ${errorMessage}`,
+                            model: buildConfiguredMessageModel(profile),
+                            botId: profile.id,
+                            agentName: profile.name,
+                        });
+                        emitConversationSyncEvents(convId, [
+                            { change: 'message.updated', messageId: assistantMessageId },
+                        ]);
+                    }
+                    sendSlashEvent('error', { error: errorMessage });
+                    responseEnded = true;
+                    res.end();
+                    return;
+                }
+            }
+            const storedAttachmentsForTurn = resolveStoredAttachmentsForTurn({
+                conversationId: convId,
+                message,
+                skipUserMessage: !!skipUserMessage,
+                chatJobId: chatJobId ? String(chatJobId) : null,
+                persistedAttachments,
+            });
+            const conversationForAttachments = data.getConversation(convId);
+            const projectForAttachments = conversationForAttachments?.project_id ? data.getProject(conversationForAttachments.project_id) : undefined;
+            const attachmentWorkspacePath = projectForAttachments?.folder?.trim() || opts.projectDir;
+            const attachmentSummaryBlock = storedAttachmentsForTurn.length > 0
+                ? await summarizeStoredAttachmentsForTextRuntime({
+                    attachments: storedAttachmentsForTurn,
+                    workspacePath: attachmentWorkspacePath,
+                    userPrompt: message,
+                    preferredProfile: profile,
+                })
+                : '';
+            const runtimeUserPrompt = attachmentSummaryBlock ? `${message}${attachmentSummaryBlock}` : message;
+            if (!assistantMessageId && persistAssistantPlaceholder === true && !shouldUseOrchestratorMode) {
                 const placeholder = data.addMessage(convId, 'assistant', '', buildConfiguredMessageModel(profile), undefined, profile?.id || undefined, profile?.name || undefined);
                 assistantMessageId = placeholder.id;
+                turnStartSyncRevision = emitConversationSyncEvents(convId, [
+                    { change: 'message.created', messageId: placeholder.id },
+                ], turnStartSyncRevision ? { revision: turnStartSyncRevision } : undefined);
             }
             // ─── Orchestrator Mode Branch ─────────────────────────
-            const shouldUseOrchestratorMode = orchestrationEnabled !== false && (data.isClerkOrchestratorEnabled() || (0, orchestrator_profile_1.isOrchestratorProfile)(profile));
             if (shouldUseOrchestratorMode) {
                 const { OrchestratorAgent } = require('./orchestrator');
                 const { buildLocalDesktopOrchestratorRuntime } = require('./orchestrator');
                 const { getWorkflowEngine } = require('./workflow-engine');
                 const workflowEngine = getWorkflowEngine(opts.projectDir, 'local_desktop');
+                // Resolve orchestrator runtime independently of request/conversation bot identity.
+                // The request botId is a participant hint, never runtime authority.
+                // Orchestrator must be explicitly designated: clerk → is_orchestrator=1 bot.
+                // No fallback to is_default=1 (that's the hardcoded-Ben trap — made the
+                // default worker bot double as the orchestrator and caused dispatch bugs).
+                const orchestratorBotIdHint = data.isClerkOrchestratorEnabled()
+                    ? null
+                    : (data.getOrchestratorBot()?.id || null);
+                const explicitOrchestratorBot = orchestratorBotIdHint
+                    ? data.getAgentProfile(orchestratorBotIdHint)
+                    : null;
                 let orchestratorRuntime;
                 try {
-                    orchestratorRuntime = buildLocalDesktopOrchestratorRuntime(profile);
+                    orchestratorRuntime = buildLocalDesktopOrchestratorRuntime(explicitOrchestratorBot);
                 }
                 catch (runtimeErr) {
                     return res.status(400).json({
-                        error: runtimeErr?.message || 'Orchestrator mode is not configured correctly.',
+                        error: runtimeErr?.message || 'Orchestrator mode is not configured. Mark a bot with is_orchestrator=1 or enable Clerk orchestration.',
                     });
                 }
                 const orchestrator = new OrchestratorAgent(orchestratorRuntime, workflowEngine);
@@ -2786,6 +4332,44 @@ function startLocalServer(opts) {
                     const shortTitle = message.slice(0, 60).replace(/\n/g, ' ').trim();
                     data.updateConversation(convId, { title: shortTitle || 'New Chat' });
                 }
+                // Create an empty assistant placeholder message BEFORE the
+                // orchestrator runs. All worker progress activities recorded via
+                // recordWorkerActivity (below) attach to this message_id, so the
+                // UI can render the in-flight orchestrator card immediately — no
+                // more blank chat pane when a user navigates away mid-run and
+                // comes back. (april19fixes.txt item 6a.) At turn end we UPDATE
+                // the placeholder with the final orchestrator response instead
+                // of addMessage'ing a new row.
+                //
+                // Identity note (Codex QA 2026-04-19 on 308cbcfd): when Clerk
+                // is the orchestrator, the placeholder must be attributed to
+                // the Orchestrator, not to the selected request bot (profile).
+                // Otherwise the in-flight card renders under the wrong bot
+                // identity mid-run, and an errored turn permanently persists
+                // under the wrong bot. At turn end we update agentName/botId/
+                // model with the authoritative final values from
+                // orchestrator.getLastResponseMeta().
+                const placeholderClerkMode = data.isClerkOrchestratorEnabled();
+                const placeholderAgentName = placeholderClerkMode
+                    ? 'Orchestrator'
+                    : (profile?.name || undefined);
+                const placeholderBotId = placeholderClerkMode
+                    ? undefined
+                    : (profile?.id || undefined);
+                const placeholderClerkConfig = placeholderClerkMode
+                    ? data.getResolvedClerkConfigInfo()
+                    : null;
+                const placeholderModel = placeholderClerkMode
+                    ? ((placeholderClerkConfig?.model || '').trim() || 'Orchestrator')
+                    : buildConfiguredMessageModel(profile);
+                if (!assistantMessageId) {
+                    const placeholder = data.addMessage(convId, 'assistant', '', placeholderModel, undefined, placeholderBotId, placeholderAgentName);
+                    assistantMessageId = placeholder.id;
+                    activityErrorContext.messageId = String(assistantMessageId);
+                    turnStartSyncRevision = emitConversationSyncEvents(convId, [
+                        { change: 'message.created', messageId: placeholder.id },
+                    ], turnStartSyncRevision ? { revision: turnStartSyncRevision } : undefined);
+                }
                 // SSE setup — same contract as normal chat path
                 res.writeHead(200, {
                     'Content-Type': 'text/event-stream',
@@ -2803,9 +4387,12 @@ function startLocalServer(opts) {
                 const clerkSelectedAsOrchestrator = data.isClerkOrchestratorEnabled();
                 try {
                     if (clerkSelectedAsOrchestrator) {
-                        const clerkProvider = data.getSetting('clerk_provider') || profile.provider;
-                        const clerkModel = data.getSetting('clerk_model') || profile.model || null;
-                        const clerkConnection = data.findProviderConnection(clerkProvider);
+                        const clerkConfig = data.getResolvedClerkConfigInfo();
+                        const clerkProvider = clerkConfig.provider || profile.provider;
+                        const clerkModel = clerkConfig.model || profile.model || null;
+                        const clerkConnection = clerkConfig.providerConnectionId
+                            ? data.getProviderConnection(clerkConfig.providerConnectionId)
+                            : data.findProviderConnection(clerkProvider);
                         const clerkRuntimeMode = clerkProvider === 'claude-cli' || clerkProvider === 'codex-cli'
                             ? 'subscription-cli'
                             : 'api-key';
@@ -2834,22 +4421,24 @@ function startLocalServer(opts) {
                 }
                 sendEvent('meta', {
                     conversationId: convId,
+                    assistantMessageId: assistantMessageId || null,
                     ...(orchestratorRuntimePayload ? { runtime: orchestratorRuntimePayload } : {}),
                 });
                 let lastProgressChat = '';
                 let lastProgressActivity = '';
                 let selfExecuteStreamed = false;
-                let hasWorkerActivity = false;
                 try {
                     let lastInterimMessage = '';
-                    const response = await orchestrator.handleUserMessage(message, convId, {
+                    const response = await orchestrator.handleUserMessage(runtimeUserPrompt, convId, {
                         projectDir: opts.projectDir,
                         projectId: effectiveProjectId,
+                        orchestratorBotIdHint,
+                        storedAttachments: storedAttachmentsForTurn.length > 0 ? storedAttachmentsForTurn : undefined,
+                        abortSignal: routeAbortController.signal,
                         commandId: `local-${Date.now()}`,
                         workflowTemplateId: workflowTemplateId || undefined,
                         onWorkerChunk: (event) => {
                             if (event.type === 'step_start') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_step_start', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2868,7 +4457,6 @@ function startLocalServer(opts) {
                                 });
                             }
                             else if (event.type === 'worker_chunk') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_chunk', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2889,7 +4477,6 @@ function startLocalServer(opts) {
                                 });
                             }
                             else if (event.type === 'worker_terminal_chunk') {
-                                hasWorkerActivity = true;
                                 sendEvent('worker_terminal_chunk', {
                                     stepId: event.stepId,
                                     botId: resolveWorkerBotId(event.agentName),
@@ -2901,7 +4488,6 @@ function startLocalServer(opts) {
                                 });
                             }
                             else if (event.type === 'worker_tool_call') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_tool_call', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2926,7 +4512,6 @@ function startLocalServer(opts) {
                                 });
                             }
                             else if (event.type === 'worker_tool_result') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_tool_result', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2965,7 +4550,6 @@ function startLocalServer(opts) {
                                 sendEvent('chunk', { text: `> [${icon}] ${event.toolName} completed\n` });
                             }
                             else if (event.type === 'step_done') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_step_done', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -3002,7 +4586,7 @@ function startLocalServer(opts) {
                             // Progress chatText suppressed — worker card handles all streaming display.
                             // Main bubble only gets final content via 'done' event.
                             // Emit interim messages for key orchestrator transitions
-                            const interimMessage = deriveOrchestratorInterimMessage(status);
+                            const interimMessage = deriveVisibleOrchestratorMessage(status);
                             if (interimMessage && interimMessage !== lastInterimMessage) {
                                 lastInterimMessage = interimMessage;
                                 recordActivity('orchestrator_interim', { text: interimMessage }, interimMessage);
@@ -3022,41 +4606,44 @@ function startLocalServer(opts) {
                     // Save O's response (no incrementTurnCount — Fix #1: user message already incremented it)
                     const responseMeta = orchestrator.getLastResponseMeta();
                     const finalAgentName = responseMeta?.agentName || 'Orchestrator';
-                    const finalBotId = responseMeta?.botId || (finalAgentName === 'Orchestrator' ? profile.id : undefined);
+                    const finalBotId = responseMeta?.botId
+                        || (finalAgentName === 'Orchestrator' && !clerkSelectedAsOrchestrator ? 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,
+                    // UPDATE the placeholder we created at turn start (april19fixes.txt
+                    // item 6a). Activities are already attached via assistantMessageId,
+                    // so the final message row completes the in-flight card rather than
+                    // creating a second message row.
+                    let savedMessage = assistantMessageId
+                        ? data.updateMessage(assistantMessageId, {
+                            content: response,
+                            model: finalModelLabel,
                             botId: finalBotId,
                             agentName: finalAgentName,
-                            activityType: 'message',
-                            summary: 'Final assistant response',
-                            payload: { content: response },
-                            expiresAt: activityExpiresAt,
-                        });
+                        })
+                        : null;
+                    if (!savedMessage) {
+                        savedMessage = data.addMessage(convId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
                     }
-                    else {
-                        const savedMessage = data.addMessage(convId, 'assistant', response, finalModelLabel, undefined, finalBotId, finalAgentName);
-                        data.attachMessageActivitiesToMessage(activityStreamId, savedMessage.id);
-                        data.createMessageActivity({
-                            conversationId: convId,
+                    emitConversationSyncEvents(convId, [
+                        {
+                            change: savedMessage.id === assistantMessageId ? 'message.updated' : 'message.created',
                             messageId: savedMessage.id,
-                            botId: finalBotId,
-                            agentName: finalAgentName,
-                            activityType: 'message',
-                            summary: 'Final orchestrator response',
-                            payload: { content: response },
-                            expiresAt: activityExpiresAt,
-                        });
-                    }
+                        },
+                    ]);
+                    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 && !splitFinalMessage) {
+                    if (!selfExecuteStreamed) {
                         sendEvent('chunk', { text: response });
                     }
                     sendEvent('done', {
@@ -3064,7 +4651,6 @@ function startLocalServer(opts) {
                         content: response,
                         agentName: finalAgentName,
                         botId: finalBotId,
-                        separateFinalMessage: splitFinalMessage,
                         ...((responseMeta?.modelLabel || orchestratorRuntimePayload)
                             ? {
                                 runtime: {
@@ -3084,7 +4670,41 @@ function startLocalServer(opts) {
                     (0, local_funnel_1.scheduleFunnelProcessing)(convId);
                 }
                 catch (orchErr) {
-                    recordActivity('error', { error: orchErr.message }, orchErr.message);
+                    if (routeAbortController.signal.aborted || orchErr?.name === 'AbortError') {
+                        responseEnded = true;
+                        res.end();
+                        return;
+                    }
+                    // Log the full stack so recursion crashes like "Maximum
+                    // call stack size exceeded" land in agent.log with the
+                    // failing frame. Previously only the message was captured.
+                    console.error(chalk_1.default.red(`Orchestrator error: ${orchErr.message}`));
+                    if (orchErr?.stack) {
+                        console.error(String(orchErr.stack));
+                    }
+                    recordActivity('error', { error: orchErr.message, stack: orchErr?.stack || null }, orchErr.message);
+                    // Populate the placeholder with the error text AND correct
+                    // the identity fields so an errored turn doesn't remain
+                    // persisted under the wrong bot. Under Clerk orchestration
+                    // the placeholder was created with agentName='Orchestrator',
+                    // botId=null — those are re-applied here explicitly because
+                    // updateMessage with no overrides preserves existing values
+                    // but we want to guarantee nothing else mutated them.
+                    // (Codex QA 2026-04-19 on 308cbcfd: error-path identity bug.)
+                    if (assistantMessageId) {
+                        try {
+                            data.updateMessage(assistantMessageId, {
+                                content: `Error: ${orchErr.message}`,
+                                agentName: placeholderAgentName,
+                                botId: placeholderBotId,
+                                model: placeholderModel,
+                            });
+                            emitConversationSyncEvents(convId, [
+                                { change: 'message.updated', messageId: assistantMessageId },
+                            ]);
+                        }
+                        catch { /* best effort */ }
+                    }
                     sendEvent('error', { type: 'error', error: orchErr.message });
                     responseEnded = true;
                     res.end();
@@ -3104,13 +4724,6 @@ function startLocalServer(opts) {
                 : expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredMcpTools);
             const toolDefs = allToolDefs.filter((tool) => allowedToolNames.has(tool.name));
             const conversation = data.getConversation(convId);
-            const topicTitle = topicId ? data.getTopic(topicId)?.title : undefined;
-            const project = conversation?.project_id ? data.getProject(conversation.project_id) : undefined;
-            const workspacePath = project?.folder?.trim() || undefined;
-            let llmSpawnCwd = opts.projectDir;
-            if (workspacePath && fs.existsSync(workspacePath)) {
-                llmSpawnCwd = workspacePath;
-            }
             // Resolve LLM runtime early so the local desktop prompt contract can differ
             // between API/fresh CLI and recurring CLI sessions without affecting server paths.
             const runtime = await buildChatRuntime(profile);
@@ -3140,33 +4753,133 @@ function startLocalServer(opts) {
             const cliEpochStartedAt = cliSessionEpochPlan.resumeSessionId
                 ? (cliSessionEpochPlan.existing?.epoch_started_at || localTimestamp())
                 : localTimestamp();
-            const primaryTopicId = topicId || data.getPrimaryTopicIdForConversation(convId) || undefined;
-            const cliHistoryFilePath = activeIsCliProvider && !cliSessionEpochPlan.resumeSessionId
-                ? writeCliBootstrapHistoryFile({
-                    conversationId: convId,
-                    botId: profile.id,
-                    projectPath: llmSpawnCwd,
-                    topicId: primaryTopicId,
-                })
-                : null;
-            const directPrompt = buildLocalDesktopDirectPrompt({
+            const promptContextWindow = (0, context_window_1.getPromptContextWindow)(convId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS, {
+                targetBotId: profile.id,
+                targetBotName: profile.name,
+            });
+            const skipFreshCliBootstrap = shouldSkipFreshCliBootstrap({
+                providerName: activeProviderName,
+                resumeSessionId: cliSessionEpochPlan.resumeSessionId,
+                promptContextMode: promptContextWindow.mode,
+            });
+            // Session lifecycle logging — tracks invariant between prompt-building
+            // decisions and session runtime reality plus structured telemetry events.
+            if (enableCliSessionEpoch) {
+                const sessionLaunchReason = cliSessionEpochPlan.resumeSessionId
+                    ? 'resumed'
+                    : promptContextWindow.mode === 'new_topic'
+                        ? 'new_topic/no_context'
+                        : cliSessionEpochPlan.resetReason
+                            ? cliSessionEpochPlan.resetReason
+                            : 'fresh_with_bootstrap';
+                console.info(`[chat] session_launch_reason=${sessionLaunchReason} botId=${profile.id} provider=${activeProviderName} mode=${promptContextWindow.mode || 'unknown'} bootstrap=${!!promptContextWindow.allowBootstrap && !skipFreshCliBootstrap}`);
+                console.info(`[chat] cli_session_selected conversationId=${convId} botId=${profile.id} provider=${activeProviderName} selectedSessionId=${cliSessionEpochPlan.resumeSessionId || '(none)'} resetReason=${cliSessionEpochPlan.resetReason || '(none)'}`);
+                if (cliSessionEpochPlan.resumeSessionId) {
+                    console.info(`[chat] cli_session_resuming conversationId=${convId} botId=${profile.id} provider=${activeProviderName} sessionId=${cliSessionEpochPlan.resumeSessionId}`);
+                }
+                else if (promptContextWindow.mode === 'new_topic') {
+                    console.info(`[chat] cli_session_fresh_without_bootstrap_new_topic conversationId=${convId} botId=${profile.id} provider=${activeProviderName}`);
+                }
+                else if (promptContextWindow.allowBootstrap && !skipFreshCliBootstrap) {
+                    console.info(`[chat] cli_session_fresh_bootstrap_applied conversationId=${convId} botId=${profile.id} provider=${activeProviderName}`);
+                }
+                else {
+                    console.warn(`[chat] cli_session_fresh_without_bootstrap_unexpected conversationId=${convId} botId=${profile.id} provider=${activeProviderName} mode=${promptContextWindow.mode || 'unknown'}`);
+                }
+            }
+            const promptContext = resolveLocalDesktopPromptContext({
+                conversationId: convId,
+                conversation,
+                explicitTopicId: topicId,
+                fallbackCwd: opts.projectDir,
+                writeCliHistoryBootstrap: activeIsCliProvider
+                    && !cliSessionEpochPlan.resumeSessionId
+                    && !!promptContextWindow.allowBootstrap
+                    && !skipFreshCliBootstrap,
+            });
+            const llmSpawnCwd = promptContext.llmSpawnCwd;
+            let cliEpochResetReason = cliSessionEpochPlan.resetReason;
+            let directPrompt = buildLocalDesktopDirectPrompt({
                 conversationId: convId,
                 currentBotId: profile.id,
                 currentBotName: profile.name,
                 currentProvider: activeProviderName,
-                userPrompt: message,
+                userPrompt: supportsNativeImageInput(activeProviderName) ? message : runtimeUserPrompt,
                 soulMd: profile.soul_md || 'You are an AI assistant running locally. You have access to project files and can execute code.',
-                projectName: conversation?.project_name || undefined,
-                topicTitle: topicTitle || undefined,
-                workspacePath,
+                projectName: promptContext.projectName,
+                topicTitle: promptContext.topicTitle,
+                workspacePath: promptContext.workspacePath,
                 timezone: effectiveTimezone,
                 availableTools: toolDefs.map((tool) => ({ name: tool.name, description: tool.description })),
-                isCliRecurring: !!cliSessionEpochPlan.resumeSessionId,
-                cliHistoryFilePath,
+                isCliRecurring: !!cliSessionEpochPlan.resumeSessionId || skipFreshCliBootstrap,
+                cliHistoryFilePath: promptContext.cliHistoryFilePath,
+                crossBotTurn: promptContextWindow.lastCrossBotTurn,
+                forceInlinePromptContext: activeProviderName === 'codex-cli'
+                    && !!cliSessionEpochPlan.resumeSessionId
+                    && ((conversation?.turn_count || 0) === 0),
                 useCompletionSentinel: resolveDirectCliSessionTransport(activeProviderName, enableCliSessionEpoch, (0, storage_mode_1.isLocalStorageMode)()) === 'pty',
             });
-            const llmMessages = [{ role: 'user', content: directPrompt.userPrompt }];
+            // Recurring CLI sessions rely on session memory for same-bot context, so
+            // inject the last completed cross-bot handoff turn explicitly when the
+            // shared prompt-context policy says it is required.
+            if (activeIsCliProvider && !!cliSessionEpochPlan.resumeSessionId && promptContextWindow.lastCrossBotTurn) {
+                const crossBotBlock = (0, context_window_1.formatCrossBotPreviousTurn)(promptContextWindow.lastCrossBotTurn);
+                directPrompt.userPrompt = `${crossBotBlock}\n\n${directPrompt.userPrompt}`;
+            }
+            let llmMessages = [{
+                    role: 'user',
+                    content: supportsNativeImageInput(activeProviderName)
+                        ? buildMessageContentWithStoredAttachments(directPrompt.userPrompt, storedAttachmentsForTurn)
+                        : directPrompt.userPrompt,
+                }];
             let systemPrompt = directPrompt.systemPrompt;
+            let freshCliBootstrapFallbackApplied = false;
+            let freshCliBootstrapFileWritten = false;
+            const applyFreshCliBootstrapFallback = (reason) => {
+                if (freshCliBootstrapFallbackApplied)
+                    return;
+                freshCliBootstrapFallbackApplied = true;
+                cliEpochResetReason = reason;
+                const bootstrapHistoryFilePath = promptContextWindow.allowBootstrap
+                    ? (0, cli_bootstrap_history_1.writeConversationBootstrapHistoryFile)({
+                        conversationId: convId,
+                        topicId: promptContext.topicId,
+                    })
+                    : null;
+                freshCliBootstrapFileWritten = !!bootstrapHistoryFilePath;
+                directPrompt = buildLocalDesktopDirectPrompt({
+                    conversationId: convId,
+                    currentBotId: profile.id,
+                    currentBotName: profile.name,
+                    currentProvider: activeProviderName,
+                    userPrompt: supportsNativeImageInput(activeProviderName) ? message : runtimeUserPrompt,
+                    soulMd: profile.soul_md || 'You are an AI assistant running locally. You have access to project files and can execute code.',
+                    projectName: promptContext.projectName,
+                    topicTitle: promptContext.topicTitle,
+                    workspacePath: promptContext.workspacePath,
+                    timezone: effectiveTimezone,
+                    availableTools: toolDefs.map((tool) => ({ name: tool.name, description: tool.description })),
+                    isCliRecurring: false,
+                    cliHistoryFilePath: bootstrapHistoryFilePath,
+                    crossBotTurn: promptContextWindow.lastCrossBotTurn,
+                    useCompletionSentinel: resolveDirectCliSessionTransport(activeProviderName, enableCliSessionEpoch, (0, storage_mode_1.isLocalStorageMode)()) === 'pty',
+                });
+                llmMessages = [{
+                        role: 'user',
+                        content: supportsNativeImageInput(activeProviderName)
+                            ? buildMessageContentWithStoredAttachments(directPrompt.userPrompt, storedAttachmentsForTurn)
+                            : directPrompt.userPrompt,
+                    }];
+                systemPrompt = directPrompt.systemPrompt;
+                console.info(`[chat] session_launch_reason=resume_failed botId=${profile.id} provider=${activeProviderName} bootstrap=${!!bootstrapHistoryFilePath}`);
+                console.warn(`[chat] cli_session_resume_failed conversationId=${convId} botId=${profile.id} provider=${activeProviderName} bootstrap=${!!bootstrapHistoryFilePath}`);
+                if (bootstrapHistoryFilePath) {
+                    console.info(`[chat] cli_session_fresh_bootstrap_applied conversationId=${convId} botId=${profile.id} provider=${activeProviderName} bootstrapReason=resume_failed`);
+                }
+                else {
+                    console.warn(`[chat] cli_session_fresh_without_bootstrap_unexpected conversationId=${convId} botId=${profile.id} provider=${activeProviderName} bootstrapReason=resume_failed`);
+                }
+            };
             if (!activeApiKey) {
                 return res.status(400).json({ error: `No API key for provider ${profile.provider}. Configure one in Settings.` });
             }
@@ -3194,10 +4907,17 @@ function startLocalServer(opts) {
                         // CLI providers only see the last user message — prepend pinned context there
                         const lastUserIdx = llmMessages.map(m => m.role).lastIndexOf('user');
                         if (lastUserIdx >= 0) {
-                            llmMessages[lastUserIdx] = {
-                                ...llmMessages[lastUserIdx],
-                                content: `${pinnedBlock}\n---\n${llmMessages[lastUserIdx].content}`,
-                            };
+                            const existing = llmMessages[lastUserIdx].content;
+                            if (typeof existing === 'string') {
+                                llmMessages[lastUserIdx] = { ...llmMessages[lastUserIdx], content: `${pinnedBlock}\n---\n${existing}` };
+                            }
+                            else {
+                                // Multimodal content — prepend pinned text as a new text block, keep images intact
+                                llmMessages[lastUserIdx] = {
+                                    ...llmMessages[lastUserIdx],
+                                    content: [{ type: 'text', text: `${pinnedBlock}\n---\n` }, ...existing],
+                                };
+                            }
                         }
                     }
                     else {
@@ -3298,7 +5018,7 @@ function startLocalServer(opts) {
                 while (true) {
                     appServerAttempt++;
                     try {
-                        const isFreshSession = forceFreshInteractiveCliSession || !cliSessionEpochPlan.resumeSessionId;
+                        const isFreshSession = forceFreshInteractiveCliSession || (!codexAppServerManager.hasActiveSession(convId, profile.id) && !cliSessionEpochPlan.resumeSessionId);
                         const result = await codexAppServerManager.runTurn({
                             runtimeMode: 'local_desktop',
                             conversationId: convId,
@@ -3308,7 +5028,7 @@ function startLocalServer(opts) {
                             systemPrompt,
                             messages: llmMessages,
                             forceFreshSession: isFreshSession,
-                            resumeSessionId: cliSessionEpochPlan.resumeSessionId || undefined,
+                            resumeSessionId: isFreshSession ? undefined : (cliSessionEpochPlan.resumeSessionId || undefined),
                             model: activeModelName || profile.model || null,
                             projectId: conversation?.project_id ?? null,
                             codexSettings: {
@@ -3326,6 +5046,12 @@ function startLocalServer(opts) {
                                 persistAssistantPartial(false);
                                 sendEvent('chunk', { text: chunk });
                             },
+                            onCommentary: async (commentary) => {
+                                const text = String(commentary || '').trim();
+                                if (!text)
+                                    return;
+                                sendEvent('status', { phase: 'commentary', detail: text });
+                            },
                             onDetail: async (detail) => {
                                 const text = String(detail || '').trim();
                                 if (!text)
@@ -3333,6 +5059,35 @@ function startLocalServer(opts) {
                                 sendEvent('status', { phase: 'thinking', detail: text });
                                 recordActivity('status', { phase: 'thinking', detail: text }, text);
                             },
+                            onToolEvent: async (toolEvent) => {
+                                if (toolEvent.kind === 'call') {
+                                    sendEvent('tool_call', {
+                                        name: toolEvent.toolName,
+                                        callId: toolEvent.toolCallId,
+                                        arguments: toolEvent.arguments || null,
+                                    });
+                                    recordActivity('tool_call', {
+                                        name: toolEvent.toolName,
+                                        callId: toolEvent.toolCallId,
+                                        arguments: toolEvent.arguments || null,
+                                    }, `Running ${toolEvent.toolName}`);
+                                    return;
+                                }
+                                sendEvent('tool_result', {
+                                    name: toolEvent.toolName,
+                                    callId: toolEvent.toolCallId,
+                                    output: toolEvent.output || '',
+                                    isError: !!toolEvent.isError,
+                                });
+                                recordActivity('tool_result', {
+                                    callId: toolEvent.toolCallId,
+                                    toolName: toolEvent.toolName,
+                                    output: toolEvent.output || '',
+                                    isError: !!toolEvent.isError,
+                                }, toolEvent.isError
+                                    ? `${toolEvent.toolName} returned an error`
+                                    : `${toolEvent.toolName} completed`);
+                            },
                         });
                         if (result.sessionId) {
                             activeCliSessionId = result.sessionId;
@@ -3342,10 +5097,40 @@ function startLocalServer(opts) {
                             totalOutputTokens += result.usage.outputTokens || 0;
                             hasExactUsage = true;
                         }
+                        // ─── token.txt: agent-side usage log (Codex App Server path) ─
+                        // Fire-and-forget. Never blocks the chat reply.
+                        try {
+                            const __auth = await getHydratedDesktopAuth().catch(() => null);
+                            if (__auth?.token && result.usage) {
+                                void (0, usage_log_1.writeAgentUsageLog)({
+                                    apiToken: __auth.token,
+                                    testRunId: __testRunId,
+                                    mode: 'local-db-codex-app',
+                                    conversationId: convId,
+                                    botId: profile?.id || null,
+                                    botName: profile?.name || null,
+                                    turnIndex: __turnIndexParsed,
+                                    provider: 'openai',
+                                    model: profile?.model || 'unknown',
+                                    inputTokensFresh: result.usage.inputTokensFresh ?? 0,
+                                    inputTokensCacheCreation: result.usage.inputTokensCacheCreation ?? 0,
+                                    inputTokensCacheRead: result.usage.inputTokensCacheRead ?? 0,
+                                    outputTokens: result.usage.outputTokens ?? 0,
+                                    userPromptText: __benchUserMessage,
+                                    systemPromptText: systemPrompt,
+                                    responseText: result.content || null,
+                                });
+                            }
+                        }
+                        catch { /* best effort; never break chat */ }
+                        // ─── end usage log ──────────────────────────────────────────
                         rawCliTranscript = result.rawOutput || '';
                         fullContent = (0, completion_marker_1.stripCompletionSentinel)((result.content || '').trim()).text.trim();
                         if (!fullContent && appServerAttempt < LOCAL_RUNTIME_RETRY_LIMIT) {
                             forceFreshInteractiveCliSession = true;
+                            if (cliSessionEpochPlan.resumeSessionId) {
+                                applyFreshCliBootstrapFallback('resume_failed');
+                            }
                             codexAppServerManager.closeSessionByConversation(convId, profile.id);
                             const retryDetail = `Selected runtime returned an empty response; retrying with a fresh ${activeProviderName} session (${appServerAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
                             console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
@@ -3358,10 +5143,14 @@ function startLocalServer(opts) {
                         if (routeAbortController.signal.aborted || codexErr?.name === 'AbortError') {
                             throw codexErr;
                         }
+                        clearFailedLocalCliSessionEpoch(convId, profile.id, activeCliSessionId || cliSessionEpochPlan.resumeSessionId);
                         if (appServerAttempt >= LOCAL_RUNTIME_RETRY_LIMIT || !shouldRetrySelectedLocalRuntime(codexErr)) {
                             throw codexErr;
                         }
                         forceFreshInteractiveCliSession = true;
+                        if (cliSessionEpochPlan.resumeSessionId) {
+                            applyFreshCliBootstrapFallback('resume_failed');
+                        }
                         codexAppServerManager.closeSessionByConversation(convId, profile.id);
                         const retryDetail = `Selected runtime failed (${codexErr?.message || codexErr}); retrying with a fresh ${activeProviderName} session (${appServerAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
                         console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
@@ -3381,10 +5170,9 @@ function startLocalServer(opts) {
                 while (true) {
                     ptyAttempt++;
                     try {
-                        // Pattern A (Claude CLI): generate a sequential session ID for new sessions
-                        // Pattern B (Codex CLI): let the CLI generate its own ID
-                        const isFreshSession = forceFreshInteractiveCliSession || !cliSessionEpochPlan.resumeSessionId;
-                        const newSessionId = isFreshSession && activeProviderName === 'claude-cli'
+                        const hasLivePtySession = ptyManager.hasActiveSession(convId, profile.id);
+                        const isFreshSession = forceFreshInteractiveCliSession || (!hasLivePtySession && !cliSessionEpochPlan.resumeSessionId);
+                        const newSessionId = activeProviderName === 'claude-cli' && isFreshSession
                             ? data.generateNextSessionId()
                             : undefined;
                         currentAttemptWasFreshSession = isFreshSession;
@@ -3393,11 +5181,20 @@ function startLocalServer(opts) {
                             conversationId: convId,
                             botId: profile.id,
                             provider: 'claude-cli',
+                            botSettings: {
+                                claude: {
+                                    model: profile.model,
+                                    effortLevel: profile.claude_effort_level,
+                                    outputStyle: profile.claude_output_style,
+                                    fastMode: profile.claude_fast_mode === 1,
+                                    permissionsJson: profile.claude_permissions_json,
+                                },
+                            },
                             cwd: llmSpawnCwd,
                             systemPrompt,
                             messages: llmMessages,
                             forceFreshSession: isFreshSession,
-                            resumeSessionId: cliSessionEpochPlan.resumeSessionId || undefined,
+                            resumeSessionId: isFreshSession ? undefined : (cliSessionEpochPlan.resumeSessionId || undefined),
                             newSessionId,
                             abortSignal: routeAbortController.signal,
                             onRawChunk: async (chunk) => {
@@ -3430,10 +5227,40 @@ function startLocalServer(opts) {
                             totalOutputTokens += result.usage.outputTokens || 0;
                             hasExactUsage = true;
                         }
+                        // ─── token.txt: agent-side usage log (Claude PTY path) ──────
+                        // Fire-and-forget. Never blocks the chat reply.
+                        try {
+                            const __auth = await getHydratedDesktopAuth().catch(() => null);
+                            if (__auth?.token && result.usage) {
+                                void (0, usage_log_1.writeAgentUsageLog)({
+                                    apiToken: __auth.token,
+                                    testRunId: __testRunId,
+                                    mode: 'local-db-claude-pty',
+                                    conversationId: convId,
+                                    botId: profile?.id || null,
+                                    botName: profile?.name || null,
+                                    turnIndex: __turnIndexParsed,
+                                    provider: 'anthropic',
+                                    model: profile?.model || 'unknown',
+                                    inputTokensFresh: result.usage.inputTokensFresh ?? 0,
+                                    inputTokensCacheCreation: result.usage.inputTokensCacheCreation ?? 0,
+                                    inputTokensCacheRead: result.usage.inputTokensCacheRead ?? 0,
+                                    outputTokens: result.usage.outputTokens ?? 0,
+                                    userPromptText: __benchUserMessage,
+                                    systemPromptText: systemPrompt,
+                                    responseText: result.content || null,
+                                });
+                            }
+                        }
+                        catch { /* best effort; never break chat */ }
+                        // ─── end usage log ──────────────────────────────────────────
                         rawCliTranscript = result.rawOutput || '';
                         fullContent = (0, completion_marker_1.stripCompletionSentinel)((result.content || '').trim()).text.trim();
                         if (!fullContent && ptyAttempt < LOCAL_RUNTIME_RETRY_LIMIT) {
                             forceFreshInteractiveCliSession = true;
+                            if (cliSessionEpochPlan.resumeSessionId) {
+                                applyFreshCliBootstrapFallback('resume_failed');
+                            }
                             ptyManager.closeSessionByConversation(convId, profile.id);
                             const retryDetail = `Selected runtime returned an empty response; retrying with a fresh ${activeProviderName} session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
                             console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
@@ -3446,6 +5273,8 @@ function startLocalServer(opts) {
                         if (routeAbortController.signal.aborted || ptyErr?.name === 'AbortError') {
                             throw ptyErr;
                         }
+                        ptyManager.logSessionFailureByConversation(convId, profile.id, 'chat_runtime_failure_before_kill', ptyErr);
+                        clearFailedLocalCliSessionEpoch(convId, profile.id, currentAttemptSessionId || activeCliSessionId || cliSessionEpochPlan.resumeSessionId);
                         if (ptyAttempt >= LOCAL_RUNTIME_RETRY_LIMIT || !shouldRetrySelectedLocalRuntime(ptyErr)) {
                             throw ptyErr;
                         }
@@ -3454,11 +5283,19 @@ function startLocalServer(opts) {
                             forceFreshInteractiveCliSession = true;
                             ptyManager.closeSessionByConversation(convId, profile.id);
                         }
+                        const resumeFailureFallback = !!cliSessionEpochPlan.resumeSessionId && !currentAttemptWasFreshSession;
+                        if (resumeFailureFallback) {
+                            forceFreshInteractiveCliSession = true;
+                            applyFreshCliBootstrapFallback('resume_failed');
+                            ptyManager.closeSessionByConversation(convId, profile.id);
+                        }
                         const retryDetail = startupRetry
-                            ? `Fresh ${activeProviderName} session ${currentAttemptSessionId || '(unknown)'} did not create a transcript within 7s; killing it and retrying with a new session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`
-                            : currentAttemptWasFreshSession && activeProviderName === 'claude-cli'
-                                ? `Fresh ${activeProviderName} session ${currentAttemptSessionId || '(unknown)'} failed (${ptyErr?.message || ptyErr}); killing it and retrying with a new session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`
-                                : `Selected runtime failed (${ptyErr?.message || ptyErr}); retrying the same connection (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
+                            ? `Fresh ${activeProviderName} session ${currentAttemptSessionId || '(unknown)'} did not finish startup before the transcript became available; killing it and retrying with a new session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`
+                            : resumeFailureFallback
+                                ? `Stored ${activeProviderName} session ${currentAttemptSessionId || '(unknown)'} failed to resume (${ptyErr?.message || ptyErr}); retrying with a fresh bootstrapped session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`
+                                : currentAttemptWasFreshSession && activeProviderName === 'claude-cli'
+                                    ? `Fresh ${activeProviderName} session ${currentAttemptSessionId || '(unknown)'} failed (${ptyErr?.message || ptyErr}); killing it and retrying with a new session (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`
+                                    : `Selected runtime failed (${ptyErr?.message || ptyErr}); retrying the same connection (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
                         console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
                         await pauseLocalRuntimeRetry(ptyAttempt);
                     }
@@ -3634,6 +5471,17 @@ function startLocalServer(opts) {
             }
             persistAssistantPartial(true);
             if (enableCliSessionEpoch && activeCliSessionId) {
+                if (cliSessionEpochPlan.resumeSessionId && !freshCliBootstrapFallbackApplied) {
+                    console.info(`[chat] cli_session_resume_succeeded conversationId=${convId} botId=${profile.id} provider=${activeProviderName} sessionId=${activeCliSessionId}`);
+                }
+                const usedBootstrap = freshCliBootstrapFileWritten
+                    || (!cliSessionEpochPlan.resumeSessionId && !!promptContextWindow.allowBootstrap && !skipFreshCliBootstrap);
+                const bootstrapReason = freshCliBootstrapFileWritten
+                    ? 'resume_failed'
+                    : (!cliSessionEpochPlan.resumeSessionId && !!promptContextWindow.allowBootstrap && !skipFreshCliBootstrap)
+                        ? 'fresh_with_context'
+                        : null;
+                console.info(`[chat] cli_turn_telemetry conversationId=${convId} botId=${profile.id} provider=${activeProviderName} selectedSessionId=${cliSessionEpochPlan.resumeSessionId || '(none)'} actualSessionId=${activeCliSessionId} promptContextMode=${promptContextWindow.mode || 'unknown'} usedBootstrap=${usedBootstrap} bootstrapReason=${bootstrapReason || '(none)'} resetReason=${cliEpochResetReason || '(none)'}`);
                 const nextEpochTurnCount = cliSessionEpochPlan.resumeSessionId
                     ? ((cliSessionEpochPlan.existing?.epoch_turn_count || 0) + 1)
                     : 1;
@@ -3645,7 +5493,7 @@ function startLocalServer(opts) {
                     epochTurnCount: nextEpochTurnCount,
                     lastInputTokens: hasExactUsage ? totalInputTokens : approxInputTokens,
                     lastOutputTokens: hasExactUsage ? totalOutputTokens : 0,
-                    resetReason: cliSessionEpochPlan.resetReason,
+                    resetReason: cliEpochResetReason,
                     epochStartedAt: cliEpochStartedAt,
                     lastUsedAt: localTimestamp(),
                 });
@@ -3679,6 +5527,12 @@ function startLocalServer(opts) {
                     resultArtifact: useInteractiveCliSession ? (rawCliTranscript || null) : undefined,
                 }) || data.addMessage(convId, 'assistant', persistedContent, modelWithRuntime || undefined, undefined, profile.id, profile.name))
                 : data.addMessage(convId, 'assistant', persistedContent, modelWithRuntime || undefined, undefined, profile.id, profile.name);
+            emitConversationSyncEvents(convId, [
+                {
+                    change: savedMessage.id === assistantMessageId ? 'message.updated' : 'message.created',
+                    messageId: savedMessage.id,
+                },
+            ]);
             data.attachMessageActivitiesToMessage(activityStreamId, savedMessage.id);
             data.createMessageActivity({
                 conversationId: convId,
@@ -3716,6 +5570,9 @@ function startLocalServer(opts) {
                     // For CLI providers, set a simple title without burning a CLI call
                     const shortTitle = message.slice(0, 60).replace(/\n/g, ' ').trim();
                     data.updateConversation(convId, { title: shortTitle || 'New Chat' });
+                    emitConversationSyncEvents(convId, [
+                        { change: 'conversation.updated' },
+                    ]);
                 }
                 else {
                     autoTitleConversation(convId, message, persistedContent, activeProviderName, activeModelName, activeApiKey);
@@ -3730,8 +5587,17 @@ function startLocalServer(opts) {
             (0, local_funnel_1.scheduleFunnelProcessing)(convId);
         }
         catch (err) {
+            // Log the FULL stack to agent.log. Previously only err.message
+            // made it into DB / console; for crashes like "Maximum call
+            // stack size exceeded" we lost the one useful diagnostic (the
+            // recursion site). Chalk-colored message + serialized stack.
+            // (2026-04-19.)
             console.error(chalk_1.default.red(`Chat error: ${err.message}`));
+            if (err?.stack) {
+                console.error(String(err.stack));
+            }
             try {
+                const userMessage = buildLocalRuntimeUserFacingError(err);
                 if (activityErrorContext.conversationId) {
                     data.createMessageActivity({
                         conversationId: activityErrorContext.conversationId,
@@ -3743,6 +5609,8 @@ function startLocalServer(opts) {
                         summary: err.message,
                         payload: {
                             error: err.message,
+                            userMessage,
+                            stack: err?.stack || null,
                             authRequired: err?.authRequired === true,
                             providerId: err?.providerId || null,
                             cli: err?.cli || null,
@@ -3755,12 +5623,13 @@ function startLocalServer(opts) {
                 // best effort only
             }
             if (!res.headersSent) {
-                res.status(500).json({ error: err.message });
+                res.status(500).json({ error: err.message, userMessage: buildLocalRuntimeUserFacingError(err) });
             }
             else {
                 try {
                     res.write(`event: error\ndata: ${JSON.stringify({
                         error: err.message,
+                        userMessage: buildLocalRuntimeUserFacingError(err),
                         authRequired: err?.authRequired === true,
                         providerId: err?.providerId || null,
                         cli: err?.cli || null,
@@ -3848,6 +5717,650 @@ function startLocalServer(opts) {
             res.status(500).json({ error: err.message });
         }
     });
+    // Phase B: tool-dispatch is always on for local_desktop; keep GET for
+    // introspection so any external tooling knows the state. POST is a
+    // no-op that returns the current (permanent) state.
+    app.get('/api/orchestration/tool-dispatch', (_req, res) => {
+        res.json({ enabled: true, permanent: true, phase: 'B' });
+    });
+    app.post('/api/orchestration/tool-dispatch', (_req, res) => {
+        res.json({ enabled: true, permanent: true, phase: 'B' });
+    });
+    function buildPlanImportChatMessage(params) {
+        const lines = [];
+        lines.push(`**Plan Imported: ${params.sourceFileName}**`);
+        lines.push('');
+        lines.push(`**Plan File:** ${params.sourceFileName}`);
+        const plannerLabel = params.planner.agentName || 'Planner';
+        lines.push(`**Planner:** ${plannerLabel}${params.planner.model ? ` (${params.planner.model})` : ''}`);
+        const stageLines = params.stages.map((stage, i) => {
+            const bot = data.getAgentProfile(stage.botId);
+            return `#${i + 1} ${stage.role} → ${bot?.name || stage.botId}`;
+        });
+        lines.push(`**Task Flow:** ${stageLines.join(', ')}`);
+        if (params.plannerInstructions?.trim()) {
+            lines.push(`**Planner Instructions:** ${params.plannerInstructions.trim()}`);
+        }
+        const orderLabel = params.executionOrder === 'batch_by_stage'
+            ? 'batch_by_stage (all coding first, then QA)'
+            : 'per_item_pipeline (Code → QA per item)';
+        lines.push(`**Execution Order:** ${orderLabel}`);
+        lines.push(`**Status:** ${params.status}`);
+        lines.push('');
+        lines.push(`**Created ${params.taskCount} TODOs:**`);
+        lines.push('');
+        for (let i = 0; i < params.tasks.length; i++) {
+            const task = params.tasks[i];
+            const role = task.task_type || 'Task';
+            const owner = task.owner_name || 'Unassigned';
+            lines.push(`${i + 1}. [${role}] ${owner}: ${task.title}`);
+        }
+        lines.push('');
+        lines.push('Review the stored tasks, delete any you do not want, then start the plan.');
+        return lines.join('\n');
+    }
+    function buildPlanStartChatMessage(params) {
+        const lines = [];
+        const action = params.isResume ? 'Resumed' : 'Started';
+        lines.push(`**Plan ${action}: ${params.sourceFileName}**`);
+        lines.push('');
+        if (params.firstTask) {
+            const role = params.firstTask.task_type || 'Task';
+            const owner = params.firstTask.owner_name || 'Unassigned';
+            lines.push(`**Next TODO:** #${params.firstTask.id} "${params.firstTask.title}" (${owner}, ${role})`);
+        }
+        lines.push(`**Active TODOs remaining:** ${params.remainingCount} of ${params.totalCount}`);
+        if (params.executionOrder) {
+            const orderLabel = params.executionOrder === 'batch_by_stage'
+                ? 'batch_by_stage (all coding first, then QA)'
+                : 'per_item_pipeline (Code → QA per item)';
+            lines.push(`**Execution Order:** ${orderLabel}`);
+        }
+        lines.push(`**Status:** ${params.status}`);
+        return lines.join('\n');
+    }
+    function buildPlanFailureChatMessage(params) {
+        const lines = [];
+        lines.push(`**Plan Resume Failed: ${params.sourceFileName}**`);
+        lines.push('');
+        lines.push(`**Error:** ${params.error}`);
+        lines.push(`**Status:** ${params.status}`);
+        lines.push('');
+        lines.push('The plan has been paused. Check the error and retry.');
+        return lines.join('\n');
+    }
+    const activeImportedPlanRunners = new Map();
+    const buildImportedPlanSessionScopeKey = (runId, conversationId) => `${conversationId}::plan::${runId}`;
+    const resolveImportedPlanWorkerBotIds = (run) => {
+        const tasks = data.getImportedPlanRunTasks(run.id);
+        const ids = new Set();
+        for (const stage of run.requested_stages || []) {
+            if (stage.botId)
+                ids.add(stage.botId);
+        }
+        for (const task of tasks) {
+            if (task.owner_bot_id) {
+                ids.add(task.owner_bot_id);
+                continue;
+            }
+            const ownerName = String(task.owner_name || '').trim().toLowerCase();
+            if (!ownerName)
+                continue;
+            const match = data.listAgentProfiles().find((agent) => agent.name.trim().toLowerCase() === ownerName);
+            if (match?.id)
+                ids.add(match.id);
+        }
+        return Array.from(ids);
+    };
+    const teardownImportedPlanRunnerSessions = (run, sessionScopeKey) => {
+        if (!run)
+            return;
+        const scopeKey = String(sessionScopeKey || '').trim() || buildImportedPlanSessionScopeKey(run.id, run.conversation_id);
+        const workerBotIds = resolveImportedPlanWorkerBotIds(run);
+        const ptyManager = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)();
+        const codexAppServerManager = (0, codex_app_server_manager_1.getCodexAppServerManager)();
+        for (const botId of workerBotIds) {
+            ptyManager.closeSessionByConversation(scopeKey, botId);
+            codexAppServerManager.closeSessionByConversation(scopeKey, botId);
+            data.deleteCliSessionEpoch(run.conversation_id, botId, scopeKey);
+        }
+    };
+    const importedPlanPauseSummary = (action) => {
+        if (action === 'cancel')
+            return 'Plan cancelled. Resume will continue from the current active TODO.';
+        if (action === 'stop')
+            return 'Plan stopped. Resume will continue from the current active TODO.';
+        return 'Plan paused. Resume will continue from the current active TODO.';
+    };
+    const normalizeImportedPlanRunForUi = (run) => {
+        if (!run)
+            return undefined;
+        if (run.status === 'running' && !activeImportedPlanRunners.has(run.id) && data.getImportedPlanRunRemainingTaskIds(run.id).length > 0) {
+            return data.updateImportedPlanRun(run.id, {
+                status: 'paused',
+                lastError: run.last_error || 'Agent restarted or lost the in-memory Plan-TODO runner. Resume will continue from the next active TODO.',
+            }) || run;
+        }
+        return run;
+    };
+    const serializeImportedPlanRun = (run) => {
+        run = normalizeImportedPlanRunForUi(run);
+        if (!run)
+            return null;
+        const tasks = data.getImportedPlanRunTasks(run.id);
+        const remainingTaskIds = data.getImportedPlanRunRemainingTaskIds(run.id);
+        const currentTask = data.getImportedPlanRunCurrentTask(run.id) || null;
+        return {
+            id: run.id,
+            conversationId: run.conversation_id,
+            projectId: run.project_id,
+            sourceFilePath: run.source_file_path,
+            sourceFileName: run.source_file_name,
+            planner: {
+                botId: run.planner_bot_id,
+                agentName: run.planner_agent_name,
+                provider: run.planner_provider,
+                model: run.planner_model,
+            },
+            stages: run.requested_stages,
+            options: run.requested_options,
+            taskIds: run.task_ids,
+            remainingTaskIds,
+            taskCount: tasks.length,
+            completedTaskCount: tasks.filter((task) => task.state === 'completed').length,
+            remainingTaskCount: remainingTaskIds.length,
+            currentTask,
+            status: run.status,
+            createdAt: run.created_at,
+            updatedAt: run.updated_at,
+            startedAt: run.started_at,
+            completedAt: run.completed_at,
+            discardedAt: run.discarded_at,
+            lastError: run.last_error,
+            tasks,
+        };
+    };
+    app.get('/api/orchestration/import-plan/current', (req, res) => {
+        try {
+            const conversationId = String(req.query.conversationId || '').trim();
+            if (!conversationId)
+                return res.status(400).json({ error: 'conversationId is required' });
+            const run = normalizeImportedPlanRunForUi(data.getLatestImportedPlanRunForConversation(conversationId));
+            res.json({ ok: true, run: serializeImportedPlanRun(run) });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/orchestration/import-plan/control', (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.status(501).json({ error: 'Imported plan control is only implemented for local desktop storage right now.' });
+            }
+            const runId = String(req.body?.runId || '').trim();
+            const action = String(req.body?.action || '').trim().toLowerCase();
+            if (!runId)
+                return res.status(400).json({ error: 'runId is required' });
+            if (action !== 'pause' && action !== 'stop' && action !== 'cancel') {
+                return res.status(400).json({ error: 'action must be pause, stop, or cancel' });
+            }
+            const run = normalizeImportedPlanRunForUi(data.getImportedPlanRun(runId));
+            if (!run)
+                return res.status(404).json({ error: 'Imported plan run not found.' });
+            if (run.status === 'completed' || run.status === 'discarded') {
+                return res.status(400).json({ error: `Imported plan is already ${run.status}.` });
+            }
+            const runner = activeImportedPlanRunners.get(run.id);
+            const summary = importedPlanPauseSummary(action);
+            const updatedRun = data.updateImportedPlanRun(run.id, {
+                status: 'paused',
+                completedAt: null,
+                lastError: summary,
+            }) || run;
+            if (runner) {
+                runner.stopRequested = true;
+                runner.stopAction = action;
+                runner.abortController.abort();
+            }
+            else {
+                teardownImportedPlanRunnerSessions(updatedRun);
+            }
+            res.json({
+                ok: true,
+                action,
+                summary,
+                run: serializeImportedPlanRun(updatedRun),
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/orchestration/import-plan', async (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.status(501).json({ error: 'Plan import is only implemented for local desktop storage right now.' });
+            }
+            const { conversationId, topicId, projectId, filePath, importMode, stages, plannerBotId, plannerInstructions, executionOrder, } = req.body || {};
+            const normalizedFilePath = String(filePath || '').trim();
+            if (!normalizedFilePath)
+                return res.status(400).json({ error: 'filePath is required' });
+            if (String(importMode || '') !== 'custom_pipeline') {
+                return res.status(400).json({ error: 'importMode must be custom_pipeline' });
+            }
+            const normalizedPlannerBotId = String(plannerBotId || '').trim();
+            if (!normalizedPlannerBotId)
+                return res.status(400).json({ error: 'plannerBotId is required' });
+            const normalizedStages = Array.isArray(stages)
+                ? stages.map((stage) => ({
+                    role: String(stage?.role || '').trim(),
+                    botId: String(stage?.botId || '').trim(),
+                })).filter((stage) => stage.role && stage.botId)
+                : [];
+            if (normalizedStages.length === 0) {
+                return res.status(400).json({ error: 'Choose at least one stage and bot before importing a plan.' });
+            }
+            const normalizedExecutionOrder = String(executionOrder || '').trim();
+            if (normalizedExecutionOrder
+                && normalizedExecutionOrder !== 'per_item_pipeline'
+                && normalizedExecutionOrder !== 'batch_by_stage') {
+                return res.status(400).json({ error: 'executionOrder must be per_item_pipeline or batch_by_stage.' });
+            }
+            const resolvedFilePath = path.resolve(normalizedFilePath);
+            if (!fs.existsSync(resolvedFilePath)) {
+                return res.status(404).json({ error: `File not found: ${resolvedFilePath}` });
+            }
+            const stat = fs.statSync(resolvedFilePath);
+            if (!stat.isFile()) {
+                return res.status(400).json({ error: 'Selected plan path is not a file.' });
+            }
+            if (stat.size > MAX_PLAN_IMPORT_BYTES) {
+                return res.status(400).json({ error: `Selected plan file is too large (${stat.size} bytes). Keep it under ${MAX_PLAN_IMPORT_BYTES} bytes.` });
+            }
+            const rawFileContent = fs.readFileSync(resolvedFilePath, 'utf8');
+            if (!rawFileContent.trim()) {
+                return res.status(400).json({ error: 'Selected plan file is empty.' });
+            }
+            const topic = topicId ? data.getTopic(String(topicId)) : undefined;
+            let effectiveProjectId = projectId ? String(projectId) : (topic?.project_id || null);
+            let convId = conversationId ? String(conversationId) : '';
+            const existingConversation = convId ? data.getConversation(convId) : undefined;
+            if (!effectiveProjectId) {
+                effectiveProjectId = existingConversation?.project_id || null;
+            }
+            if (!effectiveProjectId) {
+                return res.status(400).json({ error: 'Select a project before importing a plan.' });
+            }
+            if (!convId) {
+                const project = data.getProject(effectiveProjectId);
+                const projectBots = (project?.bot_ids || [])
+                    .map((botId) => data.getAgentProfile(botId))
+                    .filter((bot) => !!bot && bot.is_active === 1);
+                const seedBot = projectBots[0] || data.getDefaultAgentProfile() || data.listAgentProfiles().find((bot) => bot.is_active === 1);
+                if (!seedBot)
+                    return res.status(400).json({ error: 'No active bot is available to seed the plan-import conversation.' });
+                const conv = data.createConversation(seedBot.id, `Plan Import: ${path.basename(resolvedFilePath)}`, 'local', {
+                    projectId: effectiveProjectId,
+                    projectName: project?.name || null,
+                    botIds: projectBots.length > 0 ? projectBots.map((bot) => bot.id) : [seedBot.id],
+                    initialBotId: seedBot.id,
+                });
+                convId = conv.id;
+            }
+            if (topicId) {
+                try {
+                    data.upsertConversationTopicSegment(convId, String(topicId));
+                }
+                catch { /* best effort */ }
+            }
+            const existingRun = normalizeImportedPlanRunForUi(data.getLatestImportedPlanRunForConversation(convId));
+            if (existingRun && (existingRun.status === 'paused' || existingRun.status === 'running')) {
+                return res.status(409).json({
+                    error: 'This conversation already has an imported plan waiting for review or execution.',
+                    run: serializeImportedPlanRun(existingRun),
+                });
+            }
+            const { OrchestratorAgent, buildLocalDesktopOrchestratorRuntime } = require('./orchestrator');
+            const workflowEngine = (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
+            const explicitOrchestratorBot = data.isClerkOrchestratorEnabled()
+                ? null
+                : (data.getOrchestratorBot() || null);
+            let orchestratorRuntime;
+            try {
+                orchestratorRuntime = buildLocalDesktopOrchestratorRuntime(explicitOrchestratorBot);
+            }
+            catch (runtimeErr) {
+                return res.status(400).json({
+                    error: runtimeErr?.message || 'Plan import needs an orchestrator or clerk runtime configured.',
+                });
+            }
+            const orchestrator = new OrchestratorAgent(orchestratorRuntime, workflowEngine);
+            const normalizedPlannerInstructions = typeof plannerInstructions === 'string' ? plannerInstructions.trim() : null;
+            const result = await orchestrator.importPlanAsTodos({
+                conversationId: convId,
+                projectId: effectiveProjectId,
+                filePath: resolvedFilePath,
+                fileContent: rawFileContent,
+                mode: importMode,
+                stages: normalizedStages,
+                plannerInstructions: normalizedPlannerInstructions || null,
+                executionOrder: normalizedExecutionOrder === 'batch_by_stage' || normalizedExecutionOrder === 'per_item_pipeline'
+                    ? normalizedExecutionOrder
+                    : null,
+                plannerBotId: normalizedPlannerBotId,
+                orchestratorBot: explicitOrchestratorBot,
+                autoDispatchTodos: false,
+                opts: {
+                    ...opts,
+                    projectId: effectiveProjectId,
+                    onProgress: () => { },
+                    mqttPublish: async () => { },
+                    commandId: `plan-import-${Date.now()}`,
+                    autoDispatchTodos: false,
+                },
+            });
+            const importedPlanRunForMsg = data.getImportedPlanRun(result.planRunId);
+            const importedTasks = importedPlanRunForMsg ? data.getImportedPlanRunTasks(result.planRunId) : [];
+            const richImportMessage = buildPlanImportChatMessage({
+                sourceFileName: path.basename(resolvedFilePath),
+                planner: result.planner,
+                stages: normalizedStages,
+                plannerInstructions: normalizedPlannerInstructions,
+                executionOrder: importedPlanRunForMsg?.requested_options?.executionOrder || null,
+                taskCount: result.taskIds.length,
+                tasks: importedTasks.map((t) => ({
+                    id: t.id,
+                    owner_name: t.owner_name,
+                    task_type: t.task_type,
+                    title: t.title,
+                    state: t.state,
+                })),
+                status: importedPlanRunForMsg?.status || 'paused',
+            });
+            const assistant = data.addMessage(convId, 'assistant', richImportMessage, result.planner.model || 'Orchestrator', undefined, undefined, 'Orchestrator');
+            res.json({
+                ok: true,
+                conversationId: convId,
+                projectId: effectiveProjectId,
+                messageId: assistant.id,
+                planRun: serializeImportedPlanRun(importedPlanRunForMsg),
+                planRunId: result.planRunId,
+                importMode,
+                planner: result.planner,
+                taskCount: result.taskIds.length,
+                taskIds: result.taskIds,
+                ownerNames: result.ownerNames,
+                summary: richImportMessage,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/orchestration/import-plan/start', async (req, res) => {
+        try {
+            if (isConnectedMode()) {
+                return res.status(501).json({ error: 'Imported plan execution is only implemented for local desktop storage right now.' });
+            }
+            const runId = String(req.body?.runId || '').trim();
+            if (!runId)
+                return res.status(400).json({ error: 'runId is required' });
+            const run = normalizeImportedPlanRunForUi(data.getImportedPlanRun(runId));
+            if (!run)
+                return res.status(404).json({ error: 'Imported plan run not found.' });
+            if (run.status === 'discarded')
+                return res.status(400).json({ error: 'This imported plan was discarded.' });
+            if (activeImportedPlanRunners.has(run.id)) {
+                return res.json({ ok: true, started: false, run: serializeImportedPlanRun(run), summary: 'Imported plan is already running.' });
+            }
+            const project = run.project_id ? data.getProject(run.project_id) : undefined;
+            const { OrchestratorAgent, buildLocalDesktopOrchestratorRuntime } = require('./orchestrator');
+            const workflowEngine = (0, workflow_engine_1.getWorkflowEngine)(project?.folder || opts.projectDir, 'local_desktop');
+            const explicitOrchestratorBot = data.isClerkOrchestratorEnabled()
+                ? null
+                : (data.getOrchestratorBot() || null);
+            let orchestratorRuntime;
+            try {
+                orchestratorRuntime = buildLocalDesktopOrchestratorRuntime(explicitOrchestratorBot);
+            }
+            catch (runtimeErr) {
+                return res.status(400).json({
+                    error: runtimeErr?.message || 'Imported plan execution needs an orchestrator or clerk runtime configured.',
+                });
+            }
+            const orchestrator = new OrchestratorAgent(orchestratorRuntime, workflowEngine);
+            const startAllTasks = data.getImportedPlanRunTasks(run.id);
+            const startRemainingIds = data.getImportedPlanRunRemainingTaskIds(run.id);
+            const startFirstTask = startRemainingIds.length > 0
+                ? data.getTodoTask(startRemainingIds[0], 'active')
+                : null;
+            const isResumingPlan = !!run.started_at;
+            const startedSummary = buildPlanStartChatMessage({
+                sourceFileName: run.source_file_name,
+                isResume: isResumingPlan,
+                remainingCount: startRemainingIds.length,
+                totalCount: startAllTasks.length,
+                firstTask: startFirstTask ? {
+                    id: startFirstTask.id,
+                    title: startFirstTask.title,
+                    owner_name: startFirstTask.owner_name,
+                    task_type: startFirstTask.task_type,
+                } : null,
+                executionOrder: run.requested_options?.executionOrder || null,
+                status: 'running',
+            });
+            const assistant = data.addMessage(run.conversation_id, 'assistant', startedSummary, orchestratorRuntime.model || 'Orchestrator', undefined, undefined, 'Orchestrator');
+            const activityStreamId = `activity-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const activityExpiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000)
+                .toISOString()
+                .replace('T', ' ')
+                .replace('Z', '');
+            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 recordActivity = (activityType, payload, summary) => {
+                try {
+                    data.createMessageActivity({
+                        conversationId: run.conversation_id,
+                        messageId: String(assistant.id),
+                        streamId: activityStreamId,
+                        botId: null,
+                        agentName: 'Orchestrator',
+                        activityType,
+                        summary: summary || null,
+                        payload,
+                        expiresAt: activityExpiresAt,
+                    });
+                }
+                catch {
+                    // Best effort only
+                }
+            };
+            const recordWorkerActivity = (activityType, event, payload, summary) => {
+                try {
+                    data.createMessageActivity({
+                        conversationId: run.conversation_id,
+                        messageId: String(assistant.id),
+                        streamId: activityStreamId,
+                        botId: resolveWorkerBotId(event.agentName) || null,
+                        agentName: event.agentName || null,
+                        activityType,
+                        summary: summary || null,
+                        payload,
+                        expiresAt: activityExpiresAt,
+                    });
+                }
+                catch {
+                    // Best effort only
+                }
+            };
+            recordActivity('status', { phase: 'starting', detail: startedSummary }, startedSummary);
+            const activeRunner = {
+                runId: run.id,
+                conversationId: run.conversation_id,
+                sessionScopeKey: buildImportedPlanSessionScopeKey(run.id, run.conversation_id),
+                abortController: new AbortController(),
+                stopRequested: false,
+                stopAction: null,
+            };
+            activeImportedPlanRunners.set(run.id, activeRunner);
+            void (async () => {
+                try {
+                    let lastProgressActivity = '';
+                    let lastInterimMessage = '';
+                    const started = await orchestrator.startImportedPlanRun({
+                        runId: run.id,
+                        orchestratorBot: explicitOrchestratorBot,
+                        opts: {
+                            ...opts,
+                            projectId: run.project_id || undefined,
+                            projectDir: project?.folder || opts.projectDir,
+                            abortSignal: activeRunner.abortController.signal,
+                            importedPlanRunId: run.id,
+                            cliSessionScopeKey: activeRunner.sessionScopeKey,
+                            onProgress: (status) => {
+                                const progressUpdate = classifyOrchestratorProgress(status);
+                                if (progressUpdate.activityText && progressUpdate.activityText !== lastProgressActivity) {
+                                    lastProgressActivity = progressUpdate.activityText;
+                                    recordActivity('status', { phase: 'running', detail: progressUpdate.activityText }, progressUpdate.activityText);
+                                }
+                                const interimMessage = deriveVisibleOrchestratorMessage(status);
+                                if (interimMessage && interimMessage !== lastInterimMessage) {
+                                    lastInterimMessage = interimMessage;
+                                    recordActivity('orchestrator_interim', { text: interimMessage }, interimMessage);
+                                }
+                            },
+                            onWorkerChunk: (event) => {
+                                if (event.type === 'step_start') {
+                                    recordWorkerActivity('worker_step_start', event, {
+                                        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') {
+                                    recordWorkerActivity('worker_chunk', event, {
+                                        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') {
+                                    recordWorkerActivity('worker_tool_call', event, {
+                                        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') {
+                                    recordWorkerActivity('worker_tool_result', event, {
+                                        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 === 'step_done') {
+                                    recordWorkerActivity('worker_step_done', event, {
+                                        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,
+                                    });
+                                }
+                            },
+                            mqttPublish: async () => { },
+                            commandId: `plan-run-${run.id}-${Date.now()}`,
+                        },
+                    });
+                    const summary = (started.replyText || '').trim();
+                    if (summary && !activeRunner.stopRequested) {
+                        data.addMessage(run.conversation_id, 'assistant', summary, orchestratorRuntime.model || 'Orchestrator', undefined, undefined, 'Orchestrator');
+                    }
+                }
+                catch (startErr) {
+                    if (activeRunner.stopRequested || startErr?.name === 'AbortError') {
+                        const pausedRun = data.getImportedPlanRun(run.id) || run;
+                        data.updateImportedPlanRun(run.id, {
+                            status: 'paused',
+                            completedAt: null,
+                            lastError: pausedRun.last_error || importedPlanPauseSummary(activeRunner.stopAction || 'pause'),
+                        });
+                        return;
+                    }
+                    const errorDetail = startErr?.message || 'Imported plan execution failed.';
+                    data.updateImportedPlanRun(run.id, { status: 'paused', lastError: errorDetail });
+                    const failureMessage = buildPlanFailureChatMessage({
+                        sourceFileName: run.source_file_name,
+                        error: errorDetail,
+                        status: 'paused (was running)',
+                    });
+                    data.addMessage(run.conversation_id, 'assistant', failureMessage, orchestratorRuntime.model || 'Orchestrator', undefined, undefined, 'Orchestrator');
+                }
+                finally {
+                    activeImportedPlanRunners.delete(run.id);
+                    teardownImportedPlanRunnerSessions(data.getImportedPlanRun(run.id) || run, activeRunner.sessionScopeKey);
+                }
+            })();
+            res.json({
+                ok: true,
+                started: true,
+                messageId: assistant.id,
+                run: serializeImportedPlanRun(data.getImportedPlanRun(run.id)),
+                summary: startedSummary,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/orchestration/import-plan/delete-selected', (req, res) => {
+        try {
+            const runId = String(req.body?.runId || '').trim();
+            const taskIds = Array.isArray(req.body?.taskIds) ? req.body.taskIds : [];
+            if (!runId)
+                return res.status(400).json({ error: 'runId is required' });
+            const updatedRun = data.deleteImportedPlanRunSelectedTasks(runId, taskIds, { actorType: 'user', actorId: 'plan-import-review' });
+            if (!updatedRun)
+                return res.status(404).json({ error: 'Imported plan run not found.' });
+            res.json({ ok: true, run: serializeImportedPlanRun(updatedRun) });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.get('/api/admin/audit', (req, res) => {
         try {
             const rows = data.listAdminAudit({
@@ -3889,16 +6402,14 @@ function startLocalServer(opts) {
     // ─── Clerk Config ──────────────────────────────────────────
     app.get('/api/clerk/config', (_req, res) => {
         try {
-            const clerkProvider = data.getSetting('clerk_provider');
-            const clerkModel = data.getSetting('clerk_model');
-            const hasKey = !!data.getSetting('clerk_api_key');
+            const clerkConfig = data.getResolvedClerkConfigInfo();
             const currentOrchestrator = data.getCurrentOrchestratorSelection();
             const currentDefaultBot = data.getDefaultAgentProfile();
             res.json({
-                provider: clerkProvider || null,
-                model: clerkModel || null,
-                hasApiKey: hasKey,
-                configured: !!(clerkProvider && clerkModel && hasKey),
+                provider: clerkConfig.provider,
+                model: clerkConfig.model,
+                hasApiKey: clerkConfig.hasSecret,
+                configured: clerkConfig.configured,
                 isOrchestrator: data.isClerkOrchestratorEnabled(),
                 currentOrchestrator,
                 currentDefaultBot: currentDefaultBot
@@ -4794,6 +7305,8 @@ function startLocalServer(opts) {
     });
     // Initialize workflow engine
     (0, workflow_engine_1.getWorkflowEngine)(opts.projectDir, 'local_desktop');
+    // Start idle session sweep (checks every 60s, reaps after 30min idle)
+    (0, managed_process_registry_1.startIdleSweep)(handleIdleSweepClose);
     // Start server
     return new Promise((resolve, reject) => {
         _server = app.listen(port, '127.0.0.1', () => {
@@ -4801,6 +7314,12 @@ function startLocalServer(opts) {
             console.log(chalk_1.default.green(`\n  Local server: http://127.0.0.1:${port}`));
             resolve(_server);
         });
+        _server.on('close', () => {
+            (0, managed_process_registry_1.stopIdleSweep)();
+            for (const botId of [...cliBotConfigWatchers.keys()]) {
+                closeCliBotConfigWatcher(botId);
+            }
+        });
         _server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
                 console.error(chalk_1.default.red(`Port ${port} already in use`));
@@ -4810,6 +7329,7 @@ function startLocalServer(opts) {
     });
 }
 function stopLocalServer() {
+    (0, managed_process_registry_1.stopIdleSweep)();
     return new Promise((resolve) => {
         if (_server) {
             _server.close(() => {
@@ -4933,18 +7453,46 @@ function hydrateMessageDisplayMetadata(message) {
         model: [modelBase, runtimeLabel].filter(Boolean).join(' | '),
     };
 }
+function isSameTurn(a, b) {
+    return String(a.userMessage.id || '') === String(b.userMessage.id || '');
+}
+function shouldSkipFreshCliBootstrap(input) {
+    return input.providerName === 'codex-cli'
+        && !input.resumeSessionId
+        && input.promptContextMode === 'new_topic';
+}
+function resolveLocalDesktopPromptContext(input) {
+    const project = input.conversation?.project_id ? data.getProject(input.conversation.project_id) : undefined;
+    const configuredWorkspacePath = String(project?.folder || '').trim();
+    const llmSpawnCwd = configuredWorkspacePath && fs.existsSync(configuredWorkspacePath)
+        ? configuredWorkspacePath
+        : input.fallbackCwd;
+    const normalizedExplicitTopicId = String(input.explicitTopicId || '').trim();
+    const topicId = normalizedExplicitTopicId || data.getPrimaryTopicIdForConversation(input.conversationId) || undefined;
+    const topicTitle = topicId ? data.getTopic(topicId)?.title : undefined;
+    return {
+        llmSpawnCwd,
+        workspacePath: llmSpawnCwd,
+        projectName: project?.name || input.conversation?.project_name || undefined,
+        topicId,
+        topicTitle: topicTitle || undefined,
+        cliHistoryFilePath: input.writeCliHistoryBootstrap
+            ? (0, cli_bootstrap_history_1.writeConversationBootstrapHistoryFile)({
+                conversationId: input.conversationId,
+                topicId,
+            })
+            : null,
+    };
+}
 function buildLocalDesktopDirectPrompt(input) {
     const isCliProvider = index_1.CLI_PROVIDERS.has(input.currentProvider);
     const useCompletionSentinel = !!input.useCompletionSentinel;
-    const useCliHistoryBootstrap = isCliProvider && !input.isCliRecurring;
-    const crossBotReplies = isCliProvider && input.isCliRecurring
-        ? getLatestOtherBotReplies(input.conversationId, input.currentBotId, input.currentBotName)
-        : [];
+    const forceInlinePromptContext = !!input.forceInlinePromptContext;
+    const useCliHistoryBootstrap = isCliProvider && !input.isCliRecurring && !forceInlinePromptContext;
+    const crossBotBlock = input.crossBotTurn ? (0, context_window_1.formatCrossBotPreviousTurn)(input.crossBotTurn) : null;
     const contract = !isCliProvider || !input.isCliRecurring
         ? 'api_or_fresh_cli'
-        : crossBotReplies.length > 0
-            ? 'cli_recurring_multibot'
-            : 'cli_recurring_single';
+        : 'cli_recurring_single';
     const lines = [
         '[Bot Identity]',
         input.soulMd.trim(),
@@ -4978,16 +7526,51 @@ function buildLocalDesktopDirectPrompt(input) {
             lines.push('If the user refers to prior project or conversation context that is not included here, search with these tools first.');
         }
     }
-    if (contract === 'api_or_fresh_cli' && !useCliHistoryBootstrap) {
+    // Worker TODO mechanics paragraph (Decision 7 of orchestration-plan.txt).
+    // Advertises ONLY the TODO tools actually available to this bot. Respects
+    // Codex Guardrail #6: don't advertise tools the bot can't call.
+    const toolNamesAvailable = new Set((input.availableTools || [])
+        .map((tool) => String(tool?.name || '').trim().toLowerCase())
+        .filter(Boolean));
+    const todoToolMentions = [];
+    if (toolNamesAvailable.has('list_tasks')) {
+        todoToolMentions.push('Use `list_tasks` to query the TODO list (filter by `owner` for specific bots).');
+    }
+    if (toolNamesAvailable.has('check_task')) {
+        todoToolMentions.push('Use `check_task` to mark an item complete.');
+    }
+    if (toolNamesAvailable.has('add_task')) {
+        todoToolMentions.push('Use `add_task` to add new items.');
+    }
+    if (toolNamesAvailable.has('edit_task')) {
+        todoToolMentions.push('Use `edit_task` to modify.');
+    }
+    if (toolNamesAvailable.has('delete_task')) {
+        todoToolMentions.push('Use `delete_task` to remove.');
+    }
+    if (todoToolMentions.length > 0) {
+        lines.push('', '[TODO List Tools]', ...todoToolMentions);
+    }
+    if (crossBotBlock && !input.isCliRecurring) {
+        lines.push('', '[Immediate Cross-Bot Handoff]', crossBotBlock);
+    }
+    if ((contract === 'api_or_fresh_cli' && !useCliHistoryBootstrap) || forceInlinePromptContext) {
         const summaryWindow = (0, context_window_1.getPromptContextWindow)(input.conversationId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS);
         if (summaryWindow.summary?.summary_text?.trim()) {
-            lines.push('', '[Context Summary]', summaryWindow.summary.summary_text.trim());
+            lines.push('', summaryWindow.carriedForward
+                ? '[Context Summary (Carried Forward from Previous Conversation in This Topic)]'
+                : '[Context Summary]', summaryWindow.summary.summary_text.trim());
         }
         const recentTurnsWindow = (0, context_window_1.getPromptContextWindow)(input.conversationId, summaryWindow.summary?.summary_text?.trim()
             ? safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS
             : safeguards_1.SAFEGUARDS.NO_SUMMARY_CONTEXT_WINDOW_TURNS);
-        if (recentTurnsWindow.turns.length > 0) {
-            lines.push('', '[Recent Messages]', (0, context_window_1.formatTurnsForPrompt)(recentTurnsWindow.turns));
+        const recentTurns = crossBotBlock
+            ? recentTurnsWindow.turns.filter((turn) => !input.crossBotTurn || !isSameTurn(turn, input.crossBotTurn))
+            : recentTurnsWindow.turns;
+        if (recentTurns.length > 0) {
+            lines.push('', recentTurnsWindow.carriedForward
+                ? '[Recent Messages (Carried Forward from Previous Conversation in This Topic)]'
+                : '[Recent Messages]', (0, context_window_1.formatTurnsForPrompt)(recentTurns));
         }
     }
     let effectiveUserPrompt = input.userPrompt;
@@ -5002,15 +7585,6 @@ function buildLocalDesktopDirectPrompt(input) {
             input.userPrompt,
         ].join('\n');
     }
-    if (contract === 'cli_recurring_multibot' && crossBotReplies.length > 0) {
-        effectiveUserPrompt = [
-            '[Cross-Bot Context]',
-            ...crossBotReplies.map((line) => `- ${line}`),
-            '',
-            'Current user request:',
-            input.userPrompt,
-        ].join('\n');
-    }
     if (useCompletionSentinel) {
         effectiveUserPrompt = [
             effectiveUserPrompt,
@@ -5027,70 +7601,17 @@ function buildLocalDesktopDirectPrompt(input) {
 function buildLocalDesktopDirectPromptForTest(input) {
     return buildLocalDesktopDirectPrompt(input);
 }
-function writeCliBootstrapHistoryFile(input) {
-    const historyDir = path.join(input.projectPath, 'history');
-    const filename = `${input.conversationId}--${input.botId}.txt`;
-    const historyFilePath = path.join(historyDir, filename);
-    const historyContent = buildCliBootstrapHistoryContent(input.conversationId, input.topicId);
-    try {
-        fs.mkdirSync(historyDir, { recursive: true });
-        cleanupStaleCliHistoryFiles(historyDir);
-        fs.writeFileSync(historyFilePath, historyContent, 'utf8');
-        return historyFilePath;
-    }
-    catch (err) {
-        console.warn(chalk_1.default.yellow(`  [cli-history] Failed to write bootstrap history file: ${err instanceof Error ? err.message : String(err)}`));
-        return null;
-    }
+function resolveLocalDesktopPromptContextForTest(input) {
+    return resolveLocalDesktopPromptContext(input);
 }
-function buildCliBootstrapHistoryContent(conversationId, topicId) {
-    const lines = [];
-    const previousConversationId = topicId ? data.getPreviousConversationInTopic(conversationId)?.id || null : null;
-    lines.push('[Bootstrap History]');
-    if (!topicId) {
-        lines.push('No prior topic history is available for this conversation.');
-        return lines.join('\n').trim();
-    }
-    if (!previousConversationId) {
-        lines.push('No prior topic history is available for this conversation.');
-        return lines.join('\n').trim();
-    }
-    const rollingSummary = (0, context_window_1.getLatestRollingSummary)(previousConversationId);
-    const recentTurns = (0, context_window_1.getRecentTurns)(previousConversationId, 5);
-    if (rollingSummary?.summary_text?.trim()) {
-        lines.push('', '[Running Summary]', rollingSummary.summary_text.trim());
-    }
-    if (recentTurns.length > 0) {
-        lines.push('', '[Last 5 Turns]', (0, context_window_1.formatTurnsForPrompt)(recentTurns));
-    }
-    else {
-        lines.push('', '[Last 5 Turns]', '(no recent topic turns)');
-    }
-    return lines.join('\n').trim();
+function shouldSkipFreshCliBootstrapForTest(input) {
+    return shouldSkipFreshCliBootstrap(input);
 }
-function cleanupStaleCliHistoryFiles(historyDir) {
-    const maxAgeMs = 14 * 24 * 60 * 60 * 1000;
-    const now = Date.now();
-    try {
-        const files = fs.readdirSync(historyDir);
-        for (const file of files) {
-            if (!file.toLowerCase().endsWith('.txt'))
-                continue;
-            const fullPath = path.join(historyDir, file);
-            try {
-                const stat = fs.statSync(fullPath);
-                if (now - stat.mtimeMs > maxAgeMs) {
-                    fs.unlinkSync(fullPath);
-                }
-            }
-            catch {
-                // best effort cleanup only
-            }
-        }
-    }
-    catch {
-        // best effort cleanup only
-    }
+function buildLocalRuntimeUserFacingErrorForTest(err) {
+    return buildLocalRuntimeUserFacingError(err);
+}
+function persistCliOauthSessionForTest(input) {
+    return persistCliOauthSession(input.providerId, input.accessToken, input.refreshToken, input.expiresAt);
 }
 function buildLocalDesktopToolManifest(availableTools, contract) {
     const selectedTools = contract === 'api_or_fresh_cli'
@@ -5101,32 +7622,6 @@ function buildLocalDesktopToolManifest(availableTools, contract) {
         .join('\n')
         .trim();
 }
-function getLatestOtherBotReplies(conversationId, currentBotId, currentBotName) {
-    const turns = (0, context_window_1.getPromptContextWindow)(conversationId, safeguards_1.SAFEGUARDS.NO_SUMMARY_CONTEXT_WINDOW_TURNS).turns;
-    const seen = new Set();
-    const replies = [];
-    for (let turnIndex = turns.length - 1; turnIndex >= 0; turnIndex -= 1) {
-        const turn = turns[turnIndex];
-        for (let responseIndex = turn.responses.length - 1; responseIndex >= 0; responseIndex -= 1) {
-            const response = turn.responses[responseIndex];
-            if (response.role !== 'assistant')
-                continue;
-            const identity = String(response.bot_id || response.agent_name || '').trim();
-            if (!identity)
-                continue;
-            const sameBot = (response.bot_id && response.bot_id === currentBotId)
-                || (response.agent_name && response.agent_name === currentBotName);
-            if (sameBot || seen.has(identity))
-                continue;
-            const content = String(response.content || '').trim();
-            if (!content)
-                continue;
-            seen.add(identity);
-            replies.unshift(`${response.agent_name || 'Assistant'} (${response.created_at}): ${content}`);
-        }
-    }
-    return replies;
-}
 function classifyOrchestratorProgress(status) {
     const trimmed = String(status || '').trim();
     if (!trimmed)
@@ -5168,8 +7663,45 @@ function resolveCliNameForProvider(providerName) {
         return 'codex';
     return null;
 }
+function deriveVisibleOrchestratorMessage(status) {
+    const trimmed = String(status || '').trim();
+    const match = trimmed.match(/^Orchestrator::\s*(.+)$/i);
+    const detail = match?.[1]?.trim() || '';
+    if (/^Detected requested (workflow|bot sequence):/i.test(detail)) {
+        return detail;
+    }
+    // Robotic system-generated orchestrator placeholders stay hidden. The
+    // detected workflow candidate is the one exception: it is user-facing
+    // confirmation that no workers start until the orchestrator approves.
+    return null;
+}
 function isInteractiveAuthFailure(text) {
-    return /\b(not logged in|please run \/login|unauthorized|invalid api key|authentication required)\b/i.test(text);
+    return /\b(not logged in|please run \/login|login required|unauthorized|invalid authorization|invalid api key|missing api key|authentication required|invalid authentication credentials|invalid bearer token|token expired|session expired|credentials expired|expired credentials|reauthenticate)\b/i.test(text);
+}
+function normalizeCliOauthExpiry(expiresAt) {
+    return typeof expiresAt === 'number' && Number.isFinite(expiresAt) && expiresAt > 0
+        ? expiresAt
+        : Date.now() + 60 * 60 * 1000;
+}
+function persistCliOauthSession(providerId, accessToken, refreshToken, expiresAt) {
+    const normalizedExpiry = normalizeCliOauthExpiry(expiresAt);
+    const written = providerId === 'claude-cli'
+        ? (0, token_refresh_1.writeClaudeCredentials)({
+            provider: 'anthropic',
+            accessToken,
+            refreshToken,
+            expiresAt: normalizedExpiry,
+        })
+        : (0, token_refresh_1.writeCodexCredentials)({
+            provider: 'openai',
+            accessToken,
+            refreshToken,
+            expiresAt: normalizedExpiry,
+        });
+    if (written) {
+        (0, credential_reader_1.clearCache)();
+    }
+    return written;
 }
 function detectInteractiveAuthFailure(text, activeProviderName, configuredProviderName) {
     if (!isInteractiveAuthFailure(text))
@@ -5187,19 +7719,60 @@ function detectInteractiveAuthFailure(text, activeProviderName, configuredProvid
     };
 }
 const LOCAL_RUNTIME_RETRY_LIMIT = 2;
+function resolveProviderDisplayLabel(providerName) {
+    const cli = resolveCliNameForProvider(String(providerName || ''));
+    if (cli === 'claude')
+        return 'Claude';
+    if (cli === 'codex')
+        return 'Codex';
+    const normalized = String(providerName || '').trim().toLowerCase();
+    if (normalized === 'anthropic')
+        return 'Anthropic';
+    if (normalized === 'openai')
+        return 'OpenAI';
+    if (normalized === 'google' || normalized === 'gemini')
+        return 'Gemini';
+    return 'the selected LLM';
+}
 function isClaudeFreshSessionStartupFailure(err) {
     return err?.code === 'CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT'
         || err?.name === 'ClaudeFreshSessionStartupTimeoutError'
         || /fresh session startup timed out/i.test(String(err?.message || err || ''));
 }
+function clearFailedLocalCliSessionEpoch(conversationId, botId, sessionId, sessionScopeKey) {
+    const normalizedSessionId = String(sessionId || '').trim();
+    if (!normalizedSessionId)
+        return;
+    try {
+        const cleared = data.clearCliSessionEpochIfMatches(conversationId, botId, normalizedSessionId, sessionScopeKey);
+        if (cleared) {
+            console.warn(`[chat] cleared poisoned cli_session_epoch conversationId=${conversationId} botId=${botId} sessionId=${normalizedSessionId}`);
+        }
+    }
+    catch (err) {
+        console.warn(`[chat] failed to clear cli_session_epoch conversationId=${conversationId} botId=${botId} sessionId=${normalizedSessionId}: ${err?.message || err}`);
+    }
+}
+function buildLocalRuntimeUserFacingError(err) {
+    const exact = String(err?.message || err || '').trim();
+    if (!exact)
+        return null;
+    const providerLabel = resolveProviderDisplayLabel(err?.providerId || err?.provider || 'claude-cli');
+    if (isClaudeFreshSessionStartupFailure(err)
+        || err?.cli
+        || /\b(pty|app-server|resume|session|transcript)\b/i.test(exact)) {
+        return `${providerLabel} local runtime failed: ${exact}`;
+    }
+    return null;
+}
 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)) {
+    if (/\b(no api key|missing api key|configure one in settings|not available on this machine|not installed|please run \/login|login required|not logged in|unauthorized|invalid authorization|invalid api key|authentication required|invalid authentication credentials|invalid bearer token|token expired|session expired|credentials expired|expired credentials|reauthenticate)\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);
+    return /\b(429|rate limit|timeout|timed out|temporar|temporarily|econnreset|etimedout|enotfound|econnrefused|socket hang up|network|try again|overloaded|busy|no meaningful pty activity)\b/i.test(text);
 }
 async function pauseLocalRuntimeRetry(attempt) {
     const delayMs = attempt <= 1 ? 750 : 1500;
@@ -5285,6 +7858,12 @@ async function autoTitleConversation(convId, userMsg, assistantMsg, providerName
         });
         if (resp.content) {
             data.updateConversation(convId, { title: resp.content.trim().slice(0, 100) });
+            const revision = data.bumpConversationSyncRevision(convId);
+            (0, chat_sync_1.emitChatSyncEvent)({
+                change: 'conversation.updated',
+                conversationId: convId,
+                revision,
+            });
         }
     }
     catch { /* best-effort */ }