botmux 2.9.0 → 2.9.2

package/dist/core/worker-pool.js

@@ -12,12 +12,18 @@ import { randomBytes } from 'node:crypto';
 import { config } from '../config.js';
 import * as sessionStore from '../services/session-store.js';
 import { persistStreamCardState } from './session-manager.js';
-import { updateMessage, MessageWithdrawnError } from '../im/lark/client.js';
+import { updateMessage, deleteMessage, MessageWithdrawnError } from '../im/lark/client.js';
 import { buildStreamingCard, buildSessionCard, buildTuiPromptCard, buildTuiPromptResolvedCard, getCliDisplayName } from '../im/lark/card-builder.js';
+import { loadFrozenCards, saveFrozenCards } from '../services/frozen-card-store.js';
 import { logger } from '../utils/logger.js';
 import { createCliAdapterSync } from '../adapters/cli/registry.js';
+import { claudeJsonlPathForSession } from '../adapters/cli/claude-code.js';
+import { buildMarkdownCard, buildContextualReplyCard } from '../im/lark/md-card.js';
 import { TmuxBackend } from '../adapters/backend/tmux-backend.js';
 import { getBot, getAllBots } from '../bot-registry.js';
+import { dashboardEventBus } from './dashboard-events.js';
+import { composeRowFromActive } from './dashboard-rows.js';
+import { sessionKey, sessionAnchorId } from './types.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 let callbacks;
@@ -32,14 +38,124 @@ function requireCallbacks() {
         throw new Error('WorkerPool not initialised — call initWorkerPool() first');
     return callbacks;
 }
+// ─── Active session registry (daemon-owned, accessor for IPC) ───────────────
+// The activeSessions Map physically lives in daemon.ts. To let the dashboard
+// IPC server (and other modules) read it without reaching back into daemon, the
+// daemon registers its Map here at boot. Helpers below return a snapshot or
+// linear-scan by sessionId.
+let activeSessionsRegistry;
+export function setActiveSessionsRegistry(m) {
+    activeSessionsRegistry = m;
+}
+export function listActiveSessions() {
+    return activeSessionsRegistry ? [...activeSessionsRegistry.values()] : [];
+}
+/** Linear-scan lookup of the active-sessions Map by `Session.sessionId`.
+ *  The Map's actual key is `sessionKey(rootId, larkAppId)` (composite), so we
+ *  cannot use Map.get here. */
+export function findActiveBySessionId(sessionId) {
+    if (!activeSessionsRegistry)
+        return undefined;
+    for (const s of activeSessionsRegistry.values())
+        if (s.session.sessionId === sessionId)
+            return s;
+    return undefined;
+}
+/** Direct access to the active-sessions Map. Reserved for callers that need
+ *  to mutate (e.g. resumeSession reactivating a closed record); read-only
+ *  callers should prefer listActiveSessions / findActiveBySessionId. */
+export function getActiveSessionsRegistry() {
+    return activeSessionsRegistry;
+}
 // ─── Helpers ────────────────────────────────────────────────────────────────
 function tag(ds) {
     return ds.session.sessionId.substring(0, 8);
 }
+const WORKER_ERROR_MARKER = '[botmux-worker-error]';
+function logWorkerStderr(t, line) {
+    if (!line)
+        return;
+    const taggedLine = `[${t}:err] ${line}`;
+    if (line.includes(WORKER_ERROR_MARKER)) {
+        logger.error(taggedLine);
+        return;
+    }
+    logger.info(taggedLine);
+}
 // Sentinel value for streamCardId while a POST (new card) is in-flight.
 // Prevents duplicate card POSTs when multiple screen_updates arrive before
 // the first POST returns a real message_id.
 export const CARD_POSTING_SENTINEL = '__posting__';
