funolio-agent 1.0.53 → 1.1.65

package/dist/local-server.js

@@ -39,6 +39,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startLocalServer = startLocalServer;
 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.
  *
@@ -47,21 +53,24 @@ exports.buildChatRuntimeForTest = buildChatRuntimeForTest;
  * Reuses existing LLM providers and tool execution from message-loop/providers.
  */
 const index_1 = require("./providers/index");
+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");
 const status_parser_1 = require("./orchestration/status-parser");
 const guided_actions_1 = require("./orchestration/guided-actions");
 const topic_normalizer_1 = require("./orchestration/topic-normalizer");
-const policy_prompt_1 = require("./orchestration/policy-prompt");
 const safeguards_1 = require("./orchestration/safeguards");
 const token_counter_1 = require("./token-counter");
 const response_guard_1 = require("./response-guard");
@@ -71,14 +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"));
@@ -96,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();
@@ -103,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(', ')}`);
@@ -135,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)();
@@ -191,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 {
@@ -209,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)();
@@ -231,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)();
@@ -552,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) => {
@@ -607,22 +1681,29 @@ 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 next = data.listQueuedChatJobs(1)[0];
+            const runningKeys = new Set(data.listRunningChatJobs(MAX_LOCAL_CHAT_JOBS + 20).map((job) => `${job.conversation_id}::${job.bot_id}`));
+            const next = data
+                .listQueuedChatJobs(50)
+                .find((job) => !runningKeys.has(`${job.conversation_id}::${job.bot_id}`));
             if (!next)
                 return;
             if (runningChatJobControllers.has(next.id))
                 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);
@@ -646,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,
@@ -663,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);
@@ -681,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 });
                         },
                     });
                 }
@@ -696,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';
@@ -710,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);
@@ -745,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,
@@ -1072,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',
             });
@@ -1101,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) {
@@ -1230,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 } = 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' });
                 }
@@ -1260,10 +2385,28 @@ 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,
+                    codexPersonality: codexPersonality ?? codex_personality,
+                    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) {
@@ -1301,22 +2444,63 @@ 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)
                     fields.isOrchestrator = b.isOrchestrator ?? b.is_orchestrator;
+                if (b.codexReasoningEffort !== undefined || b.codex_reasoning_effort !== undefined)
+                    fields.codexReasoningEffort = b.codexReasoningEffort ?? b.codex_reasoning_effort;
+                if (b.codexReasoningSummary !== undefined || b.codex_reasoning_summary !== undefined)
+                    fields.codexReasoningSummary = b.codexReasoningSummary ?? b.codex_reasoning_summary;
+                if (b.codexPersonality !== undefined || b.codex_personality !== undefined)
+                    fields.codexPersonality = b.codexPersonality ?? b.codex_personality;
+                if (b.codexServiceTier !== undefined || b.codex_service_tier !== undefined)
+                    fields.codexServiceTier = b.codexServiceTier ?? b.codex_service_tier;
+                if (b.codexSandboxPolicy !== undefined || b.codex_sandbox_policy !== undefined)
+                    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) {
@@ -1352,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) {
@@ -1373,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 });
@@ -1423,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();
@@ -1438,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) {
@@ -1488,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) {
@@ -1510,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) {
@@ -1614,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' });
@@ -1777,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' });
@@ -1998,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) {
@@ -2055,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) {
@@ -2201,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 || ''),
@@ -2367,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) {
@@ -2437,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 && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
-            if (shouldUseOrchestratorMode) {
-                return res.status(400).json({ error: 'Background chat jobs do not support orchestrator mode yet.' });
-            }
-            let convId = conversationId ? String(conversationId) : '';
-            if (convId) {
-                const latestJob = data.getLatestConversationChatJob(convId);
-                if (latestJob && (latestJob.status === 'queued' || latestJob.status === 'running')) {
-                    return res.status(409).json({ error: 'This conversation already has a pending response.' });
-                }
-            }
-            if (!convId) {
-                let topicProjectId = null;
-                if (topicId) {
-                    const topic = data.getTopic(String(topicId));
-                    topicProjectId = topic?.project_id ?? null;
-                }
-                const requestedProjectId = (projectId ? String(projectId) : null) || topicProjectId;
-                const conv = data.createConversation(profile.id, '', 'local', {
-                    projectId: requestedProjectId,
-                });
-                convId = conv.id;
-            }
-            if (topicId && convId) {
-                try {
-                    data.upsertConversationTopicSegment(convId, String(topicId));
-                }
-                catch { /* best effort */ }
-            }
-            if (!topicId && projectId && convId) {
-                const selectedProject = data.getProject(String(projectId));
-                if (selectedProject) {
-                    data.updateConversation(convId, {
-                        projectId: selectedProject.id,
-                        projectName: selectedProject.name,
-                    });
-                }
+            const 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) => {
@@ -2542,19 +3769,114 @@ function startLocalServer(opts) {
                 controller.abort();
             }
             else {
-                finalizeCancelledChatJobMessage(job);
-                data.touchConversationActivity(job.conversation_id);
+                finalizeCancelledChatJobMessage(job);
+                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' });
+        }
+        catch (err) {
+            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();
             }
-            res.json({ ok: true, status: 'cancelled' });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
         }
     });
     // ─── 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 latestJob = data.getLatestConversationChatJob(req.params.id);
+            const requestedBotId = String(req.body?.botId || '').trim();
+            const latestJob = requestedBotId
+                ? data.getLatestConversationBotChatJob(req.params.id, requestedBotId)
+                : data.getLatestConversationChatJob(req.params.id);
             if (!latestJob)
                 return res.status(404).json({ error: 'Chat job not found' });
             if (latestJob.status === 'completed' || latestJob.status === 'failed' || latestJob.status === 'cancelled') {
@@ -2572,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 });
@@ -2590,15 +3916,44 @@ function startLocalServer(opts) {
             routeAbortController.abort();
         };
         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);
@@ -2614,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
@@ -2626,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) {
@@ -2703,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);
@@ -2729,24 +4098,232 @@ 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 && (0, orchestrator_profile_1.isOrchestratorProfile)(profile);
             if (shouldUseOrchestratorMode) {
-                const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
-                if (!clerk) {
-                    // Fix #2: Do not silently fall through to direct chat — return a clear error
-                    return res.status(400).json({
-                        error: 'Orchestrator mode requires a clerk model to be configured. Please add a provider connection in Settings.',
-                    });
-                }
                 const { OrchestratorAgent } = require('./orchestrator');
+                const { buildLocalDesktopOrchestratorRuntime } = require('./orchestrator');
                 const { getWorkflowEngine } = require('./workflow-engine');
                 const workflowEngine = getWorkflowEngine(opts.projectDir, 'local_desktop');
-                const orchestrator = new OrchestratorAgent(clerk, workflowEngine);
+                // 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(explicitOrchestratorBot);
+                }
+                catch (runtimeErr) {
+                    return res.status(400).json({
+                        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);
                 // Resolve effective project ID from request or existing conversation
                 const conv = data.getConversation(convId);
                 const effectiveProjectId = projectId ? String(projectId) : (conv?.project_id || undefined);
@@ -2755,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',
@@ -2769,35 +4384,61 @@ function startLocalServer(opts) {
                 };
                 let orchestratorRuntimeLabel = '';
                 let orchestratorRuntimePayload;
+                const clerkSelectedAsOrchestrator = data.isClerkOrchestratorEnabled();
                 try {
-                    const orchestratorRuntime = await buildChatRuntime(profile);
-                    orchestratorRuntimeLabel = [
-                        orchestratorRuntime.model || profile.model || '',
-                        runtimeModeLabel(orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource),
-                    ].filter(Boolean).join(' | ');
-                    orchestratorRuntimePayload = runtimePayloadForDisplay(profile.provider, orchestratorRuntime.model || profile.model || null, orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource || null);
+                    if (clerkSelectedAsOrchestrator) {
+                        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';
+                        const clerkRuntimeSource = clerkConnection?.access_mode === 'oauth'
+                            ? 'oauth-token'
+                            : clerkConnection?.access_mode === 'cli'
+                                ? 'cli-direct'
+                                : 'api-key';
+                        orchestratorRuntimeLabel = [
+                            clerkModel || '',
+                            runtimeModeLabel(clerkRuntimeMode, clerkRuntimeSource),
+                        ].filter(Boolean).join(' | ');
+                        orchestratorRuntimePayload = runtimePayloadForDisplay(clerkProvider, clerkModel, clerkRuntimeMode, clerkRuntimeSource);
+                    }
+                    else {
+                        const orchestratorRuntime = await buildChatRuntime(profile);
+                        orchestratorRuntimeLabel = [
+                            orchestratorRuntime.model || profile.model || '',
+                            runtimeModeLabel(orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource),
+                        ].filter(Boolean).join(' | ');
+                        orchestratorRuntimePayload = runtimePayloadForDisplay(profile.provider, orchestratorRuntime.model || profile.model || null, orchestratorRuntime.runtimeMode, orchestratorRuntime.runtimeSource || null);
+                    }
                 }
                 catch {
                     orchestratorRuntimeLabel = buildConfiguredMessageModel(profile);
                 }
                 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,
@@ -2816,7 +4457,6 @@ function startLocalServer(opts) {
                                 });
                             }
                             else if (event.type === 'worker_chunk') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_chunk', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2836,8 +4476,18 @@ function startLocalServer(opts) {
                                     text: event.text,
                                 });
                             }
+                            else if (event.type === 'worker_terminal_chunk') {
+                                sendEvent('worker_terminal_chunk', {
+                                    stepId: event.stepId,
+                                    botId: resolveWorkerBotId(event.agentName),
+                                    agentName: event.agentName,
+                                    description: event.description,
+                                    stepIndex: event.stepIndex,
+                                    totalSteps: event.totalSteps,
+                                    text: event.rawText,
+                                });
+                            }
                             else if (event.type === 'worker_tool_call') {
-                                hasWorkerActivity = true;
                                 recordWorkerActivity('worker_tool_call', event, {
                                     stepId: event.stepId,
                                     agentName: event.agentName,
@@ -2862,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,
@@ -2901,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,
@@ -2938,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);
@@ -2958,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', {
@@ -3000,7 +4651,6 @@ function startLocalServer(opts) {
                         content: response,
                         agentName: finalAgentName,
                         botId: finalBotId,
-                        separateFinalMessage: splitFinalMessage,
                         ...((responseMeta?.modelLabel || orchestratorRuntimePayload)
                             ? {
                                 runtime: {
@@ -3020,16 +4670,47 @@ 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();
                 }
                 return;
             }
-            // Prompt Contract v1: system carries summary + last 5 turns.
-            // Send only the current user request as the primary user message.
-            const llmMessages = [{ role: 'user', content: message }];
             const configuredTz = (data.getSetting('timezone') || '').trim();
             const effectiveTimezone = configuredTz && configuredTz.toLowerCase() !== 'system'
                 ? configuredTz
@@ -3042,101 +4723,9 @@ function startLocalServer(opts) {
                 ? new Set(allToolDefs.map((tool) => tool.name))
                 : expandAllowedToolNames(allToolDefs, configuredBuiltinTools, configuredMcpTools);
             const toolDefs = allToolDefs.filter((tool) => allowedToolNames.has(tool.name));
-            // Build system prompt via clerk (token-budgeted context injection)
-            let systemPrompt;
-            let llmSpawnCwd = opts.projectDir;
-            const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
-            if (clerk) {
-                const conv = data.getConversation(convId);
-                const topicTitle = topicId ? data.getTopic(topicId)?.title : undefined;
-                const project = conv?.project_id ? data.getProject(conv.project_id) : undefined;
-                const workspacePath = project?.folder?.trim() || undefined;
-                if (workspacePath && fs.existsSync(workspacePath)) {
-                    llmSpawnCwd = workspacePath;
-                }
-                const built = clerk.buildPrompt(message, profile.id, profile, {
-                    targetModel: profile.model,
-                    conversationId: convId,
-                    projectName: conv?.project_name || undefined,
-                    projectId: conv?.project_id || undefined,
-                    topicTitle: topicTitle || undefined,
-                    workspacePath,
-                    timezone: effectiveTimezone,
-                    includeKeyDecisions: false,
-                    availableTools: toolDefs.map((tool) => ({ name: tool.name, description: tool.description })),
-                });
-                systemPrompt = built.systemPrompt;
-                console.log(chalk_1.default.gray(`  [clerk] Context: ${built.injectedSummaries} summaries (${built.contextTokensUsed} tokens)`));
-            }
-            else {
-                // Fallback: manual prompt building
-                systemPrompt = '[Bot Identity]\n' + (profile.soul_md
-                    || 'You are an AI assistant running locally. You have access to project files and can execute code.');
-                systemPrompt += '\n\nDo not end with a deferred promise (for example: "Let me check..."). Return a final answer in this turn, or state exactly what is unavailable.';
-                systemPrompt += '\n\nWhen [Project Overview] is present, treat Project/Topic/Workspace values there as authoritative for the current turn and override stale prior-chat claims.';
-                systemPrompt += '\n\n[Response Style]\nWrite in short readable paragraphs. Put a blank line between distinct ideas. Use bullets when listing findings, steps, or issues. Do not return one dense wall of text. For progress updates, keep them compact and clearly separate what you checked, what you found, and what you are doing next.';
-                const convForFallback = data.getConversation(convId);
-                const projectForFallback = convForFallback?.project_id ? data.getProject(convForFallback.project_id) : undefined;
-                const workspaceForFallback = projectForFallback?.folder?.trim();
-                if (workspaceForFallback && fs.existsSync(workspaceForFallback)) {
-                    llmSpawnCwd = workspaceForFallback;
-                }
-                const fallbackMeta = [];
-                if (convForFallback?.project_name)
-                    fallbackMeta.push(`Project: ${convForFallback.project_name}`);
-                if (topicId) {
-                    const fallbackTopic = data.getTopic(topicId);
-                    if (fallbackTopic?.title)
-                        fallbackMeta.push(`Topic: ${fallbackTopic.title}`);
-                }
-                if (convForFallback?.project_id) {
-                    fallbackMeta.push(`Workspace: ${workspaceForFallback || '(project folder not configured)'}`);
-                }
-                if (fallbackMeta.length > 0) {
-                    systemPrompt += '\n\n[Project Overview]\n' + fallbackMeta.join('\n');
-                }
-                const effectivePolicy = data.getEffectiveOrchestrationPolicy(convForFallback?.project_id || undefined);
-                systemPrompt += '\n\n' + (0, policy_prompt_1.buildEffectivePolicyPromptSection)(effectivePolicy, {
-                    heading: '[Effective Policy]',
-                    defaultLine: 'No confirmed special policy is set.',
-                });
-                try {
-                    const todoStatus = data.getTodoStatusMarker(convForFallback?.project_id ?? undefined);
-                    systemPrompt += `\n\n[TODO Coordination]\nTODO STATUS: ${todoStatus}`;
-                }
-                catch { /* best-effort */ }
-                systemPrompt += '\n\n' + (0, clerk_model_1.buildTodoInstructions)(profile?.name || profile?.id || 'LLM');
-                let hasSummary = false;
-                try {
-                    const summaryContext = (0, context_window_1.getPromptContextWindow)(convId, safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS);
-                    if (summaryContext.summary?.summary_text) {
-                        const summaryHeader = summaryContext.carriedForward
-                            ? '[Context Summary (Carried Forward from Previous Conversation in This Topic)]'
-                            : '[Context Summary]';
-                        systemPrompt += `\n\n${summaryHeader}\n` + summaryContext.summary.summary_text;
-                        hasSummary = true;
-                    }
-                }
-                catch { /* best-effort */ }
-                try {
-                    const turnWindow = hasSummary
-                        ? safeguards_1.SAFEGUARDS.CONTEXT_WINDOW_TURNS
-                        : safeguards_1.SAFEGUARDS.NO_SUMMARY_CONTEXT_WINDOW_TURNS;
-                    const promptContext = (0, context_window_1.getPromptContextWindow)(convId, turnWindow);
-                    if (promptContext.turns.length > 0) {
-                        const turnsHeader = promptContext.carriedForward
-                            ? `[Recent Messages (Last ${promptContext.turns.length} Turns from Previous Conversation in This Topic)]`
-                            : `[Recent Messages (Last ${promptContext.turns.length} Turns)]`;
-                        systemPrompt += `\n\n${turnsHeader}\n` + (0, context_window_1.formatTurnsForPrompt)(promptContext.turns);
-                    }
-                }
-                catch { /* best-effort */ }
-            }
-            // Resolve LLM runtime.
-            // Desktop local mode intentionally supports only:
-            // - Subscription CLI
-            // - API Key
-            // We do not use subscription-token API routing for local CLI bots.
+            const conversation = data.getConversation(convId);
+            // 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);
             let activeProviderName = runtime.providerName;
             let activeModelName = runtime.model;
@@ -3164,6 +4753,133 @@ function startLocalServer(opts) {
             const cliEpochStartedAt = cliSessionEpochPlan.resumeSessionId
                 ? (cliSessionEpochPlan.existing?.epoch_started_at || localTimestamp())
                 : localTimestamp();
+            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: 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: !!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',
+            });
+            // 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.` });
             }