+/**
+ * Move the current streaming card into `frozenCards` without freezing it
+ * cosmetically. The next successful card POST will sweep it via
+ * `recallFrozenCards`. Used on paths that bypass the normal freeze step
+ * (worker dead before a new turn, repo switch tearing down the session) so
+ * we never delete the only visible card before its successor exists — if
+ * fork / worker_ready / POST fails, the parked card stays in the thread.
+ *
+ * Lazy-loads `frozenCards` from disk if the in-memory Map is missing
+ * (post daemon-restart, before any card-handler action has loaded it).
+ * Without this, parking would synthesize an empty Map and the subsequent
+ * `saveFrozenCards` would overwrite earlier turns' entries on disk —
+ * stranding their cards in the thread with no way to recall them.
+ *
+ * No-op when there is no live card to park.
+ */
+export function parkStreamCard(ds) {
+    if (!ds.streamCardId || ds.streamCardId === CARD_POSTING_SENTINEL)
+        return;
+    if (!ds.streamCardNonce)
+        return;
+    if (!ds.frozenCards)
+        ds.frozenCards = loadFrozenCards(ds.session.sessionId);
+    ds.frozenCards.set(ds.streamCardNonce, {
+        messageId: ds.streamCardId,
+        content: ds.lastScreenContent ?? '',
+        title: ds.currentTurnTitle ?? '',
+        displayMode: ds.displayMode ?? 'hidden',
+        imageKey: ds.currentImageKey,
+    });
+    saveFrozenCards(ds.session.sessionId, ds.frozenCards);
+}
+/**
+ * Delete previously-frozen streaming cards from Lark and clear the cache.
+ * Called whenever a new streaming card becomes the active one — old turns'
+ * cards just add visual clutter when scrolling thread history.
+ *
+ * Lazy-loads `frozenCards` from disk if the in-memory Map is missing
+ * (post daemon-restart). Best-effort delete; failures (already withdrawn,
+ * expired) are non-fatal.
+ *
+ * Skips any entry whose messageId matches `ds.streamCardId` — guards the
+ * daemon-restart window where a turn was frozen (entry persisted to disk)
+ * but a new card was never POSTed before the crash. After restart the same
+ * messageId is the live `streamCardId` again, and recalling it would delete
+ * the only card the user can see.
+ */
+export function recallFrozenCards(ds) {
+    if (!ds.frozenCards)
+        ds.frozenCards = loadFrozenCards(ds.session.sessionId);
+    if (ds.frozenCards.size === 0)
+        return;
+    const activeId = ds.streamCardId && ds.streamCardId !== CARD_POSTING_SENTINEL
+        ? ds.streamCardId
+        : undefined;
+    const targets = [];
+    for (const [nonce, fc] of [...ds.frozenCards.entries()]) {
+        if (activeId && fc.messageId === activeId)
+            continue;
+        targets.push(fc.messageId);
+        ds.frozenCards.delete(nonce);
+    }
+    if (targets.length === 0)
+        return;
+    saveFrozenCards(ds.session.sessionId, ds.frozenCards);
+    for (const messageId of targets) {
+        deleteMessage(ds.larkAppId, messageId).catch(() => { });
+    }
+    logger.info(`[${tag(ds)}] Recalled ${targets.length} previous streaming card(s)`);
+}
 // ─── Card PATCH serialization queue ─────────────────────────────────────────
 // Only one PATCH in-flight at a time per session. New PATCHes queue on
 // ds.pendingCardJson (latest wins). When the in-flight PATCH completes,
@@ -74,9 +190,21 @@ function flushCardPatch(ds) {
     updateMessage(ds.larkAppId, cardId, json)
         .catch(err => {
         if (err instanceof MessageWithdrawnError) {
-            logger.warn(`[${tag(ds)}] Stream card withdrawn, clearing reference`);
-            ds.streamCardId = undefined;
-            persistStreamCardState(ds);
+            // Only clear streamCardId when the withdrawn message is still the
+            // active one. With auto-recall a new turn may have advanced
+            // ds.streamCardId past `cardId` while this PATCH was in flight (the
+            // recall on the new POST deletes the previous card, which surfaces
+            // here as MessageWithdrawnError). Clearing unconditionally would
+            // forget the live new card and trigger a duplicate POST on the next
+            // screen_update.
+            if (ds.streamCardId === cardId) {
+                logger.warn(`[${tag(ds)}] Stream card withdrawn, clearing reference`);
+                ds.streamCardId = undefined;
+                persistStreamCardState(ds);
+            }
+            else {
+                logger.debug(`[${tag(ds)}] Stale card ${cardId.substring(0, 12)} withdrawn (current: ${ds.streamCardId?.substring(0, 12) ?? 'none'})`);
+            }
             return;
         }
         logger.debug(`[${tag(ds)}] Failed to update streaming card: ${err}`);
@@ -228,6 +356,51 @@ export function killWorker(ds) {
     ds.workerPort = null;
     ds.workerToken = null;
 }
+// ─── Idempotent session close (dashboard IPC) ───────────────────────────────
+/**
+ * Idempotent close: kill worker if alive, mark Session status='closed' + closedAt,
+ * publish session.exited (if a live worker was killed) and session.update
+ * (if the persistence row transitioned to closed).
+ *
+ * Calling this on an unknown sessionId, an already-closed session, or a session
+ * whose worker died asynchronously must still resolve with `{ ok: true }`.
+ */
+export async function closeSession(sessionId) {
+    const ds = findActiveBySessionId(sessionId);
+    let killedLive = false;
+    if (ds) {
+        killWorker(ds);
+        activeSessionsRegistry?.delete(sessionKey(sessionAnchorId(ds), ds.larkAppId));
+        killedLive = true;
+        if (!ds.exitEventEmitted) {
+            ds.exitEventEmitted = true;
+            dashboardEventBus.publish({
+                type: 'session.exited',
+                body: { sessionId, reason: 'dashboard_close' },
+            });
+        }
+    }
+    // Persistence path — load → mark closed → save (delegated to sessionStore).
+    const stored = sessionStore.getSession(sessionId);
+    const wasOpen = !!stored && stored.status !== 'closed';
+    if (wasOpen) {
+        sessionStore.closeSession(sessionId);
+        const after = sessionStore.getSession(sessionId);
+        dashboardEventBus.publish({
+            type: 'session.update',
+            body: {
+                sessionId,
+                patch: {
+                    status: 'closed',
+                    closedAt: after?.closedAt ? Date.parse(after.closedAt) : Date.now(),
+                },
+            },
+        });
+    }
+    // alreadyClosed = nothing happened on either path.
+    const alreadyClosed = !killedLive && !wasOpen;
+    return { ok: true, alreadyClosed };
+}
 // ─── Fork worker ────────────────────────────────────────────────────────────
 export function forkWorker(ds, prompt, resume = false) {
     const cb = requireCallbacks();
@@ -264,13 +437,18 @@ export function forkWorker(ds, prompt, resume = false) {
             ...process.env,
             PATH: pathWithBotmux,
             CLAUDECODE: undefined,
-            BOTMUX: '1', // Inherited by CLI → MCP server for session detection
+            BOTMUX: '1', // Marker so user scripts/skills can detect a botmux-spawned CLI
             SESSION_DATA_DIR: config.session.dataDir,
             LARK_APP_ID: botCfg.larkAppId,
             LARK_APP_SECRET: botCfg.larkAppSecret,
         },
     });
-    // Pipe worker stdout/stderr to daemon logger
+    // Pipe worker stdout/stderr to daemon logger.
+    // Both go through logger.info → daemon.log (not error.log). Worker stderr
+    // is NOT necessarily an error: CLI adapters (claude, codex, etc.) write
+    // progress, version banners, deprecation warnings, etc. there. The line
+    // is still visible (tagged `:err`) for triage. Real worker faults arrive
+    // separately via the IPC `Worker error` branch and stay as logger.error.
     worker.stdout?.on('data', (data) => {
         for (const line of data.toString().split('\n')) {
             const trimmed = line.trim();
@@ -280,9 +458,7 @@ export function forkWorker(ds, prompt, resume = false) {
     });
     worker.stderr?.on('data', (data) => {
         for (const line of data.toString().split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed)
-                logger.error(`[${t}:worker] ${trimmed}`);
+            logWorkerStderr(t, line.trim());
         }
     });
     // Send init config — use per-bot settings
@@ -290,13 +466,14 @@ export function forkWorker(ds, prompt, resume = false) {
         type: 'init',
         sessionId: ds.session.sessionId,
         chatId: ds.chatId,
-        rootMessageId: ds.session.rootMessageId,
+        rootMessageId: sessionAnchorId(ds),
         workingDir: cwd,
         cliId: botCfg.cliId,
         cliPathOverride: botCfg.cliPathOverride,
         backendType: botCfg.backendType ?? config.daemon.backendType,
         prompt,
         resume,
+        cliSessionId: ds.session.cliSessionId,
         ownerOpenId: ds.ownerOpenId,
         webPort: ds.session.webPort,
         larkAppId: botCfg.larkAppId,
@@ -311,8 +488,23 @@ export function forkWorker(ds, prompt, resume = false) {
     ds.worker = worker;
     ds.spawnedAt = Date.now();
     ds.cliVersion = currentCliVersion;
+    // Stamp cliId on the persisted session so the dashboard can show a CLI badge
+    // even after the session is closed. Subsequent updateSession spreads carry
+    // this field forward for free.
+    if (ds.session.cliId !== botCfg.cliId) {
+        ds.session.cliId = botCfg.cliId;
+        sessionStore.updateSession(ds.session);
+    }
     sessionStore.updateSessionPid(ds.session.sessionId, worker.pid ?? null);
     logger.info(`[${t}] Worker forked (pid: ${worker.pid}, active: ${cb.getActiveCount()})`);
+    // Reset the exit-emit flag for the freshly spawned worker so a subsequent
+    // exit publishes again (the previous lifecycle's flag would otherwise mask it).
+    ds.exitEventEmitted = false;
+    // Notify dashboard SSE subscribers a new session is live.
+    dashboardEventBus.publish({
+        type: 'session.spawned',
+        body: { session: composeRowFromActive(ds) },
+    });
 }
 // ─── Shared worker IPC handler ──────────────────────────────────────────────
 function setupWorkerHandlers(ds, worker) {
@@ -320,9 +512,15 @@ function setupWorkerHandlers(ds, worker) {
     const t = tag(ds);
     const bot = getBot(ds.larkAppId);
     const botCfg = bot.config;
-    // Adopt mode flags — computed once, used in all buildStreamingCard calls
+    // Adopt mode flags — computed once, used in all buildStreamingCard calls.
+    // Bridge mode (the v3 default for /adopt) hides the legacy takeover
+    // button: the model never sees botmux, daemon harvests final output via
+    // the transcript watcher, and the old takeover path would SIGKILL the
+    // user's original CLI 1.5s after fork — incompatible with bridge intent.
+    // Explicit takeover will be re-introduced as `/adopt --takeover` in a
+    // follow-up patch with safe semantics (no implicit kill).
     const isAdopt = !!ds.adoptedFrom;
-    const showTakeover = isAdopt && !!ds.adoptedFrom?.sessionId;
+    const showTakeover = false;
     worker.on('message', async (msg) => {
         switch (msg.type) {
             case 'ready': {
@@ -334,6 +532,14 @@ function setupWorkerHandlers(ds, worker) {
                 const readOnlyUrl = `http://${config.web.externalHost}:${msg.port}`;
                 const writeUrl = `${readOnlyUrl}?token=${msg.token}`;
                 logger.info(`[${t}] Worker ready, terminal at ${readOnlyUrl}`);
+                // Dashboard: surface the new xterm port so the live terminal link works.
+                dashboardEventBus.publish({
+                    type: 'session.update',
+                    body: {
+                        sessionId: ds.session.sessionId,
+                        patch: { webPort: msg.port },
+                    },
+                });
                 // If a previous streaming card survived (e.g. daemon restart), try to
                 // PATCH it with the new "starting" state instead of POSTing a fresh card.
                 // ds.streamCardPending forces a new card (e.g. mid-session repo switch
@@ -347,13 +553,17 @@ function setupWorkerHandlers(ds, worker) {
                         // Reuse persisted nonce so existing card buttons (toggle/etc) keep working.
                         if (!ds.streamCardNonce)
                             ds.streamCardNonce = randomBytes(4).toString('hex');
-                        const streamCardJson = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readOnlyUrl, initTitle, ds.lastScreenContent ?? '', 'starting', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                        const streamCardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, initTitle, ds.lastScreenContent ?? '', 'starting', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
                         await updateMessage(ds.larkAppId, restoredCardId, streamCardJson);
                         persistStreamCardState(ds);
                         // Re-sync worker's display mode (it starts fresh in 'hidden')
                         if (ds.worker && ds.displayMode && ds.displayMode !== 'hidden') {
                             ds.worker.send({ type: 'set_display_mode', mode: ds.displayMode });
                         }
+                        // The restored card is now the active one — withdraw any cards
+                        // frozen before the daemon went down so they don't pile up in the
+                        // thread on each restart.
+                        recallFrozenCards(ds);
                         logger.info(`[${t}] Reused existing streaming card ${restoredCardId.substring(0, 12)} after worker (re)start`);
                         break;
                     }
@@ -371,9 +581,13 @@ function setupWorkerHandlers(ds, worker) {
                 try {
                     ds.streamCardNonce = randomBytes(4).toString('hex');
                     const initTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(botCfg.cliId);
-                    const streamCardJson = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readOnlyUrl, initTitle, '', 'starting', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
-                    ds.streamCardId = await cb.sessionReply(ds.session.rootMessageId, streamCardJson, 'interactive', ds.larkAppId);
+                    const streamCardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, initTitle, '', 'starting', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                    ds.streamCardId = await cb.sessionReply(sessionAnchorId(ds), streamCardJson, 'interactive', ds.larkAppId);
                     persistStreamCardState(ds);
+                    // New card is live — recall any cards frozen by previous turns.
+                    // Done after `streamCardId` is committed so we never delete the old
+                    // card without a successor visible to the user.
+                    recallFrozenCards(ds);
                 }
                 catch (err) {
                     if (err instanceof MessageWithdrawnError) {
@@ -388,8 +602,8 @@ function setupWorkerHandlers(ds, worker) {
                     persistStreamCardState(ds);
                     // Fallback: send static session card
                     try {
-                        const cardJson = buildSessionCard(ds.session.sessionId, ds.session.rootMessageId, readOnlyUrl, ds.session.title || getCliDisplayName(botCfg.cliId), botCfg.cliId);
-                        await cb.sessionReply(ds.session.rootMessageId, cardJson, 'interactive', ds.larkAppId);
+                        const cardJson = buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, ds.session.title || getCliDisplayName(botCfg.cliId), botCfg.cliId, undefined, !!ds.adoptedFrom);
+                        await cb.sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId);
                     }
                     catch (fallbackErr) {
                         if (fallbackErr instanceof MessageWithdrawnError) {
@@ -413,6 +627,23 @@ function setupWorkerHandlers(ds, worker) {
                 const prevStatus = ds.lastScreenStatus;
                 ds.lastScreenContent = msg.content;
                 ds.lastScreenStatus = msg.status;
+                // Dashboard: publish a patch only when status truly transitioned, so
+                // SSE clients reflect real state changes (starting → working → idle)
+                // without flooding on every PTY tick. The screen analyzer is the
+                // upstream debouncer — by the time we get here, status flips are
+                // already coarse-grained.
+                if (prevStatus !== msg.status) {
+                    dashboardEventBus.publish({
+                        type: 'session.update',
+                        body: {
+                            sessionId: ds.session.sessionId,
+                            patch: {
+                                status: ds.lastScreenStatus,
+                                lastMessageAt: ds.lastMessageAt,
+                            },
+                        },
+                    });
+                }
                 const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
                 const turnTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(botCfg.cliId);
                 const mode = ds.displayMode ?? 'hidden';
@@ -428,13 +659,22 @@ function setupWorkerHandlers(ds, worker) {
                     // New turn → image_key from previous turn no longer valid
                     if (isNewTurn)
                         ds.currentImageKey = undefined;
-                    const cardJson = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, turnTitle, isNewTurn ? '' : msg.content, msg.status, botCfg.cliId, mode, ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, isNewTurn ? '' : msg.content, msg.status, botCfg.cliId, mode, ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
                     // Mark POST in-flight so subsequent screen_updates are dropped,
                     // not POSTed as duplicate cards.
                     ds.streamCardPending = false;
                     ds.streamCardId = CARD_POSTING_SENTINEL;
-                    cb.sessionReply(ds.session.rootMessageId, cardJson, 'interactive', ds.larkAppId)
-                        .then(msgId => { ds.streamCardId = msgId; persistStreamCardState(ds); })
+                    cb.sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId)
+                        .then(msgId => {
+                        ds.streamCardId = msgId;
+                        persistStreamCardState(ds);
+                        // New card live — recall any cards parked by previous turns
+                        // (user message, bot @mention, adopt-bridge new turn, etc.).
+                        // This is the main turn-to-turn POST path; without recall here,
+                        // every long session would leak old streaming cards into the
+                        // thread.
+                        recallFrozenCards(ds);
+                    })
                         .catch(err => {
                         if (err instanceof MessageWithdrawnError) {
                             logger.warn(`[${t}] Root message withdrawn, closing stale session`);
@@ -453,7 +693,7 @@ function setupWorkerHandlers(ds, worker) {
                     const statusChanged = prevStatus !== msg.status;
                     if (!statusChanged)
                         break;
-                    const cardJson = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, turnTitle, msg.content, msg.status, botCfg.cliId, mode, ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, msg.content, msg.status, botCfg.cliId, mode, ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
                     scheduleCardPatch(ds, cardJson);
                 }
                 break;
@@ -472,7 +712,7 @@ function setupWorkerHandlers(ds, worker) {
                     break;
                 const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
                 const turnTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(botCfg.cliId);
-                const cardJson = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, turnTitle, ds.lastScreenContent ?? '', msg.status, botCfg.cliId, 'screenshot', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, ds.lastScreenContent ?? '', msg.status, botCfg.cliId, 'screenshot', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
                 scheduleCardPatch(ds, cardJson);
                 break;
             }
@@ -487,10 +727,20 @@ function setupWorkerHandlers(ds, worker) {
                 ds.tuiPromptOptions = msg.options;
                 ds.tuiPromptMultiSelect = msg.multiSelect;
                 ds.tuiToggledIndices = [];
+                const prevTuiTurnTitle = ds.currentTurnTitle;
                 ds.currentTurnTitle = msg.description; // store for card PATCH on toggle
+                if (prevTuiTurnTitle !== ds.currentTurnTitle) {
+                    dashboardEventBus.publish({
+                        type: 'session.update',
+                        body: {
+                            sessionId: ds.session.sessionId,
+                            patch: { title: ds.currentTurnTitle },
+                        },
+                    });
+                }
                 try {
-                    const cardJson = buildTuiPromptCard(ds.session.rootMessageId, ds.session.sessionId, msg.description, msg.options, msg.multiSelect);
-                    const cardMsgId = await cb.sessionReply(ds.session.rootMessageId, cardJson, 'interactive', ds.larkAppId);
+                    const cardJson = buildTuiPromptCard(sessionAnchorId(ds), ds.session.sessionId, msg.description, msg.options, msg.multiSelect);
+                    const cardMsgId = await cb.sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId);
                     ds.tuiPromptCardId = cardMsgId;
                 }
                 catch (err) {
@@ -519,14 +769,21 @@ function setupWorkerHandlers(ds, worker) {
                     if (ds.streamCardId && ds.workerPort) {
                         const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
                         const turnTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(botCfg.cliId);
-                        const frozenCard = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, turnTitle, ds.lastScreenContent ?? '', 'idle', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
+                        const frozenCard = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, ds.lastScreenContent ?? '', 'idle', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isAdopt, showTakeover);
                         scheduleCardPatch(ds, frozenCard);
                     }
                     killWorker(ds);
-                    try {
-                        await cb.sessionReply(ds.session.rootMessageId, '\u23cf 已采纳的 CLI 会话已退出', 'text', ds.larkAppId);
+                    // Skip the exit notice when the session was already closed via the
+                    // ⏏ card button — card-handler already posted "已断开，原 CLI 会话
+                    // 不受影响" right before killing us, so another exit message here
+                    // is just noise. Natural exits (user typed `exit`, CLI crashed)
+                    // leave status='active' and still get the notice.
+                    if (ds.session.status !== 'closed') {
+                        try {
+                            await cb.sessionReply(sessionAnchorId(ds), '\u23cf 已采纳的 CLI 会话已退出', 'text', ds.larkAppId);
+                        }
+                        catch { /* best effort */ }
                     }
-                    catch { /* best effort */ }
                     break;
                 }
                 // Rate-limit auto-restart to prevent crash loops
@@ -544,14 +801,14 @@ function setupWorkerHandlers(ds, worker) {
                     if (ds.streamCardId && ds.workerPort) {
                         const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
                         const turnTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(botCfg.cliId);
-                        const frozenCard = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, turnTitle, ds.lastScreenContent ?? '', 'idle', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey);
+                        const frozenCard = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, ds.lastScreenContent ?? '', 'idle', botCfg.cliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey);
                         scheduleCardPatch(ds, frozenCard);
                     }
                     // Kill the worker process to free resources
                     killWorker(ds);
                     const cliName = getCliDisplayName(botCfg.cliId);
                     try {
-                        await cb.sessionReply(ds.session.rootMessageId, `\u26a0\ufe0f ${cliName} 在 1 分钟内崩溃 ${rc.count} 次，已停止自动重启。发消息可触发重新启动。`, 'text', ds.larkAppId);
+                        await cb.sessionReply(sessionAnchorId(ds), `\u26a0\ufe0f ${cliName} 在 1 分钟内崩溃 ${rc.count} 次，已停止自动重启。发消息可触发重新启动。`, 'text', ds.larkAppId);
                     }
                     catch (replyErr) {
                         if (replyErr instanceof MessageWithdrawnError) {
@@ -575,13 +832,55 @@ function setupWorkerHandlers(ds, worker) {
             case 'user_notify': {
                 logger.warn(`[${t}] Worker user_notify: ${msg.message}`);
                 try {
-                    await cb.sessionReply(ds.session.rootMessageId, msg.message, 'text', ds.larkAppId);
+                    await cb.sessionReply(sessionAnchorId(ds), msg.message, 'text', ds.larkAppId);
                 }
                 catch (err) {
                     logger.error(`[${t}] Failed to deliver user_notify to Lark: ${err.message}`);
                 }
                 break;
             }
+            case 'final_output': {
+                // Adopt-bridge: worker harvested the assistant turn from Claude Code's
+                // transcript JSONL and forwarded it to us. Dedup by lastUuid so a
+                // re-drain after a noisy idle doesn't re-send the same answer.
+                if (!msg.content || !msg.content.trim())
+                    break;
+                if (msg.lastUuid && ds.lastBridgeEmittedUuid === msg.lastUuid) {
+                    logger.debug(`[${t}] final_output deduped (uuid ${msg.lastUuid.substring(0, 8)})`);
+                    break;
+                }
+                // Worker pops the turn off its queue right after emit, so it will
+                // NOT re-send this payload on its own. Daemon owns retry on
+                // transient Lark failures.
+                deliverFinalOutput(ds, msg, t, 0);
+                break;
+            }
+            case 'adopt_preamble': {
+                // Adopt-bridge: surface the last completed user/assistant exchange
+                // from the adopted CLI session so the Lark thread has context to
+                // continue from. Best-effort — failure here just means the user
+                // won't see the preamble; adopt itself isn't blocked. Card chrome
+                // matches the regular markdown-card path (schema 2.0 + footer) so
+                // the assistant body renders with proper code blocks / tables /
+                // lists instead of arriving as a wall of plain text.
+                if (!ds.adoptedFrom) {
+                    logger.warn(`[${t}] Ignored adopt_preamble from non-adopt worker`);
+                    break;
+                }
+                if (!msg.userText.trim() && !msg.assistantText.trim())
+                    break;
+                const cardJson = buildContextualReplyCard({
+                    title: '📜 /adopt 前最后一轮',
+                    userText: msg.userText,
+                    assistantText: msg.assistantText,
+                    assistantLabel: getCliDisplayName(botCfg.cliId),
+                    recipientOpenId: ds.session.ownerOpenId,
+                });
+                cb.sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId).catch((err) => {
+                    logger.warn(`[${t}] Failed to deliver adopt_preamble to Lark: ${err.message}`);
+                });
+                break;
+            }
         }
     });
     worker.on('exit', (code) => {
@@ -592,10 +891,91 @@ function setupWorkerHandlers(ds, worker) {
             ds.worker = null;
             ds.workerPort = null;
         }
+        // Notify dashboard, but only once per session lifecycle. The
+        // dashboard-driven `closeSession()` path also publishes; whichever
+        // fires first wins, the other's emit is suppressed.
+        if (!ds.exitEventEmitted) {
+            ds.exitEventEmitted = true;
+            dashboardEventBus.publish({
+                type: 'session.exited',
+                body: {
+                    sessionId: ds.session.sessionId,
+                    reason: code === 0 ? 'graceful' : `exit_code_${code}`,
+                },
+            });
+        }
     });
 }
+// ─── Bridge final-output delivery (with retry) ──────────────────────────────
+const FINAL_OUTPUT_RETRY_BACKOFF_MS = [0, 5000, 15000]; // immediate, +5s, +15s
+/** Deliver a bridge `final_output` to Lark. The worker emits each turn
+ *  exactly once (it pops the turn off its queue at emit time), so the
+ *  daemon owns retries on transient failures. After 3 attempts we log
+ *  and give up — the user's answer is lost; better than leaking memory
+ *  via an unbounded retry loop. */
+function deliverFinalOutput(ds, msg, t, attempt) {
+    const cb = requireCallbacks();
+    setTimeout(async () => {
+        // Guard: if the user closed the session (or it was torn down for any
+        // other reason) between attempts, don't post a stale final answer to
+        // a closed thread.
+        if (ds.session.status === 'closed') {
+            logger.info(`[${t}] Bridge final_output abandoned — session closed (turn ${msg.turnId.substring(0, 8)})`);
+            return;
+        }
+        try {
+            // Wrap the model's reply in the same card chrome `botmux send` uses
+            // (schema 2.0 + footer with botmux link + 发送给 owner) so a turn
+            // delivered via this fallback path looks identical in the Lark thread
+            // to one the model sent itself. Markdown rendering, tables, code
+            // blocks all flow through the shared `buildCardBodyElements`.
+            //
+            // Local-turn variants (kind = 'local-turn' / 'local-turn-headless')
+            // also surface the user-side prompt synced from the adopted pane;
+            // they use the contextual card so the user prompt sits in a
+            // blockquote and only the assistant body goes through full markdown
+            // rendering.
+            const cardJson = msg.kind === 'local-turn' || msg.kind === 'local-turn-headless'
+                ? buildContextualReplyCard({
+                    title: msg.kind === 'local-turn-headless'
+                        ? '🖥️ 终端本地对话续传（daemon 重启时模型正在输出）'
+                        : '🖥️ 终端本地对话（在 adopted pane 中直接输入，已同步至飞书）',
+                    userText: msg.kind === 'local-turn' ? msg.userText ?? '' : undefined,
+                    assistantText: msg.content,
+                    assistantLabel: getCliDisplayName(getBot(ds.larkAppId).config.cliId),
+                    recipientOpenId: ds.session.ownerOpenId,
+                })
+                : buildMarkdownCard(msg.content, ds.session.ownerOpenId);
+            await cb.sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId);
+            ds.lastBridgeEmittedUuid = msg.lastUuid;
+            logger.info(`[${t}] Bridge final_output forwarded (turn ${msg.turnId.substring(0, 8)}, ${msg.content.length} chars, kind=${msg.kind ?? 'bridge'}, attempt ${attempt + 1})`);
+        }
+        catch (err) {
+            if (err instanceof MessageWithdrawnError) {
+                // Root message gone — no point retrying. Mark as emitted so any
+                // duplicate IPC is correctly deduped, and tear the session down.
+                ds.lastBridgeEmittedUuid = msg.lastUuid;
+                logger.warn(`[${t}] Root message withdrawn while forwarding final_output, closing session`);
+                cb.closeSession(ds);
+                return;
+            }
+            const next = attempt + 1;
+            if (next >= FINAL_OUTPUT_RETRY_BACKOFF_MS.length) {
+                logger.error(`[${t}] Bridge final_output gave up after ${next} attempts (turn ${msg.turnId.substring(0, 8)}): ${err.message}`);
+                // Don't commit the dedup marker — leave room for any future
+                // retransmit (e.g. daemon restart that re-fires the IPC).
+                return;
+            }
+            logger.warn(`[${t}] Bridge final_output attempt ${next} failed (${err.message}); retrying in ${FINAL_OUTPUT_RETRY_BACKOFF_MS[next]}ms`);
+            deliverFinalOutput(ds, msg, t, next);
+        }
+    }, FINAL_OUTPUT_RETRY_BACKOFF_MS[attempt] ?? 0);
+}
+/** Test-only alias so the retry pipeline can be exercised without a real
+ *  fork. Intentionally underscored to discourage non-test callers. */
+export const __testOnly_deliverFinalOutput = deliverFinalOutput;
 // ─── Fork adopt worker ──────────────────────────────────────────────────────
-export function forkAdoptWorker(ds) {
+export function forkAdoptWorker(ds, opts) {
     const cb = requireCallbacks();
     const workerPath = join(__dirname, '..', 'worker.js');
     const t = tag(ds);
@@ -631,7 +1011,8 @@ export function forkAdoptWorker(ds) {
             LARK_APP_SECRET: botCfg.larkAppSecret,
         },
     });
-    // Pipe worker stdout/stderr
+    // Pipe worker stdout/stderr — both go through logger.info (→ daemon.log,
+    // not error.log). See forkWorker for the rationale.
     worker.stdout?.on('data', (data) => {
         for (const line of data.toString().split('\n')) {
             const trimmed = line.trim();
@@ -641,18 +1022,33 @@ export function forkAdoptWorker(ds) {
     });
     worker.stderr?.on('data', (data) => {
         for (const line of data.toString().split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed)
-                logger.error(`[${t}:worker] ${trimmed}`);
+            logWorkerStderr(t, line.trim());
         }
     });
+    // Bridge mode is gated per-CLI:
+    //   - claude-code: needs sessionId to compute jsonl path. PID + cwd let
+    //     the worker follow Claude's `/clear` / `/resume` rotations.
+    //   - codex: worker resolves the rollout path either from cliSessionId
+    //     (passed below when known) or by reading the Codex pid's open fds
+    //     in /proc — so we always pass the pid for codex adopt.
+    //   - coco: events.jsonl path is `~/.cache/coco/sessions/<sid>/events.jsonl`,
+    //     deterministic from cliSessionId. PID is the fallback when discovery
+    //     missed (events.jsonl isn't held open continuously, so worker may need
+    //     to re-probe via session.log / traces.jsonl fds).
+    // Other CLIs fall back to legacy screen-capture only.
+    const adoptedCliId = adopted.cliId ?? 'claude-code';
+    const bridgeJsonlPath = adoptedCliId === 'claude-code' && adopted.sessionId
+        ? claudeJsonlPathForSession(adopted.sessionId, adopted.cwd)
+        : undefined;
+    const isStructuredBridge = adoptedCliId === 'codex' || adoptedCliId === 'coco';
     const initMsg = {
         type: 'init',
         sessionId: ds.session.sessionId,
         chatId: ds.chatId,
-        rootMessageId: ds.session.rootMessageId,
+        rootMessageId: sessionAnchorId(ds),
         workingDir: adopted.cwd,
-        cliId: adopted.cliId ?? 'claude-code',
+        cliId: adoptedCliId,
+        cliSessionId: isStructuredBridge ? adopted.sessionId : undefined,
         backendType: 'tmux',
         prompt: '',
         resume: false,
@@ -666,6 +1062,19 @@ export function forkAdoptWorker(ds) {
         adoptTmuxTarget: adopted.tmuxTarget,
         adoptPaneCols: adopted.paneCols,
         adoptPaneRows: adopted.paneRows,
+        bridgeJsonlPath,
+        // PID + cwd: claude uses for `~/.claude/sessions/<pid>.json` resolver;
+        // codex uses for `/proc/<pid>/fd` rollout discovery (works even if
+        // session-discovery couldn't probe sessionId up-front).
+        adoptCliPid: (adoptedCliId === 'claude-code' || isStructuredBridge) ? adopted.originalCliPid : undefined,
+        adoptCwd: (adoptedCliId === 'claude-code' || isStructuredBridge) ? adopted.cwd : undefined,
+        // Restored-from-metadata: this fork is recreating an /adopt session after
+        // a daemon restart, NOT a fresh /adopt command. The Lark thread already
+        // has every prior turn pushed as cards, so the worker should skip the
+        // "📜 /adopt 前最后一轮" preamble (it would surface a stale turn from
+        // whichever jsonl was current at the original /adopt time, which may be
+        // way out of date if the user has /clear'd since).
+        adoptRestoredFromMetadata: opts?.restoredFromMetadata === true ? true : undefined,
     };
     worker.send(initMsg);
     ds.initConfig = initMsg;
@@ -674,7 +1083,19 @@ export function forkAdoptWorker(ds) {
     ds.worker = worker;
     ds.spawnedAt = Date.now();
     ds.cliVersion = '';
+    // Stamp cliId on the persisted session so the dashboard can show a CLI badge
+    // even after the session is closed. Adopt sessions inherit the adopted CLI's id.
+    const adoptedCliIdTyped = adoptedCliId;
+    if (ds.session.cliId !== adoptedCliIdTyped) {
+        ds.session.cliId = adoptedCliIdTyped;
+        sessionStore.updateSession(ds.session);
+    }
     logger.info(`[${t}] Adopt worker forked (pid: ${worker.pid}, target: ${adopted.tmuxTarget})`);
+    ds.exitEventEmitted = false;
+    dashboardEventBus.publish({
+        type: 'session.spawned',
+        body: { session: composeRowFromActive(ds) },
+    });
 }
 // ─── Kill stale PIDs ────────────────────────────────────────────────────────
 export function killStalePids(activeSessions_) {