@@ -3175,14 +4891,6 @@ function startLocalServer(opts) {
                 restrictFileAccessToProject: unrestrictedCliProfile ? false : undefined,
                 abortSignal: routeAbortController.signal,
             });
-            const toolManifest = toolDefs
-                .map(t => `- ${t.name}: ${t.description}`)
-                .join('\n');
-            if (toolManifest.trim()) {
-                systemPrompt += unrestrictedCliProfile
-                    ? '\n\n[Available Tools]\nThe following tools are available in the current runtime:\n' + toolManifest
-                    : '\n\n[Available Tools]\nOnly the following tools are enabled for this bot in the current runtime:\n' + toolManifest;
-            }
             // Inject pinned messages as context (user-selected cross-bot references)
             if (pinnedMessageIds && Array.isArray(pinnedMessageIds) && pinnedMessageIds.length > 0) {
                 const pinnedLines = [];
@@ -3199,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 {
@@ -3240,33 +4955,6 @@ function startLocalServer(opts) {
                     isApproximate: true,
                 },
             });
-            sendEvent('status', {
-                phase: 'thinking',
-                detail: `Sending request to ${activeProviderName}...`,
-                runtime: runtimePayload(),
-            });
-            recordActivity('status', {
-                phase: 'thinking',
-                detail: `Sending request to ${activeProviderName}...`,
-                runtime: runtimePayload(),
-            }, `Sending request to ${activeProviderName}...`);
-            if (cliSessionEpochPlan.resetReason && enableCliSessionEpoch) {
-                const resetDetail = cliSessionEpochPlan.resetReason === 'turn_limit'
-                    ? 'Resetting CLI session after reaching the turn limit.'
-                    : cliSessionEpochPlan.resetReason === 'token_limit'
-                        ? 'Resetting CLI session after reaching the context budget.'
-                        : 'Resetting CLI session because the runtime changed.';
-                sendEvent('status', {
-                    phase: 'thinking',
-                    detail: resetDetail,
-                    runtime: runtimePayload(),
-                });
-                recordActivity('status', {
-                    phase: 'thinking',
-                    detail: resetDetail,
-                    runtime: runtimePayload(),
-                }, resetDetail);
-            }
             let partialPersistedContent = '';
             let partialPersistedAt = 0;
             const throwIfChatJobCancelled = () => {
@@ -3306,6 +4994,7 @@ function startLocalServer(opts) {
             let fullContent = '';
             let streamedContent = '';
             let streamedAnyChunk = false;
+            let rawCliTranscript = '';
             let iteration = 0;
             const MAX_ITERATIONS = 10; // Phase 1d: reduced from 20
             let totalInputTokens = 0;
@@ -3316,31 +5005,218 @@ function startLocalServer(opts) {
             let accumulatedThinking = '';
             const thinkingEnabled = !!profile?.show_thinking;
             let useInteractiveCliSession = enableCliSessionEpoch;
-            if (useInteractiveCliSession) {
+            const directCliSessionTransport = resolveDirectCliSessionTransport(activeProviderName, useInteractiveCliSession, (0, storage_mode_1.isLocalStorageMode)());
+            const useCodexAppServerInteractive = directCliSessionTransport === 'codex-app-server';
+            const usePtyInteractiveCliSession = directCliSessionTransport === 'pty';
+            const startDetail = `Started response via ${runtimeModeLabel(activeRuntimeMode, activeRuntimeSource) || activeProviderName}`;
+            sendEvent('status', { phase: 'thinking', detail: startDetail });
+            recordActivity('status', { phase: 'thinking', detail: startDetail }, startDetail);
+            if (useCodexAppServerInteractive) {
+                const codexAppServerManager = (0, codex_app_server_manager_1.getCodexAppServerManager)();
+                let appServerAttempt = 0;
+                let forceFreshInteractiveCliSession = false;
+                while (true) {
+                    appServerAttempt++;
+                    try {
+                        const isFreshSession = forceFreshInteractiveCliSession || (!codexAppServerManager.hasActiveSession(convId, profile.id) && !cliSessionEpochPlan.resumeSessionId);
+                        const result = await codexAppServerManager.runTurn({
+                            runtimeMode: 'local_desktop',
+                            conversationId: convId,
+                            botId: profile.id,
+                            botName: profile.name,
+                            cwd: llmSpawnCwd,
+                            systemPrompt,
+                            messages: llmMessages,
+                            forceFreshSession: isFreshSession,
+                            resumeSessionId: isFreshSession ? undefined : (cliSessionEpochPlan.resumeSessionId || undefined),
+                            model: activeModelName || profile.model || null,
+                            projectId: conversation?.project_id ?? 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,
+                            },
+                            abortSignal: routeAbortController.signal,
+                            onChunk: async (chunk) => {
+                                streamedAnyChunk = true;
+                                streamedContent += chunk;
+                                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)
+                                    return;
+                                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;
+                        }
+                        if (result.usage) {
+                            totalInputTokens += result.usage.inputTokens || 0;
+                            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}`));
+                            await pauseLocalRuntimeRetry(appServerAttempt);
+                            continue;
+                        }
+                        break;
+                    }
+                    catch (codexErr) {
+                        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}`));
+                        await pauseLocalRuntimeRetry(appServerAttempt);
+                    }
+                }
+            }
+            if (usePtyInteractiveCliSession) {
+                if (activeProviderName !== 'claude-cli') {
+                    throw new Error(`Legacy PTY interactive sessions are Claude-only in local desktop mode; expected ${activeProviderName} to use Codex app-server.`);
+                }
                 const ptyManager = (0, local_cli_pty_manager_1.getLocalCliPtySessionManager)();
                 let ptyAttempt = 0;
+                let forceFreshInteractiveCliSession = false;
+                let currentAttemptSessionId = null;
+                let currentAttemptWasFreshSession = false;
                 while (true) {
                     ptyAttempt++;
                     try {
+                        const hasLivePtySession = ptyManager.hasActiveSession(convId, profile.id);
+                        const isFreshSession = forceFreshInteractiveCliSession || (!hasLivePtySession && !cliSessionEpochPlan.resumeSessionId);
+                        const newSessionId = activeProviderName === 'claude-cli' && isFreshSession
+                            ? data.generateNextSessionId()
+                            : undefined;
+                        currentAttemptWasFreshSession = isFreshSession;
+                        currentAttemptSessionId = newSessionId || cliSessionEpochPlan.resumeSessionId || activeCliSessionId || null;
                         const result = await ptyManager.runTurn({
                             conversationId: convId,
                             botId: profile.id,
-                            provider: activeProviderName,
+                            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: !cliSessionEpochPlan.resumeSessionId,
-                            onDetail: async (detail) => {
-                                sendEvent('status', {
-                                    phase: 'thinking',
-                                    detail,
-                                    runtime: runtimePayload(),
+                            forceFreshSession: isFreshSession,
+                            resumeSessionId: isFreshSession ? undefined : (cliSessionEpochPlan.resumeSessionId || undefined),
+                            newSessionId,
+                            abortSignal: routeAbortController.signal,
+                            onRawChunk: async (chunk) => {
+                                sendEvent('terminal_chunk', {
+                                    text: chunk,
+                                    provider: activeProviderName,
+                                    botId: profile?.id || null,
+                                    agentName: profile?.name || null,
                                 });
-                                recordActivity('status', {
-                                    phase: 'thinking',
-                                    detail,
-                                    runtime: runtimePayload(),
-                                }, detail);
+                            },
+                            onChunk: async (chunk) => {
+                                streamedAnyChunk = true;
+                                streamedContent += chunk;
+                                persistAssistantPartial(false);
+                                sendEvent('chunk', { text: chunk });
+                            },
+                            onDetail: async (detail) => {
+                                const text = String(detail || '').trim();
+                                if (!text)
+                                    return;
+                                sendEvent('status', { phase: 'thinking', detail: text });
+                                recordActivity('status', { phase: 'thinking', detail: text }, text);
                             },
                         });
                         if (result.sessionId) {
@@ -3351,25 +5227,76 @@ function startLocalServer(opts) {
                             totalOutputTokens += result.usage.outputTokens || 0;
                             hasExactUsage = true;
                         }
-                        fullContent = (result.content || '').trim();
+                        // ─── 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}`));
+                            await pauseLocalRuntimeRetry(ptyAttempt);
+                            continue;
+                        }
                         break;
                     }
                     catch (ptyErr) {
+                        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;
                         }
-                        const retryDetail = `Selected runtime failed (${ptyErr?.message || ptyErr}); retrying the same connection (${ptyAttempt + 1}/${LOCAL_RUNTIME_RETRY_LIMIT})...`;
-                        console.warn(chalk_1.default.yellow(`  [chat] ${retryDetail}`));
-                        sendEvent('status', {
-                            phase: 'thinking',
-                            detail: retryDetail,
-                            runtime: runtimePayload(),
-                        });
-                        recordActivity('status', {
-                            phase: 'thinking',
-                            detail: retryDetail,
-                            runtime: runtimePayload(),
-                        }, retryDetail);
+                        const startupRetry = isClaudeFreshSessionStartupFailure(ptyErr);
+                        if (startupRetry || currentAttemptWasFreshSession) {
+                            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 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);
                     }
                 }
@@ -3379,10 +5306,6 @@ function startLocalServer(opts) {
                     iteration++;
                     let iterationFirstChunk = true;
                     throwIfChatJobCancelled();
-                    if (iteration > 1) {
-                        sendEvent('status', { phase: 'thinking', detail: 'Processing tool results...' });
-                        recordActivity('status', { phase: 'thinking', detail: 'Processing tool results...' }, 'Processing tool results...');
-                    }
                     let response;
                     const chatOptions = {
                         messages: llmMessages,
@@ -3398,8 +5321,6 @@ function startLocalServer(opts) {
                             throwIfChatJobCancelled();
                             if (iterationFirstChunk) {
                                 iterationFirstChunk = false;
-                                sendEvent('status', { phase: 'generating' });
-                                recordActivity('status', { phase: 'generating' }, 'Generating response...');
                             }
                             streamedAnyChunk = true;
                             streamedContent += chunk;
@@ -3531,7 +5452,7 @@ function startLocalServer(opts) {
                         continue;
                     }
                     // Final response (guard against defer-only filler)
-                    const candidate = (response.content || '').trim();
+                    const candidate = (0, completion_marker_1.stripCompletionSentinel)((response.content || '').trim()).text.trim();
                     if (!forcedFinalizationPass && (0, response_guard_1.isLikelyDeferredReply)(candidate)) {
                         forcedFinalizationPass = true;
                         llmMessages.push({ role: 'assistant', content: candidate });
@@ -3539,19 +5460,28 @@ function startLocalServer(opts) {
                             role: 'user',
                             content: 'Provide the final answer now. Do not say you will check later. Either provide concrete results or explicitly say what is unavailable.',
                         });
-                        sendEvent('status', { phase: 'thinking', detail: 'Finalizing response...' });
-                        recordActivity('status', { phase: 'thinking', detail: 'Finalizing response...' }, 'Finalizing response...');
                         continue;
                     }
                     fullContent = candidate;
                     break;
                 }
-            const persistedContent = fullContent || streamedContent.trim();
+            const persistedContent = (0, completion_marker_1.stripCompletionSentinel)(fullContent || streamedContent.trim()).text.trim();
             if (!persistedContent) {
                 throw new Error('Assistant returned no final response');
             }
             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;
@@ -3563,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(),
                 });
@@ -3594,8 +5524,15 @@ function startLocalServer(opts) {
                     model: modelWithRuntime || null,
                     botId: profile.id,
                     agentName: profile.name,
+                    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,
@@ -3606,6 +5543,7 @@ function startLocalServer(opts) {
                 summary: 'Final assistant response',
                 payload: {
                     content: persistedContent,
+                    ...(useInteractiveCliSession && rawCliTranscript ? { rawOutput: rawCliTranscript } : {}),
                     runtime: runtimePayload(),
                 },
                 expiresAt: activityExpiresAt,
@@ -3632,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);
@@ -3646,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,
@@ -3659,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,
@@ -3671,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,
@@ -3689,6 +5642,7 @@ function startLocalServer(opts) {
         }
         finally {
             req.off?.('close', abortOnClientClose);
+            res.off?.('close', abortOnClientClose);
         }
     });
     // ─── Memory Facts ───────────────────────────────────────────
@@ -3763,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({
@@ -3804,14 +6402,19 @@ 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
+                    ? { botId: currentDefaultBot.id, botName: currentDefaultBot.name }
+                    : null,
             });
         }
         catch (err) {
@@ -3820,13 +6423,16 @@ function startLocalServer(opts) {
     });
     app.put('/api/clerk/config', (req, res) => {
         try {
-            const { provider, model, apiKey } = req.body;
+            const { provider, model, apiKey, isOrchestrator } = req.body;
             if (!provider || !model)
                 return res.status(400).json({ error: 'provider and model are required' });
             data.setSetting('clerk_provider', provider);
             data.setSetting('clerk_model', model);
             if (apiKey)
                 data.setSetting('clerk_api_key', apiKey);
+            if (typeof isOrchestrator === 'boolean') {
+                data.setClerkAsOrchestrator(isOrchestrator);
+            }
             // Reset clerk instance so it picks up new config
             const { resetClerk } = require('./clerk-model');
             resetClerk();
@@ -3842,11 +6448,31 @@ function startLocalServer(opts) {
             const { prompt } = req.body;
             if (!prompt)
                 return res.status(400).json({ error: 'prompt is required' });
-            const clerk = (0, clerk_model_1.getClerk)({ runtimeMode: 'local_desktop' });
-            if (!clerk)
-                return res.json({ routing: 'default', reason: 'No clerk configured' });
             const agents = data.listAgentProfiles();
-            const route = await clerk.routeTask(prompt, agents);
+            const normalized = String(prompt || '').toLowerCase();
+            const defaultAgent = data.getDefaultAgentProfile() || agents[0];
+            const namedAgent = agents.find((agent) => normalized.includes(agent.name.toLowerCase()));
+            const roleMatchedAgent = /\b(qa|review|verify|test)\b/i.test(normalized)
+                ? agents.find((agent) => /\bqa|review\b/i.test(String(agent.role_class || agent.role_label || '')))
+                : /\b(research|brainstorm|analy[sz]e|evaluate|investigate)\b/i.test(normalized)
+                    ? agents.find((agent) => /\bresearch|analyst\b/i.test(String(agent.role_class || agent.role_label || '')))
+                    : /\b(build|code|implement|create|fix|write|update)\b/i.test(normalized)
+                        ? agents.find((agent) => /\bcode|coding|developer|builder\b/i.test(String(agent.role_class || agent.role_label || '')))
+                        : undefined;
+            const routeAgent = namedAgent || roleMatchedAgent || defaultAgent;
+            const route = routeAgent
+                ? {
+                    agentId: routeAgent.id,
+                    agentName: routeAgent.name,
+                    provider: routeAgent.provider,
+                    model: routeAgent.model,
+                    reasoning: namedAgent
+                        ? 'Matched the explicitly named bot.'
+                        : roleMatchedAgent
+                            ? 'Matched the prompt to the configured bot role.'
+                            : 'Fell back to the configured default bot.',
+                }
+                : { routing: 'default', reason: 'No bot configured' };
             res.json(route);
         }
         catch (err) {
@@ -4679,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', () => {
@@ -4686,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`));
@@ -4695,6 +7329,7 @@ function startLocalServer(opts) {
     });
 }
 function stopLocalServer() {
+    (0, managed_process_registry_1.stopIdleSweep)();
     return new Promise((resolve) => {
         if (_server) {
             _server.close(() => {
@@ -4752,6 +7387,13 @@ function runtimeModeLabel(mode, runtimeSource) {
         return (0, subscription_runtime_1.claudeSubscriptionRuntimeLabel)(runtimeSource);
     return 'API Key';
 }
+function resolveDirectCliSessionTransport(providerName, enableCliSessionEpoch, localStorageMode) {
+    if (!enableCliSessionEpoch)
+        return 'none';
+    if (providerName === 'codex-cli' && localStorageMode)
+        return 'codex-app-server';
+    return 'pty';
+}
 function runtimePayloadForDisplay(providerName, model, runtimeMode, runtimeSource) {
     return {
         mode: runtimeMode,
@@ -4783,6 +7425,9 @@ function configuredRuntimeLabelForProfile(profile) {
 async function buildChatRuntimeForTest(profile) {
     return buildChatRuntime(profile);
 }
+function resolveDirectCliSessionTransportForTest(providerName, enableCliSessionEpoch, localStorageMode) {
+    return resolveDirectCliSessionTransport(providerName, enableCliSessionEpoch, localStorageMode);
+}
 function buildConfiguredMessageModel(profile) {
     if (!profile)
         return '';
@@ -4808,100 +7453,206 @@ 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 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'
+        : 'cli_recurring_single';
+    const lines = [
+        '[Bot Identity]',
+        input.soulMd.trim(),
+        '',
+        'If the provided context is not enough, use available tools to get what you need.',
+        '',
+        '[Response Style]',
+        'Write in short readable paragraphs.',
+        'Put a blank line between distinct ideas.',
+        'Use bullets when listing findings, steps, or issues.',
+        'Do not return one dense wall of text.',
+        'Keep progress updates compact and factual.',
+        'Do not mention bootstrap files, history files, file paths, or that you loaded context unless the user explicitly asks about them.',
+    ];
+    if (useCompletionSentinel) {
+        lines.push(completion_marker_1.CLI_COMPLETION_INSTRUCTION);
+    }
+    const projectLines = [];
+    if (input.projectName)
+        projectLines.push(`Project: ${input.projectName}`);
+    if (input.topicTitle)
+        projectLines.push(`Topic: ${input.topicTitle}`);
+    projectLines.push(`Workspace: ${input.workspacePath || '(project folder not configured)'}`);
+    if (input.timezone)
+        projectLines.push(`Timezone: ${input.timezone}`);
+    lines.push('', '[Project Overview]', ...projectLines);
+    const toolManifest = isCliProvider ? '' : buildLocalDesktopToolManifest(input.availableTools, contract);
+    if (toolManifest) {
+        lines.push('', '[Available Tools]', toolManifest);
+        if (/\bsearch_local_memory\b|\bsearch_memory\b/i.test(toolManifest)) {
+            lines.push('If the user refers to prior project or conversation context that is not included here, search with these tools first.');
+        }
+    }
+    // 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('', 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);
+        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;
+    if (useCliHistoryBootstrap && input.cliHistoryFilePath) {
+        effectiveUserPrompt = [
+            `Please read the history file at: ${input.cliHistoryFilePath}`,
+            'Use it for context only.',
+            'There is no need to mention the file, its path, or that you loaded context unless the user explicitly asks about it.',
+            'Then respond to the user request below.',
+            '',
+            'Current user request:',
+            input.userPrompt,
+        ].join('\n');
+    }
+    if (useCompletionSentinel) {
+        effectiveUserPrompt = [
+            effectiveUserPrompt,
+            '',
+            `Required final line when the response is fully complete: ${completion_marker_1.CLI_COMPLETION_SENTINEL}`,
+            'Do not mention or explain the tag.',
+        ].join('\n');
+    }
+    return {
+        systemPrompt: lines.join('\n').trim(),
+        userPrompt: effectiveUserPrompt,
+    };
+}
+function buildLocalDesktopDirectPromptForTest(input) {
+    return buildLocalDesktopDirectPrompt(input);
+}
+function resolveLocalDesktopPromptContextForTest(input) {
+    return resolveLocalDesktopPromptContext(input);
+}
+function shouldSkipFreshCliBootstrapForTest(input) {
+    return shouldSkipFreshCliBootstrap(input);
+}
+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'
+        ? availableTools
+        : availableTools.filter((tool) => ['search_local_memory', 'search_memory'].includes(tool.name));
+    return selectedTools
+        .map((tool) => `- ${tool.name}: ${tool.description}`)
+        .join('\n')
+        .trim();
+}
 function classifyOrchestratorProgress(status) {
     const trimmed = String(status || '').trim();
     if (!trimmed)
         return {};
     const match = trimmed.match(/^([a-z][a-z0-9_ -]{1,48})::\s*(.+)$/i);
-    if (!match) {
-        return {
-            activityText: trimmed.replace(/\*\*/g, '').replace(/\s+/g, ' ').trim(),
-            chatText: trimmed,
-        };
-    }
+    if (!match)
+        return {};
     const roleName = match[1].trim().toLowerCase();
     const detail = match[2].trim();
-    if (roleName === 'intent_classifier') {
-        if (/decomposing request|classifying request/i.test(detail)) {
-            return { activityText: 'Classifying request', chatText: 'Classifying request..' };
-        }
-        if (/routed single intent as (.+)$/i.test(detail)) {
-            const classifiedAs = detail.replace(/^routed single intent as\s+/i, '').trim();
-            return { activityText: `Classified as ${classifiedAs}`, chatText: `Classified as ${classifiedAs}..` };
-        }
-        const orderedCount = detail.match(/decomposed request into (\d+) ordered intents/i);
-        if (orderedCount) {
-            return { activityText: `${orderedCount[1]} ordered steps established` };
-        }
+    if (/(intent_classifier|orchestration_planner|dispatch_controller|policy_interpreter|verifier)/i.test(roleName)) {
         return {};
     }
-    if (roleName === 'orchestration_planner') {
-        if (/planning multi-step workflow/i.test(detail)) {
-            return { activityText: 'Planning multi-step workflow', chatText: 'Planning multi-step workflow' };
+    if (roleName === 'orchestrator') {
+        if (/^understanding request$/i.test(detail)
+            || /^still understanding the request$/i.test(detail)
+            || /is working on the request/i.test(detail)
+            || /completed the request/i.test(detail)) {
+            return {};
         }
-        const prepared = detail.match(/prepared (\d+) workflow steps/i);
-        if (prepared) {
-            return {
-                activityText: `${prepared[1]} workflow steps established`,
-                chatText: `${prepared[1]} workflow steps established`,
-            };
+        if (/hit an issue while working/i.test(detail)) {
+            return { activityText: detail };
         }
-        return {};
-    }
-    if (roleName === 'dispatch_controller') {
-        if (/still working:/i.test(detail))
-            return {};
-        if (/locked .* execution/i.test(detail))
-            return {};
-        return { activityText: detail };
-    }
-    if (roleName === 'orchestrator') {
-        return {
-            activityText: detail,
-        };
-    }
-    if (roleName === 'policy_interpreter' || roleName === 'verifier') {
-        return { activityText: detail };
     }
     return {};
 }
 /** Derive user-visible interim messages from orchestrator progress for key transitions */
 function deriveOrchestratorInterimMessage(status) {
-    const trimmed = String(status || '').trim();
-    const match = trimmed.match(/^([a-z][a-z0-9_ -]{1,48})::\s*(.+)$/i);
-    if (!match)
-        return null;
-    const roleName = match[1].trim().toLowerCase();
-    const detail = match[2].trim();
+    void status;
     // Intent classification → "I'll analyze this request..."
-    if (roleName === 'intent_classifier') {
-        if (/classif/i.test(detail))
-            return null; // skip classification (too early)
-        if (/decomposed request into (\d+)/i.test(detail)) {
-            const m = detail.match(/(\d+)/);
-            return `I've broken this down into ${m?.[1] || 'multiple'} steps. Let me work through them...`;
-        }
-        if (/routed single intent/i.test(detail))
-            return null; // handled by dispatch
-    }
     // Dispatch → "I'm sending this to [Bot Name]..."
-    if (roleName === 'dispatch_controller') {
-        const routingMatch = detail.match(/routing (?:direct )?request to (.+)/i);
-        if (routingMatch) {
-            return `Sending this to ${routingMatch[1]}...`;
-        }
-        const connectMatch = detail.match(/connecting request to (.+)/i);
-        if (connectMatch) {
-            return `Connecting to ${connectMatch[1]}...`;
-        }
-    }
     // Orchestration planner → workflow planning
-    if (roleName === 'orchestration_planner') {
-        const stepsMatch = detail.match(/prepared (\d+) workflow steps/i);
-        if (stepsMatch) {
-            return `I've prepared a ${stepsMatch[1]}-step workflow. Starting execution...`;
-        }
-    }
     return null;
 }
 function resolveCliNameForProvider(providerName) {
@@ -4912,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))
@@ -4931,14 +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;
@@ -5024,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 */ }