botmux 2.11.1 → 2.12.1

package/dist/worker.js

@@ -13,15 +13,23 @@
  *   7. On 'restart', kills CLI and re-spawns with --resume
  */
 import { randomBytes } from 'node:crypto';
-import { mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import { mkdirSync, writeFileSync, unlinkSync, existsSync, statSync, readdirSync, readlinkSync, readFileSync, watch as fsWatch } from 'node:fs';
 import { join } from 'node:path';
+import { drainTranscript, joinAssistantText, findJsonlContainingFingerprint, findLatestJsonl, extractLastAssistantTurn, stringifyUserContent } from './services/claude-transcript.js';
+import { BridgeTurnQueue, makeFingerprint } from './services/bridge-turn-queue.js';
+import { shouldSuppressBridgeEmit } from './services/bridge-fallback-gate.js';
+import { CodexBridgeQueue } from './services/codex-bridge-queue.js';
+import { drainCodexRollout, findCodexRolloutBySessionId } from './services/codex-transcript.js';
+import { dirname } from 'node:path';
 import { createServer as createHttpServer } from 'node:http';
 import { WebSocketServer, WebSocket } from 'ws';
 import { TerminalRenderer } from './utils/terminal-renderer.js';
+import { DEFAULT_RENDER_COLS, DEFAULT_RENDER_ROWS, MAX_RENDER_COLS, MAX_RENDER_ROWS, MIN_RENDER_COLS, MIN_RENDER_ROWS, clamp, resolveRenderDimensions, } from './utils/render-dimensions.js';
 import { createCliAdapterSync } from './adapters/cli/registry.js';
-import { claudeJsonlPathForSession } from './adapters/cli/claude-code.js';
+import { claudeJsonlPathForSession, resolveJsonlFromPid } from './adapters/cli/claude-code.js';
 import { PtyBackend } from './adapters/backend/pty-backend.js';
 import { TmuxBackend } from './adapters/backend/tmux-backend.js';
+import { TmuxPipeBackend } from './adapters/backend/tmux-pipe-backend.js';
 import { IdleDetector } from './utils/idle-detector.js';
 import { ScreenAnalyzer } from './utils/screen-analyzer.js';
 import { captureToPng } from './utils/screenshot-renderer.js';
@@ -36,6 +44,10 @@ let backend = null;
 let cliPidMarker = null; // path to .botmux-cli-pids/<pid>
 let idleDetector = null;
 let isTmuxMode = false;
+/** Adopt-bridge mode using TmuxPipeBackend: not a tmux attach client, all
+ *  web-terminal updates flow through the shared scrollback fan-out instead
+ *  of per-WS attach-session PTYs. Set in spawnCli's adopt branch. */
+let isPipeMode = false;
 let httpServer = null;
 let wss = null;
 const wsClients = new Set();
@@ -51,13 +63,1040 @@ let isPromptReady = false;
 /** Mutex for async flushPending — prevents concurrent flush loops. */
 let isFlushing = false;
 const pendingMessages = [];
+// ─── Adopt-bridge state (Claude Code only) ─────────────────────────────────
+//
+// In bridge mode the daemon adopted an existing CLI session that we do NOT
+// own; the model never sees botmux. We harvest assistant turns by tailing
+// Claude Code's transcript JSONL and forward only the bytes appended after
+// each Lark-driven user turn — never the historical content present at
+// attach time, never local-terminal-driven turns.
+//
+// Attribution lives in BridgeTurnQueue; this file only manages the
+// fs.watch wakeup, byte-offset bookkeeping, lazy baseline, and IPC emit.
+let bridgeJsonlPath;
+/** Directory enclosing bridgeJsonlPath. We poll this dir for newer jsonl
+ *  files so the bridge follows `/clear` / `/resume` in the user's CLI —
+ *  those create a brand-new sessionId.jsonl, and a watcher pinned to the
+ *  original path would silently stop receiving events. */
+let bridgeJsonlDir;
+/** PID + cwd of the adopted Claude Code process. Lets every poll re-read
+ *  ~/.claude/sessions/<pid>.json — Claude's own authoritative record of the
+ *  current sessionId — and switch the watched jsonl when Claude rotates
+ *  (via /clear, /resume, --resume etc.) without waiting for a Lark message
+ *  to land in the new file. */
+let bridgeCliPid;
+let bridgeCliCwd;
+/** Last sessionId we observed via the pid resolver — used to detect
+ *  rotations cheaply (string compare instead of stat()ing every jsonl). */
+let bridgeObservedCliSessionId;
+/** Old jsonl paths we keep polling AFTER a rotation switched
+ *  bridgeJsonlPath away — needed when a started turn was stamped with the
+ *  old path but its assistant text hasn't been written yet. We continue to
+ *  drain each entry on every tick so trailing appends to that file land in
+ *  the queue against the right turn, and prune the entry once no pending
+ *  turn references the path anymore. */
+const bridgeSecondaryPaths = new Map(); // path → offset
+let bridgeOffset = 0;
+let bridgePendingTail = '';
+const bridgeQueue = new BridgeTurnQueue();
+let bridgeWatcher = null;
+let bridgeFallbackTimer = null;
+/** True once we successfully baselined the transcript file. Until then,
+ *  any data we see is treated as history — absorbed into the queue's seen
+ *  set without being attributed to a pending Lark turn. This protects the
+ *  first Lark turn from inheriting historical lines if Claude Code creates
+ *  the JSONL file *after* attach. */
+let bridgeBaselineDone = false;
+/** Once-per-attach flag so a re-baseline after fs.watch lazy-fire doesn't
+ *  re-send the preamble. Reset only when the bridge teardown happens. */
+let bridgePreambleSent = false;
+// ─── Codex bridge state ──────────────────────────────────────────────────
+//
+// Parallel to the Claude bridge above. Codex's transcript layout is
+// different enough (separate file location, different event schema) that
+// trying to share storage / readers would obscure both — so we keep state
+// independent. Marker file (`<DATA_DIR>/turn-sends/<sid>.jsonl`) and the
+// gate function are CLI-agnostic and shared.
+let codexBridgeRolloutPath;
+let codexBridgeOffset = 0;
+let codexBridgePendingTail = '';
+let codexBridgeBaselineDone = false;
+const codexBridgeQueue = new CodexBridgeQueue();
+let codexBridgeWatcher = null;
+let codexBridgeTimer = null;
+/** Codex sessionId we received via writeInput but haven't yet resolved a
+ *  rollout file for. The poller keeps retrying — the file appears on
+ *  Codex's first user submit, but with some race delay after our submit
+ *  returns. Cleared once attached. */
+let codexBridgePendingSessionId;
+/** Cap the preamble text so an extremely long previous turn doesn't blow
+ *  past Lark's per-message limit. The user only needs enough to recall
+ *  context, not the entire transcript. */
+const PREAMBLE_USER_MAX = 500;
+const PREAMBLE_ASSISTANT_MAX = 4000;
+/** Same intent as the preamble caps, but for live local-terminal turns
+ *  forwarded to Lark. A long paste typed locally shouldn't be allowed to
+ *  blow past Lark's per-message limit. */
+const LOCAL_TURN_USER_MAX = 1000;
+const LOCAL_TURN_ASSISTANT_MAX = 8000;
+function truncatePreambleText(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + '…';
+}
+/** Compose a `final_output` payload for a turn synthesised from a user
+ *  prompt the human typed directly into the adopted pane. Shows both the
+ *  user text and assistant text so the Lark thread doesn't see an orphan
+ *  reply with no context. Returns `null` when neither side has anything
+ *  visible — the worker should suppress the emit in that case. */
+function formatLocalTurnContent(userText, assistantText) {
+    const u = truncatePreambleText(userText.trim(), LOCAL_TURN_USER_MAX);
+    const a = truncatePreambleText(assistantText.trim(), LOCAL_TURN_ASSISTANT_MAX);
+    if (!u && !a)
+        return null;
+    return [
+        '🖥️ 终端本地对话（在 adopted pane 中直接输入，已同步至飞书）',
+        '',
+        '👤 你：',
+        u || '(空)',
+        '',
+        `🤖 ${cliName()}：`,
+        a || '(空)',
+    ].join('\n');
+}
+// ─── Bridge fallback marker (non-adopt) ────────────────────────────────────
+//
+// `botmux send` (cli.ts cmdSend) appends a line `{sentAtMs, messageId}\n` to
+// `<DATA_DIR>/turn-sends/<sid>.jsonl` every time the model successfully posts
+// a reply to its OWN session thread. The worker reads these markers at idle
+// and suppresses transcript-driven final_output for any turn whose time
+// window already contains a send — i.e. the model didn't forget, no fallback
+// needed. Append-only over a shared file (instead of a per-turn marker) is
+// type-ahead safe: type-ahead'd turns each have their own [markTimeMs,
+// nextTurn.markTimeMs) window, and a stray send only fills its own bucket.
+function bridgeMarkerPath() {
+    if (!process.env.SESSION_DATA_DIR || !sessionId)
+        return undefined;
+    return join(process.env.SESSION_DATA_DIR, 'turn-sends', `${sessionId}.jsonl`);
+}
+function readSendMarkers() {
+    const path = bridgeMarkerPath();
+    if (!path || !existsSync(path))
+        return [];
+    try {
+        const out = [];
+        for (const line of readFileSync(path, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (typeof parsed?.sentAtMs === 'number')
+                    out.push(parsed);
+            }
+            catch { /* skip malformed line */ }
+        }
+        return out;
+    }
+    catch (err) {
+        log(`Bridge marker read failed: ${err.message}`);
+        return [];
+    }
+}
+function clearSendMarkers() {
+    const path = bridgeMarkerPath();
+    if (!path)
+        return;
+    try {
+        unlinkSync(path);
+    }
+    catch { /* already gone or fs.unavailable; not fatal */ }
+}
+function maybeEmitAdoptPreamble(events) {
+    // Preamble is an /adopt-only signal: it tells the user "here's the last
+    // turn from the Claude session you just attached to, so the Lark thread
+    // has context to continue from". In non-adopt sessions the user IS the
+    // Lark thread (every turn was already pushed there as a card), so
+    // surfacing the last turn again on daemon restart is just noise.
+    if (!lastInitConfig?.adoptMode)
+        return;
+    if (bridgePreambleSent)
+        return;
+    const turn = extractLastAssistantTurn(events);
+    if (!turn)
+        return;
+    bridgePreambleSent = true;
+    send({
+        type: 'adopt_preamble',
+        userText: truncatePreambleText(turn.userText, PREAMBLE_USER_MAX),
+        assistantText: truncatePreambleText(turn.assistantText, PREAMBLE_ASSISTANT_MAX),
+    });
+    log('Bridge adopt preamble emitted (last completed turn from baseline)');
+}
+function bridgeAbsorbBaseline() {
+    if (!bridgeJsonlPath)
+        return;
+    const result = drainTranscript(bridgeJsonlPath, 0);
+    bridgeOffset = result.newOffset;
+    bridgePendingTail = result.pendingTail;
+    bridgeQueue.absorb(result.events);
+    bridgeBaselineDone = true;
+    // After absorb (uuids registered as seen so they won't re-emit as a Lark
+    // turn), surface the last completed user/assistant exchange to Lark as a
+    // one-shot preamble — but only for real /adopt sessions. Non-adopt
+    // claude-code fallback bridge also uses baseline-existing on daemon
+    // restart/resume; it must not emit the "/adopt 前最后一轮" message.
+    if (lastInitConfig?.adoptMode)
+        maybeEmitAdoptPreamble(result.events);
+}
+/** Detect /clear / /resume: when Claude Code starts a new session in the
+ *  user's pane it writes to a brand-new sessionId.jsonl. We *cannot* use
+ *  "latest-mtime jsonl in the project dir" as the switch trigger — that
+ *  hijacks our watcher whenever a sibling Claude pane in the same cwd
+ *  writes anything. Instead, switch only when:
+ *
+ *    1. We have an unstarted pending Lark turn (otherwise no signal to
+ *       chase, and switching would risk grabbing another pane's reply).
+ *    2. The pending turn's content fingerprint shows up in a candidate
+ *       jsonl other than our current one — that's the user's current
+ *       session because they JUST typed our pane-write into it.
+ *
+ *  Pending turns are preserved across the switch so the next ingest can
+ *  match the fingerprint and start the turn in the new file. */
+function maybeSwitchBridgeJsonl() {
+    if (!bridgeJsonlDir)
+        return false;
+    const pending = bridgeQueue.peek();
+    const candidate = pending.find(t => !t.started && !!t.contentFingerprint);
+    if (!candidate || !candidate.contentFingerprint)
+        return false;
+    // Bound the search to events written after the turn was marked. Short
+    // fingerprints ("hello", "test") would otherwise match old user lines
+    // in unrelated sibling jsonls. 5s skew absorbs clock drift between the
+    // mark and Claude's transcript write.
+    const minEventTimestampMs = candidate.markTimeMs !== undefined
+        ? candidate.markTimeMs - 5_000
+        : undefined;
+    const matched = findJsonlContainingFingerprint(bridgeJsonlDir, candidate.contentFingerprint, {
+        excludePath: bridgeJsonlPath,
+        includeQueueOperations: true,
+        minEventTimestampMs,
+    });
+    if (!matched)
+        return false;
+    // Drain-before-switch: pull in any unread bytes from the old path so a
+    // late assistant append doesn't vanish. We do NOT emit here — emission
+    // only happens at idle (bridgeDrainAndMaybeEmit), otherwise drainEmittable
+    // would publish a half-finished assistant turn during fs.watch / poll
+    // ticks (drainEmittable's contract is "has visible text", not "model
+    // finished"). If the drained user/assistant events still need follow-up
+    // appends on the old path, retainSecondaryPathIfStillReferenced() keeps
+    // the old path in the polling rotation.
+    if (bridgeJsonlPath && bridgeBaselineDone) {
+        let postDrainOffset = bridgeOffset;
+        try {
+            const drained = drainPathInto(bridgeJsonlPath, bridgeOffset);
+            postDrainOffset = drained.offset;
+        }
+        catch (err) {
+            log(`Bridge final-drain on fingerprint switch failed (${err.message}); continuing`);
+        }
+        retainSecondaryPathIfStillReferenced(bridgeJsonlPath, postDrainOffset);
+    }
+    log(`Bridge transcript switched: ${bridgeJsonlPath} → ${matched} (Lark fingerprint observed in new jsonl — user likely ran /clear or /resume)`);
+    if (bridgeWatcher) {
+        try {
+            bridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        bridgeWatcher = null;
+    }
+    // Critically: do NOT clear pending turns. The switch was triggered by
+    // the fingerprint of the FIRST pending turn already living in `matched`,
+    // so the immediate next ingest from offset 0 will find that user event
+    // and start the turn. Clearing here would race-drop exactly the message
+    // we're trying to deliver.
+    bridgeJsonlPath = matched;
+    bridgeOffset = 0;
+    bridgePendingTail = '';
+    // baselineDone=false would absorb the new file's existing content
+    // (including the pending turn's user event) as history — defeating the
+    // switch. Skip baseline; fall straight into ingest from offset 0 so
+    // BridgeTurnQueue.ingest() can attribute the matching user/assistant.
+    bridgeBaselineDone = true;
+    try {
+        bridgeWatcher = fsWatch(matched, { persistent: false }, () => {
+            try {
+                bridgeIngest();
+            }
+            catch (err) {
+                log(`Bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Bridge fs.watch unavailable on new target (${err.message}); relying on fallback poller`);
+    }
+    return true;
+}
+/** /clear or /resume in the user's adopted pane creates (or touches) a new
+ *  jsonl in the same Claude project directory. Neither pid-resolver nor
+ *  fingerprint switch will fire when the rotation happened mid-process AND
+ *  there's no pending Lark turn to anchor on (pure local-terminal use), so
+ *  this fallback owns that case.
+ *
+ *  Detection priority:
+ *    1. Linux first-class: read `/proc/<pid>/fd` and pick the .jsonl the
+ *       adopted Claude process actually has open. This is bound to the real
+ *       PID — a sibling Claude pane in the same cwd has a different PID and
+ *       therefore cannot hijack the result.
+ *    2. Cross-platform fallback: directory-level mtime heuristic, gated on
+ *       (a) our current jsonl quiet ≥ QUIET_ROTATION_MS, (b) candidate
+ *       newer by ≥ QUIET_ROTATION_MS, (c) adopted Claude pid alive. Less
+ *       robust than fd lookup but the best available without /proc.
+ *
+ *  When a rotation is detected, the new jsonl is drained from offset 0 and
+ *  events are split by timestamp against `rotationCutoffMs` (the old
+ *  jsonl's last-write time): events before the cutoff are *history*
+ *  (absorbed into the seen-set, not emitted), events after are *live*
+ *  (ingested → local-turn synthesis runs). This is what lets /resume to a
+ *  long-history jsonl NOT replay the entire past as one giant local turn,
+ *  while /clear's first new turn still gets forwarded.
+ *
+ *  Critically, we do NOT call `bridgeAbsorbBaseline` here — that helper
+ *  also fires `maybeEmitAdoptPreamble`, which on rotation would surface
+ *  the *previous session's* last turn as if it were a fresh "/adopt 前最
+ *  后一轮" preamble. Preamble belongs only to initial attach. */
+const QUIET_ROTATION_MS = 8_000;
+function statSafe(path) {
+    try {
+        const st = statSync(path);
+        if (!st.isFile())
+            return null;
+        return { mtimeMs: st.mtimeMs, size: st.size };
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** List `.jsonl` files inside `dir` that are currently held open by `pid`.
+ *  Returns [] on non-Linux platforms or if /proc lookup fails — the caller
+ *  treats an empty result as "fd info unavailable, fall back to mtime". */
+function findOpenJsonlsForPid(pid, dir) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return [];
+    if (process.platform !== 'linux')
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(`/proc/${pid}/fd`);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        let target;
+        try {
+            target = readlinkSync(`/proc/${pid}/fd/${name}`);
+        }
+        catch {
+            continue;
+        }
+        if (!target.endsWith('.jsonl'))
+            continue;
+        if (dirname(target) !== dir)
+            continue;
+        out.push(target);
+    }
+    return out;
+}
+/** Pick the most recently modified path among `paths`. Returns null if
+ *  none of them stat. */
+function newestPath(paths) {
+    let best = null;
+    for (const p of paths) {
+        const st = statSafe(p);
+        if (!st)
+            continue;
+        if (!best || st.mtimeMs > best.mtimeMs)
+            best = { path: p, mtimeMs: st.mtimeMs };
+    }
+    return best?.path ?? null;
+}
+/** Switch bridgeJsonlPath to `newPath` and split-baseline its existing
+ *  content: events with timestamp ≤ `cutoffMs` are absorbed as history
+ *  (seen-set only, no emission), events strictly after are ingested so
+ *  local turn synthesis runs against them. The old path is retained in
+ *  the secondary polling rotation if any started turn still references
+ *  it. Does NOT emit `adopt_preamble` — that's an initial-attach signal,
+ *  not a rotation signal. */
+function performRotationSwitch(newPath, cutoffMs, reason) {
+    // Drain-before-switch: pull any unread bytes from the old path so a
+    // late assistant append doesn't vanish. Mirrors the other rotation
+    // helpers.
+    if (bridgeJsonlPath && bridgeBaselineDone) {
+        let postDrainOffset = bridgeOffset;
+        try {
+            const drained = drainPathInto(bridgeJsonlPath, bridgeOffset);
+            postDrainOffset = drained.offset;
+        }
+        catch (err) {
+            log(`Bridge final-drain on rotation (${reason}) failed (${err.message}); continuing`);
+        }
+        retainSecondaryPathIfStillReferenced(bridgeJsonlPath, postDrainOffset);
+    }
+    log(`Bridge transcript switched (${reason}): ${bridgeJsonlPath ?? '(none)'} → ${newPath}`);
+    if (bridgeWatcher) {
+        try {
+            bridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        bridgeWatcher = null;
+    }
+    bridgeJsonlPath = newPath;
+    bridgeJsonlDir = dirname(newPath);
+    bridgePendingTail = '';
+    // Drain the new path from 0 ourselves (do NOT call bridgeAbsorbBaseline
+    // — that would emit the preamble we want to suppress on rotation).
+    const result = drainTranscript(newPath, 0);
+    bridgeOffset = result.newOffset;
+    bridgePendingTail = result.pendingTail;
+    const history = [];
+    const live = [];
+    for (const ev of result.events) {
+        let evMs = Number.NaN;
+        if (typeof ev.timestamp === 'string')
+            evMs = Date.parse(ev.timestamp);
+        if (Number.isFinite(evMs) && evMs <= cutoffMs)
+            history.push(ev);
+        else
+            live.push(ev);
+    }
+    bridgeQueue.absorb(history);
+    if (live.length > 0)
+        bridgeQueue.ingest(live, newPath);
+    bridgeBaselineDone = true;
+    log(`Bridge rotation split: ${history.length} historical events absorbed, ${live.length} live events ingested`);
+    try {
+        bridgeWatcher = fsWatch(newPath, { persistent: false }, () => {
+            try {
+                bridgeIngest();
+            }
+            catch (err) {
+                log(`Bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Bridge fs.watch unavailable on rotated target (${err.message}); relying on fallback poller`);
+    }
+}
+function maybeFollowQuietRotation() {
+    if (!bridgeJsonlDir || !bridgeJsonlPath)
+        return;
+    // Need a known pid to do safe rotation tracking; if we don't have one,
+    // we can't bind to the adopted Claude process and a directory-mtime
+    // switch would risk sibling-pane hijack.
+    if (bridgeCliPid === undefined)
+        return;
+    if (!isPidAlive(bridgeCliPid))
+        return;
+    const currentStat = statSafe(bridgeJsonlPath);
+    if (!currentStat)
+        return;
+    // Path 1: Linux fd-based detection — definitive, can't be hijacked.
+    // Read /proc/<pid>/fd, find every .jsonl Claude has open in our cwd's
+    // project dir, pick the one with the most recent mtime. Differs from
+    // bridgeJsonlPath ⇒ rotation.
+    const opened = findOpenJsonlsForPid(bridgeCliPid, bridgeJsonlDir);
+    if (opened.length > 0) {
+        const newest = newestPath(opened);
+        if (newest && newest !== bridgeJsonlPath) {
+            performRotationSwitch(newest, currentStat.mtimeMs, `pid fd → ${bridgeCliPid}`);
+        }
+        // fd lookup succeeded — even if it confirmed the current path, the
+        // mtime fallback below would only add risk. Stop here.
+        return;
+    }
+    // Path 2: non-Linux fallback (or /proc unavailable). Directory-mtime
+    // heuristic with three guards. Less robust than fd lookup; sibling
+    // panes could in principle race the conditions, but the QUIET windows
+    // make it unlikely in practice.
+    const now = Date.now();
+    if (now - currentStat.mtimeMs < QUIET_ROTATION_MS)
+        return;
+    const latest = findLatestJsonl(bridgeJsonlDir);
+    if (!latest || latest === bridgeJsonlPath)
+        return;
+    const latestStat = statSafe(latest);
+    if (!latestStat)
+        return;
+    if (latestStat.mtimeMs - currentStat.mtimeMs < QUIET_ROTATION_MS)
+        return;
+    performRotationSwitch(latest, currentStat.mtimeMs, `quiet mtime fallback (${Math.round((now - currentStat.mtimeMs) / 1000)}s quiet)`);
+}
+function maybeFollowSessionRotationViaPid() {
+    if (!bridgeCliPid || !bridgeCliCwd)
+        return 'unavailable';
+    const resolved = resolveJsonlFromPid(bridgeCliPid, bridgeCliCwd);
+    if (!resolved)
+        return 'unavailable';
+    if (bridgeObservedCliSessionId !== resolved.cliSessionId) {
+        bridgeObservedCliSessionId = resolved.cliSessionId;
+    }
+    if (resolved.path === bridgeJsonlPath)
+        return 'same';
+    // Drain-before-switch: pull in any unread bytes from the OLD path so a
+    // trailing assistant append doesn't vanish. We do NOT emit here — emit
+    // is reserved for idle ticks (bridgeDrainAndMaybeEmit), otherwise we'd
+    // publish a half-finished assistant during fs.watch / poll-driven
+    // bridgeIngest calls. If a started turn still references the old path
+    // and its assistant text might still be on the way, the old path stays
+    // in the polling rotation via bridgeSecondaryPaths.
+    if (bridgeJsonlPath && bridgeBaselineDone) {
+        let postDrainOffset = bridgeOffset;
+        try {
+            const drained = drainPathInto(bridgeJsonlPath, bridgeOffset);
+            postDrainOffset = drained.offset;
+        }
+        catch (err) {
+            log(`Bridge final-drain on rotation failed (${err.message}); continuing`);
+        }
+        retainSecondaryPathIfStillReferenced(bridgeJsonlPath, postDrainOffset);
+    }
+    log(`Bridge transcript switched (pid resolver): ${bridgeJsonlPath ?? '(none)'} → ${resolved.path}`);
+    if (bridgeWatcher) {
+        try {
+            bridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        bridgeWatcher = null;
+    }
+    // Preserve any pending Lark turn so the next ingest can attribute it
+    // when Claude appends our user event to the new jsonl. Skip baseline:
+    // we want to read from offset 0 so the pending turn's user event is
+    // visible to BridgeTurnQueue.ingest(). Turns already started on the
+    // old path keep their stamped sourceJsonlPath, so when their assistant
+    // text eventually arrives there too it still resolves correctly.
+    bridgeJsonlPath = resolved.path;
+    bridgeJsonlDir = dirname(resolved.path);
+    bridgeOffset = 0;
+    bridgePendingTail = '';
+    bridgeBaselineDone = true;
+    try {
+        bridgeWatcher = fsWatch(resolved.path, { persistent: false }, () => {
+            try {
+                bridgeIngest();
+            }
+            catch (err) {
+                log(`Bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Bridge fs.watch unavailable on rotated target (${err.message}); relying on fallback poller`);
+    }
+    return 'switched';
+}
+function bridgeIngest() {
+    // Drain secondary paths first so any trailing assistant text on an old
+    // jsonl reaches the queue before the rotation check considers retiring
+    // the path. Strictly read-only on the polling rotation; never triggers
+    // a rotate or shifts the primary path.
+    drainSecondaryPaths();
+    // Pid-resolver: catches *spawn-time* rotations (new Claude PID → new
+    // pid file → new sessionId), e.g. daemon restart that re-issues
+    // `--resume <id>` and Claude rotates the internal id.
+    const pidFollow = maybeFollowSessionRotationViaPid();
+    // Fingerprint fallback: catches *in-process* rotations Claude makes
+    // via /clear or /resume from the user's pane. Claude's pid file has
+    // its sessionId field set ONCE at process start (see binary persistence
+    // schema) and is NOT rewritten on /clear, so pid resolver returning
+    // 'same' is NOT proof that no rotation happened. We skip the
+    // fingerprint scan only when pid resolver actively switched the path
+    // — in that case the authoritative source already moved us, and
+    // running fingerprint on top would risk a redundant flip.
+    let switched = pidFollow === 'switched';
+    if (!switched) {
+        switched = maybeSwitchBridgeJsonl();
+    }
+    // Quiet-rotation fallback: catches /clear or /resume in pure-local
+    // sessions (no pending Lark turn → no fingerprint to match against).
+    // Without this, a user who hits /clear in the adopted pane and then
+    // continues in the terminal would never get those replies forwarded
+    // to Lark — the watcher stays stuck on the old, frozen jsonl.
+    if (!switched) {
+        maybeFollowQuietRotation();
+    }
+    if (!bridgeJsonlPath)
+        return;
+    if (!bridgeBaselineDone) {
+        // Lazy baseline: file didn't exist at attach, baseline the moment it does.
+        if (!existsSyncSafe(bridgeJsonlPath))
+            return;
+        bridgeAbsorbBaseline();
+        return;
+    }
+    const result = drainTranscript(bridgeJsonlPath, bridgeOffset);
+    bridgeOffset = result.newOffset;
+    bridgePendingTail = result.pendingTail;
+    bridgeQueue.ingest(result.events, bridgeJsonlPath);
+}
+function startBridgeWatcher(jsonlPath, opts) {
+    bridgeJsonlPath = jsonlPath;
+    bridgeJsonlDir = dirname(jsonlPath);
+    bridgeCliPid = opts?.cliPid;
+    bridgeCliCwd = opts?.cliCwd;
+    const mode = opts?.mode ?? 'baseline-existing';
+    // Authoritative: prefer Claude's own pid-state record over the path the
+    // adopt scan computed. If Claude has already rotated since adopt fired
+    // (e.g. user ran /clear before any Lark message arrived), this swaps the
+    // initial path before baseline so we don't waste a baseline on a frozen
+    // file.
+    if (bridgeCliPid && bridgeCliCwd) {
+        const resolved = resolveJsonlFromPid(bridgeCliPid, bridgeCliCwd);
+        if (resolved) {
+            bridgeObservedCliSessionId = resolved.cliSessionId;
+            if (resolved.path !== bridgeJsonlPath) {
+                log(`Bridge transcript adjusted at start (pid resolver): ${bridgeJsonlPath} → ${resolved.path}`);
+                bridgeJsonlPath = resolved.path;
+                bridgeJsonlDir = dirname(resolved.path);
+            }
+        }
+    }
+    if (mode === 'fresh-empty') {
+        // Non-adopt fallback: brand-new session, jsonl gets created on the first
+        // user submit. We must NOT lazy-absorb the file when it appears — that
+        // would treat the first turn's user/assistant events as history and the
+        // worker would never emit a final_output for them. Instead declare
+        // baseline=done with offset=0 up front: the very first events drained
+        // from the file are eligible for attribution against pending Lark turns.
+        bridgeOffset = 0;
+        bridgePendingTail = '';
+        bridgeBaselineDone = true;
+        log(`Bridge fresh-empty mode: ${bridgeJsonlPath} (waiting for file to appear; no baseline absorb)`);
+    }
+    else if (existsSyncSafe(bridgeJsonlPath)) {
+        bridgeAbsorbBaseline();
+        log(`Bridge baselined: ${bridgeJsonlPath} (offset=${bridgeOffset})`);
+    }
+    else {
+        log(`Bridge transcript not yet present at ${bridgeJsonlPath}; will baseline on first appearance`);
+    }
+    // fs.watch is best-effort wakeup — actual data source is the byte offset.
+    // The fallback poller covers fs.watch's gaps (NFS, rename-rotation, etc.)
+    // and also drives lazy baseline when the file shows up after attach.
+    try {
+        bridgeWatcher = fsWatch(bridgeJsonlPath, { persistent: false }, () => {
+            try {
+                bridgeIngest();
+            }
+            catch (err) {
+                log(`Bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Bridge fs.watch unavailable (${err.message}); relying on fallback poller`);
+    }
+    bridgeFallbackTimer = setInterval(() => {
+        try {
+            bridgeIngest();
+        }
+        catch (err) {
+            log(`Bridge ingest error: ${err.message}`);
+        }
+    }, 1000);
+}
+function stopBridgeWatcher() {
+    if (bridgeWatcher) {
+        try {
+            bridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        bridgeWatcher = null;
+    }
+    if (bridgeFallbackTimer) {
+        clearInterval(bridgeFallbackTimer);
+        bridgeFallbackTimer = null;
+    }
+    bridgeCliPid = undefined;
+    bridgeCliCwd = undefined;
+    bridgeObservedCliSessionId = undefined;
+    bridgeSecondaryPaths.clear();
+    bridgePreambleSent = false;
+}
+/**
+ * Push a pending turn for the next Lark message.
+ *
+ * Returns true on success, false if bridge-final-output isn't available for
+ * this message (transcript not yet baselined). On false, the worker still
+ * raw-writes the message into the pane — the user just won't get a
+ * transcript-driven final_output reply for it. This keeps the v3 promise:
+ * if we can't attribute correctly, we don't attribute at all.
+ *
+ * `messageText` is the raw Lark message body — we derive a short content
+ * fingerprint from it so the next *matching* user event in the transcript
+ * (and only that one) starts this turn. Local-terminal input that races
+ * with the pane-write will not match the fingerprint and won't hijack the
+ * Lark turn.
+ */
+function bridgeMarkPendingTurn(messageText) {
+    if (!bridgeJsonlPath)
+        return false;
+    if (!bridgeBaselineDone) {
+        log('Bridge baseline not ready — this turn will not have transcript-driven final_output');
+        return false;
+    }
+    const fingerprint = makeFingerprint(messageText);
+    bridgeQueue.mark(randomBytes(8).toString('hex'), fingerprint);
+    return true;
+}
+function bridgeDrainAndMaybeEmit() {
+    if (!bridgeJsonlPath)
+        return;
+    bridgeIngest();
+    emitReadyTurns();
+    // Prune AFTER emit so a path is only retired once its turn has actually
+    // been published. During non-idle ticks (fs.watch / 1s poll) we never
+    // emit, so we never prune — the path stays put until idle resolves it.
+    pruneSecondaryPaths();
+}
+/** Pop ready turns and emit their final_output. Resolves uuid → text via
+ *  each turn's own `sourceJsonlPath` (stamped at turn-start) so an in-flight
+ *  reply that started in an old jsonl still gets picked up after a sessionId
+ *  rotation has switched the global `bridgeJsonlPath` to a different file.
+ *  Falls back to `bridgeJsonlPath` for legacy turns without a stamped source.
+ *
+ *  Caches per-path drains so a batch of turns from the same file only reads
+ *  the transcript once (O(jsonl size) per distinct path). */
+function emitReadyTurns() {
+    const ready = bridgeQueue.drainEmittable();
+    if (ready.length === 0)
+        return;
+    const adoptMode = lastInitConfig?.adoptMode === true;
+    // Send markers (`botmux send` landed in own thread) + the queue's first
+    // still-unready turn. The latter caps the LAST ready turn's window —
+    // without it, a model that's still mid-tool-use for turn N+1 could leak
+    // a send credit into turn N's window via shouldSuppressBridgeEmit.
+    const markers = adoptMode ? [] : readSendMarkers();
+    const remainingPending = bridgeQueue.peek();
+    const nextPendingMarkTimeMs = remainingPending.length > 0 ? remainingPending[0].markTimeMs : undefined;
+    const cache = new Map();
+    for (let i = 0; i < ready.length; i++) {
+        const turn = ready[i];
+        const nextBoundaryMs = (i + 1 < ready.length ? ready[i + 1].markTimeMs : nextPendingMarkTimeMs);
+        if (shouldSuppressBridgeEmit({ markTimeMs: turn.markTimeMs, isLocal: turn.isLocal }, nextBoundaryMs, markers, adoptMode)) {
+            const reason = turn.isLocal ? 'local-typed' : 'model called botmux send within window';
+            log(`Bridge fallback suppressed for turn ${turn.turnId.substring(0, 8)} (${reason})`);
+            continue;
+        }
+        const path = turn.sourceJsonlPath ?? bridgeJsonlPath;
+        if (!path)
+            continue;
+        let drained = cache.get(path);
+        if (!drained) {
+            drained = drainTranscript(path, 0);
+            cache.set(path, drained);
+        }
+        const set = new Set(turn.assistantUuids);
+        const matched = drained.events.filter(e => e.uuid && set.has(e.uuid));
+        const assistantText = joinAssistantText(matched);
+        if (assistantText.length === 0)
+            continue;
+        const lastUuid = turn.assistantUuids[turn.assistantUuids.length - 1];
+        if (turn.isLocal) {
+            // Local turn (adopt mode only): also surface the user prompt so the
+            // Lark thread shows both sides of the exchange. User text comes from
+            // the same drained transcript via the userUuid stamped at start time.
+            const userEv = turn.userUuid
+                ? drained.events.find(e => e.uuid === turn.userUuid)
+                : undefined;
+            const userText = userEv ? stringifyUserContent(userEv.message?.content) : '';
+            const content = formatLocalTurnContent(userText, assistantText);
+            if (!content)
+                continue;
+            send({ type: 'final_output', content, lastUuid, turnId: turn.turnId });
+            continue;
+        }
+        send({ type: 'final_output', content: assistantText, lastUuid, turnId: turn.turnId });
+    }
+}
+/** Drain `path` from `fromOffset` and feed the events to the bridge queue
+ *  with that path as the source stamp. Pure side-effects on bridgeQueue +
+ *  the returned cursor; does NOT touch bridgeJsonlPath / bridgeOffset, so
+ *  callers can use it to flush the old path during a rotation without
+ *  disturbing the watcher's normal cursor. Returns the new offset for the
+ *  caller to commit (or discard, if it's about to switch paths). */
+function drainPathInto(path, fromOffset) {
+    const result = drainTranscript(path, fromOffset);
+    bridgeQueue.ingest(result.events, path);
+    return { offset: result.newOffset, tail: result.pendingTail };
+}
+// ─── Codex bridge wiring ─────────────────────────────────────────────────
+//
+// Codex's bridge fallback is intentionally simpler than Claude's: no /adopt
+// surface, no pid-resolver / quiet-rotation / fingerprint-jsonl-switch
+// machinery. The reader watches one rollout file (located by cliSessionId)
+// and the queue's only responsibility is "user fingerprint match → start;
+// assistant_final → close". Everything else (mark / emit gate / send
+// marker IO / type-ahead serialisation / one-write-per-idle break) is
+// shared with the Claude path.
+function codexBridgeFallbackActive() {
+    if (lastInitConfig?.adoptMode)
+        return false;
+    return lastInitConfig?.cliId === 'codex';
+}
+function codexBridgeStartTimer() {
+    if (codexBridgeTimer)
+        return;
+    // Single 1s ticker that handles three jobs: late-attach (poll for the
+    // rollout file once we know cliSessionId), ingest (fs.watch backup),
+    // and idle-window emit. The last is critical for the late-attach race:
+    // if the rollout path appears AFTER the CLI's idle event has fired,
+    // the idle callback's emit already ran (and saw an empty queue), so
+    // the next emit chance would be at the next idle — i.e. the user has
+    // to send another message before the previous turn's fallback shows
+    // up. Emitting here when isPromptReady=true closes that window.
+    // Codex's queue only releases turns on `assistant_final` (the model's
+    // declared end-of-turn), so a tick-driven emit can't accidentally
+    // publish a half-streamed response.
+    codexBridgeTimer = setInterval(() => {
+        try {
+            if (!codexBridgeRolloutPath && codexBridgePendingSessionId) {
+                const path = findCodexRolloutBySessionId(codexBridgePendingSessionId);
+                if (path) {
+                    codexBridgePendingSessionId = undefined;
+                    codexBridgeAttach(path, 'fresh-empty');
+                }
+            }
+            codexBridgeIngest();
+            if (isPromptReady)
+                emitReadyCodexTurns();
+        }
+        catch (err) {
+            log(`Codex bridge tick error: ${err.message}`);
+        }
+    }, 1000);
+}
+function codexBridgeAttach(rolloutPath, mode) {
+    codexBridgeRolloutPath = rolloutPath;
+    if (mode === 'fresh-empty') {
+        // Brand-new session OR late-attach right after first submit. Either
+        // way we want to ingest from offset 0 — pending turns marked before
+        // attach are still in the queue, so the user_message that just landed
+        // (or is about to land) will fingerprint-match them.
+        codexBridgeOffset = 0;
+        codexBridgePendingTail = '';
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge fresh-empty: ${rolloutPath}`);
+    }
+    else if (existsSync(rolloutPath)) {
+        const result = drainCodexRollout(rolloutPath, 0);
+        codexBridgeOffset = result.newOffset;
+        codexBridgePendingTail = result.pendingTail;
+        codexBridgeQueue.absorb(result.events);
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge baselined: ${rolloutPath} (offset=${codexBridgeOffset})`);
+    }
+    else {
+        // baseline-existing requested but file missing — degrade to fresh
+        // semantics so the lazy-appearing file isn't accidentally absorbed.
+        codexBridgeOffset = 0;
+        codexBridgePendingTail = '';
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge transcript not yet present at ${rolloutPath}; treating as fresh`);
+    }
+    try {
+        codexBridgeWatcher = fsWatch(rolloutPath, { persistent: false }, () => {
+            try {
+                codexBridgeIngest();
+            }
+            catch (err) {
+                log(`Codex bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Codex bridge fs.watch unavailable (${err.message}); relying on poller`);
+    }
+}
+/** Called from flushPending after writeInput first returns a cliSessionId.
+ *  Tries to locate the rollout file immediately; if it's not on disk yet,
+ *  remembers the sid so the 1s poller can keep retrying. */
+function codexBridgeNotifyCliSessionId(cliSessionId) {
+    if (!codexBridgeFallbackActive() || codexBridgeRolloutPath)
+        return;
+    const path = findCodexRolloutBySessionId(cliSessionId);
+    if (path) {
+        codexBridgePendingSessionId = undefined;
+        codexBridgeAttach(path, 'fresh-empty');
+    }
+    else {
+        codexBridgePendingSessionId = cliSessionId;
+        codexBridgeStartTimer();
+    }
+}
+function codexBridgeIngest() {
+    if (!codexBridgeRolloutPath || !codexBridgeBaselineDone)
+        return;
+    const result = drainCodexRollout(codexBridgeRolloutPath, codexBridgeOffset);
+    codexBridgeOffset = result.newOffset;
+    codexBridgePendingTail = result.pendingTail;
+    codexBridgeQueue.ingest(result.events);
+}
+/** Mark a pending Lark turn for Codex. Crucially this works even before a
+ *  rollout path is known — the queue is path-agnostic, and ingest after
+ *  late-attach picks up the user_message and matches the fingerprint. */
+function codexBridgeMarkPendingTurn(messageText) {
+    if (!codexBridgeFallbackActive())
+        return false;
+    const turnId = `codex-${randomBytes(8).toString('hex')}`;
+    codexBridgeQueue.mark(turnId, messageText);
+    return true;
+}
+function codexBridgeDrainAndMaybeEmit() {
+    if (!codexBridgeFallbackActive())
+        return;
+    if (codexBridgeRolloutPath && codexBridgeBaselineDone) {
+        try {
+            codexBridgeIngest();
+        }
+        catch (err) {
+            log(`Codex bridge ingest error: ${err.message}`);
+        }
+    }
+    emitReadyCodexTurns();
+}
+function emitReadyCodexTurns() {
+    const ready = codexBridgeQueue.drainEmittable();
+    if (ready.length === 0)
+        return;
+    const markers = readSendMarkers();
+    const remaining = codexBridgeQueue.peek();
+    const nextPendingMarkTimeMs = remaining.length > 0 ? remaining[0].markTimeMs : undefined;
+    for (let i = 0; i < ready.length; i++) {
+        const turn = ready[i];
+        const nextBoundaryMs = (i + 1 < ready.length ? ready[i + 1].markTimeMs : nextPendingMarkTimeMs);
+        if (shouldSuppressBridgeEmit({ markTimeMs: turn.markTimeMs, isLocal: false }, nextBoundaryMs, markers, false)) {
+            log(`Codex bridge fallback suppressed for turn ${turn.turnId.substring(0, 8)} (model called botmux send within window)`);
+            continue;
+        }
+        if (!turn.finalText)
+            continue;
+        send({ type: 'final_output', content: turn.finalText, lastUuid: turn.turnId, turnId: turn.turnId });
+    }
+}
+function stopCodexBridge() {
+    if (codexBridgeWatcher) {
+        try {
+            codexBridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        codexBridgeWatcher = null;
+    }
+    if (codexBridgeTimer) {
+        clearInterval(codexBridgeTimer);
+        codexBridgeTimer = null;
+    }
+    codexBridgeRolloutPath = undefined;
+    codexBridgeOffset = 0;
+    codexBridgePendingTail = '';
+    codexBridgeBaselineDone = false;
+    codexBridgeQueue.clearPending();
+    codexBridgePendingSessionId = undefined;
+}
+/** When a rotation moves bridgeJsonlPath away from `oldPath`, queue turns
+ *  whose sourceJsonlPath equals oldPath may still be waiting on assistant
+ *  text that hasn't landed yet. Add oldPath to the secondary polling set
+ *  so subsequent ingests continue to drain it; the offset is whatever was
+ *  reached by the final pre-switch drain so we don't re-scan history. The
+ *  entry is later pruned after each idle emit when no started turn
+ *  references it anymore. */
+function retainSecondaryPathIfStillReferenced(oldPath, postDrainOffset) {
+    const stillReferenced = bridgeQueue.peek().some(t => t.sourceJsonlPath === oldPath);
+    if (!stillReferenced)
+        return;
+    const existing = bridgeSecondaryPaths.get(oldPath);
+    // Don't rewind a higher existing offset — multiple rotations through
+    // the same file shouldn't replay drained bytes.
+    if (existing === undefined || postDrainOffset > existing) {
+        bridgeSecondaryPaths.set(oldPath, postDrainOffset);
+    }
+    log(`Bridge retaining secondary path ${oldPath} (offset=${postDrainOffset}) for in-flight turn`);
+}
+/** Drain every secondary path once. Mirrors bridgeIngest's primary-path
+ *  drain but never touches bridgeJsonlPath / bridgeOffset and never
+ *  triggers further rotation checks — it's strictly a "catch up trailing
+ *  events on an old file" pass. */
+function drainSecondaryPaths() {
+    for (const [path, offset] of bridgeSecondaryPaths) {
+        try {
+            const result = drainTranscript(path, offset);
+            if (result.events.length > 0)
+                bridgeQueue.ingest(result.events, path);
+            bridgeSecondaryPaths.set(path, result.newOffset);
+        }
+        catch (err) {
+            log(`Bridge secondary-path drain failed (${path}): ${err.message}`);
+        }
+    }
+}
+/** Drop secondary paths whose started turns are no longer in the queue —
+ *  i.e. they've been emitted (or discarded). Called after each idle emit so
+ *  pruning never races with an in-flight turn. */
+function pruneSecondaryPaths() {
+    if (bridgeSecondaryPaths.size === 0)
+        return;
+    const referenced = new Set();
+    for (const t of bridgeQueue.peek()) {
+        if (t.sourceJsonlPath)
+            referenced.add(t.sourceJsonlPath);
+    }
+    for (const path of [...bridgeSecondaryPaths.keys()]) {
+        if (!referenced.has(path)) {
+            bridgeSecondaryPaths.delete(path);
+            log(`Bridge dropped secondary path ${path} (no remaining turns)`);
+        }
+    }
+}
+/** Tiny safe-existence check that doesn't throw. */
+function existsSyncSafe(p) {
+    try {
+        return existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
 /** Suppress screen updates until first prompt detected (avoids history replay in card on --resume) */
 let awaitingFirstPrompt = true;
 // ─── PTY Dimensions ──────────────────────────────────────────────────────────
-// Matches SNAPSHOT_COLS / SHOT_COLS (160). Narrow enough for the web terminal
-// to render comfortably; the card PNG crops at this width anyway.
-const PTY_COLS = 160;
-const PTY_ROWS = 50;
+// Default for botmux-spawned CLIs: narrow enough for the web terminal to
+// render comfortably and for the card PNG to fit Lark's typical card width.
+// Adopt mode overrides this via resolveRenderDimensions() to match the
+// user's actual pane (often 200-270 cols) so the renderer doesn't wrap
+// wide ANSI into a stair-stepped / duplicated mess.
+const PTY_COLS = DEFAULT_RENDER_COLS;
+const PTY_ROWS = DEFAULT_RENDER_ROWS;
+/** Set in the `init` handler BEFORE startScreenUpdates() so the headless
+ *  xterm + screenshot canvas are sized to the source pane from the start.
+ *  Setting them later (after the renderer was built at the default size)
+ *  wouldn't retroactively re-size what xterm has already buffered,
+ *  leaving the wrap artefacts in place. */
+let renderCols = PTY_COLS;
+let renderRows = PTY_ROWS;
 // ─── Headless Terminal for Screen Capture ────────────────────────────────────
 let renderer = null;
 let screenUpdateTimer = null;
@@ -117,8 +1156,10 @@ function stopScreenAnalyzer() {
 // ─── Screenshot Capture (PNG → Feishu image_key) ────────────────────────────
 const SCREENSHOT_INTERVAL_MS = 10_000;
 const POST_ACTION_DELAY_MS = 1_000;
-const SHOT_COLS = 160;
-const SHOT_ROWS = 50;
+// PNG dimensions key off the renderer's actual size (renderCols / renderRows),
+// which adopt-mode peg to the source pane so wrap artefacts don't appear.
+// Re-clamping at MAX_RENDER_COLS/ROWS guards against a malformed init
+// payload sneaking past the resolver into a runaway canvas.
 let displayMode = 'hidden';
 let screenshotTimer = null;
 let pendingShotTimer = null;
@@ -178,7 +1219,9 @@ async function captureAndUpload() {
     lastShotHash = hash;
     let png;
     try {
-        png = captureToPng(term, { cols: SHOT_COLS, rows: SHOT_ROWS, startY });
+        const shotCols = clamp(term.cols, MIN_RENDER_COLS, MAX_RENDER_COLS);
+        const shotRows = clamp(term.rows, MIN_RENDER_ROWS, MAX_RENDER_ROWS);
+        png = captureToPng(term, { cols: shotCols, rows: shotRows, startY });
     }
     catch (err) {
         log(`Screenshot render failed: ${err.message}`);
@@ -377,9 +1420,11 @@ let trustHandled = false;
 // ─── Prompt Detection ────────────────────────────────────────────────────────
 function onPtyData(data) {
     renderer?.write(data);
-    // In tmux mode, web clients have their own tmux attach — no relay needed.
-    // In non-tmux mode, broadcast to all WS clients via shared scrollback.
-    if (!isTmuxMode) {
+    // In tmux-attach mode, each web client has its own tmux attach PTY —
+    // no relay needed. In non-tmux mode AND in pipe mode (adopt-bridge),
+    // broadcast through the shared scrollback so all connected web clients
+    // render the same byte stream.
+    if (!isTmuxMode || isPipeMode) {
         // Track alt-buffer state so we can restore it in the scrollback prefix.
         // Scan for the *last* toggle in this chunk — that's the current state.
         let lastToggleIdx = -1;
@@ -453,6 +1498,23 @@ function markPromptReady() {
     }
     flushPending();
 }
+function persistCliSessionId(cliSessionId) {
+    if (!cliSessionId || !sessionId)
+        return;
+    if (lastInitConfig)
+        lastInitConfig.cliSessionId = cliSessionId;
+    try {
+        const session = sessionStore.getSession(sessionId);
+        if (!session || session.cliSessionId === cliSessionId)
+            return;
+        session.cliSessionId = cliSessionId;
+        sessionStore.updateSession(session);
+        log(`Persisted CLI session id: ${cliSessionId}`);
+    }
+    catch (err) {
+        log(`Failed to persist CLI session id: ${err.message}`);
+    }
+}
 /**
  * Drain the pending message queue sequentially.
  * Async with isFlushing mutex: awaits each writeInput, then immediately
@@ -467,7 +1529,21 @@ async function flushPending() {
     if (pendingMessages.length === 0)
         return; // nothing to flush — keep isPromptReady
     // Type-ahead adapters flush even while the CLI is busy; others wait for idle.
-    if (!isPromptReady && !cliAdapter.supportsTypeAhead)
+    // Bridge fallback (non-adopt) disables type-ahead: queued submits land
+    // in jsonl as `attachment(queued_command)` events, NOT `role:user` lines,
+    // so BridgeTurnQueue.ingest never starts the pending turn for them and
+    // the assistant text would be dropped on the floor. Serialise instead —
+    // worker holds messages in pendingMessages until the CLI reaches idle.
+    const claudeBridgeActive = !!bridgeJsonlPath && !lastInitConfig?.adoptMode;
+    const codexBridgeActive = codexBridgeFallbackActive();
+    const bridgeFallbackActive = claudeBridgeActive || codexBridgeActive;
+    // Type-ahead must be disabled for any active bridge fallback (claude or
+    // codex). Claude type-ahead's queued submits never become role:user
+    // events; Codex doesn't declare supportsTypeAhead so this is mostly a
+    // belt-and-braces gate, but keep symmetry so future adapters with
+    // type-ahead get the same protection automatically.
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !bridgeFallbackActive;
+    if (!isPromptReady && !typeAheadAllowed)
         return;
     isFlushing = true;
     if (isPromptReady) {
@@ -477,8 +1553,41 @@ async function flushPending() {
     try {
         while (pendingMessages.length > 0 && backend && cliAdapter) {
             const msg = pendingMessages.shift();
+            // Bridge fallback: mark immediately before writeInput. Doing it here
+            // (instead of at enqueue time) means markTimeMs anchors to the
+            // moment the message actually starts hitting the PTY — so any
+            // `botmux send` whose sentAtMs lands during turn N's processing
+            // falls inside [markTimeMs(N), markTimeMs(N+1)). Marking earlier
+            // (at IPC arrival) would let a slow-finishing turn N's send leak
+            // into turn N+1's window and falsely suppress its emit.
+            if (claudeBridgeActive) {
+                try {
+                    bridgeIngest();
+                }
+                catch { /* best-effort */ }
+                bridgeMarkPendingTurn(msg);
+            }
+            else if (codexBridgeActive) {
+                // Codex mark works even before the rollout path is known: the
+                // queue is path-agnostic, and the late-attach below will start
+                // ingest from offset 0 so the user_message that lands shortly
+                // after still fingerprint-matches this turn.
+                codexBridgeMarkPendingTurn(msg);
+            }
             log(`Writing to PTY (flush): "${msg.substring(0, 80)}"`);
             const result = await cliAdapter.writeInput(backend, msg);
+            // Persist any sessionId the adapter observed via authoritative sources
+            // (Claude's pid file, Codex's history). Done independently of submit
+            // outcome — the rotation is real even when the current Enter didn't
+            // land, and we want next-resume to use the right id.
+            if (result?.cliSessionId) {
+                persistCliSessionId(result.cliSessionId);
+                // First successful Codex submit also reveals the rollout path.
+                // Late-attach now so subsequent assistant_final events get
+                // attributed to this turn.
+                if (codexBridgeActive)
+                    codexBridgeNotifyCliSessionId(result.cliSessionId);
+            }
             if (result && result.submitted === false) {
                 const preview = msg.length > 60 ? msg.slice(0, 60) + '…' : msg;
                 log(`writeInput: submit not confirmed after retries — notifying user. preview="${preview}"`);
@@ -487,6 +1596,16 @@ async function flushPending() {
                     message: `⚠️ 刚才那条消息发给 ${cliName()} 后没能确认提交（重试 Enter 3 次仍未在会话 JSONL 中看到新记录）。可能卡在输入框里——请去 Web 终端看一下，手动按 Enter 或重发。\n开头：${preview}`,
                 });
             }
+            // Bridge fallback: stop after one writeInput. Subsequent submits
+            // would be type-ahead'd into Claude's queue, which jsonl records as
+            // queued_command attachments (not role:user lines) — BridgeTurnQueue
+            // can't attribute those, so the fallback would silently drop them.
+            // We resume on the next idle, by which point Claude has finished
+            // and the next message can be a normal role:user submit. Scoped to
+            // bridgeFallbackActive so non-bridge CLIs (codex/gemini/...) keep
+            // the original "one idle drains all pending" behaviour.
+            if (bridgeFallbackActive && pendingMessages.length > 0)
+                break;
         }
     }
     finally {
@@ -497,11 +1616,23 @@ function sendToPty(content) {
     if (!backend || !cliAdapter)
         return;
     pendingMessages.push(content);
+    // User-override semantics: a fresh Lark message while a TUI prompt is "active"
+    // takes precedence over the AI-detected prompt. The screen analyzer can be
+    // wrong (false positive on a question that has no rendered options) and a
+    // wedged blocking flag silently swallows every subsequent message — without
+    // this override the user has no way to recover from Lark. Mirrors the
+    // web-terminal text-input path (handleTuiTextInput).
     if (tuiPromptBlocking) {
-        log(`Queued message (${pendingMessages.length} pending): "${content.substring(0, 80)}" — TUI prompt active`);
-        return;
+        log(`User override: incoming Lark message clears tuiPromptBlocking — "${content.substring(0, 80)}"`);
+        tuiPromptBlocking = false;
+        screenAnalyzer?.notifySelection('lark-input');
+        // Tear down the prompt card so the user doesn't see stale options.
+        send({ type: 'tui_prompt_resolved', selectedText: 'user-override' });
     }
-    if (isPromptReady || isFlushing || cliAdapter.supportsTypeAhead) {
+    // See flushPending: bridge fallback gates type-ahead off (claude OR codex).
+    const bridgeFallbackActive = (!!bridgeJsonlPath && !lastInitConfig?.adoptMode) || codexBridgeFallbackActive();
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !bridgeFallbackActive;
+    if (isPromptReady || isFlushing || typeAheadAllowed) {
         log(`Writing to PTY: "${content.substring(0, 80)}"`);
         flushPending(); // fire-and-forget async; no-op if already flushing
     }
@@ -511,7 +1642,12 @@ function sendToPty(content) {
 }
 // ─── Screen Update Timer ─────────────────────────────────────────────────────
 function startScreenUpdates() {
-    renderer = new TerminalRenderer(PTY_COLS, PTY_ROWS);
+    // renderCols / renderRows were set by the init handler from cfg, so
+    // adopt-mode panes (e.g. 270x57) get an xterm-headless of matching
+    // width. With a too-narrow renderer, ANSI meant for the source pane
+    // would wrap and the screenshot would show duplicated / stair-stepped
+    // content (the live failure that prompted this fix).
+    renderer = new TerminalRenderer(renderCols, renderRows);
     let lastSentStatus;
     screenUpdateTimer = setInterval(() => {
         if (!renderer || awaitingFirstPrompt)
@@ -539,36 +1675,73 @@ function stopScreenUpdates() {
 }
 // ─── PTY Management ──────────────────────────────────────────────────────────
 function spawnCli(cfg) {
-    // ── Adopt mode: attach to an existing tmux pane (no CLI spawn) ──
+    // ── Adopt mode: pipe-pane the user's existing tmux pane (no attach) ──
     if (cfg.adoptMode && cfg.adoptTmuxTarget) {
+        // We mark BOTH isTmuxMode and isPipeMode: the former keeps idle/spawn
+        // logic on the tmux track; the latter tells the WS handler to route
+        // updates through the shared scrollback fan-out (because there is no
+        // PTY-per-WS — we don't attach to anything).
         isTmuxMode = true;
+        isPipeMode = true;
         const cols = cfg.adoptPaneCols ?? PTY_COLS;
         const rows = cfg.adoptPaneRows ?? PTY_ROWS;
-        const tmuxBe = new TmuxBackend('adopt-' + cfg.sessionId.slice(0, 8), { ownsSession: false });
-        backend = tmuxBe;
-        tmuxBe.attachToExisting(cfg.adoptTmuxTarget, {
+        const pipeBe = new TmuxPipeBackend(cfg.adoptTmuxTarget);
+        backend = pipeBe;
+        pipeBe.spawn('', [], {
             cwd: cfg.workingDir,
             cols,
             rows,
             env: process.env,
         });
-        // Minimal idle detection (output quiescence only)
-        idleDetector = new IdleDetector({ completionPattern: undefined, readyPattern: undefined });
+        // Seed the shared scrollback with the pane's current screen so any
+        // already-connected (or future) WS clients render meaningful content
+        // immediately, instead of waiting for the next byte tmux pipes through.
+        try {
+            const initial = pipeBe.captureCurrentScreen();
+            if (initial.length > 0)
+                onPtyData(initial);
+        }
+        catch (err) {
+            log(`captureCurrentScreen failed: ${err.message}`);
+        }
+        // Bridge mode: tail Claude Code's transcript JSONL to harvest assistant
+        // turns out-of-band. Only enabled when the daemon supplied a path
+        // (claude-code adopt with a known sessionId).
+        if (cfg.bridgeJsonlPath) {
+            startBridgeWatcher(cfg.bridgeJsonlPath, {
+                cliPid: cfg.adoptCliPid,
+                cliCwd: cfg.adoptCwd,
+            });
+        }
+        // Idle detection. In bridge mode we use Claude Code's real
+        // completion/ready patterns (e.g. "Worked for Xs") so tool-execution
+        // pauses don't trigger a premature emit. Other adopt cases keep the
+        // minimal output-quiescence-only detector.
+        const idleAdapter = cfg.bridgeJsonlPath
+            ? createCliAdapterSync('claude-code', undefined)
+            : { completionPattern: undefined, readyPattern: undefined };
+        idleDetector = new IdleDetector(idleAdapter);
         idleDetector.onIdle(() => {
             log('Prompt detected (idle) — adopt mode');
+            try {
+                bridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Bridge emit error: ${err.message}`);
+            }
             markPromptReady();
         });
         backend.onData(onPtyData);
         backend.onExit((code, signal) => {
-            log(`Adopted session exited (code: ${code}, signal: ${signal})`);
+            log(`Adopted pipe-pane stream ended (code: ${code}, signal: ${signal})`);
             backend = null;
             isPromptReady = false;
+            stopBridgeWatcher();
             send({ type: 'claude_exit', code, signal });
         });
-        // CLI is already running — unblock screen updates immediately
         awaitingFirstPrompt = false;
         renderer?.markNewTurn();
-        log(`Adopt mode: attached to ${cfg.adoptTmuxTarget} (${cols}x${rows})`);
+        log(`Adopt mode (pipe): observing ${cfg.adoptTmuxTarget} (${cols}x${rows})`);
         return;
     }
     cliAdapter = createCliAdapterSync(cfg.cliId, cfg.cliPathOverride);
@@ -588,6 +1761,7 @@ function spawnCli(cfg) {
     const args = cliAdapter.buildArgs({
         sessionId: cfg.sessionId,
         resume: cfg.resume ?? false,
+        resumeSessionId: cfg.cliSessionId,
         initialPrompt: cfg.prompt || undefined,
         botName: cfg.botName,
         botOpenId: cfg.botOpenId,
@@ -632,16 +1806,85 @@ function spawnCli(cfg) {
             log(`Failed to write CLI PID marker: ${err.message}`);
         }
     }
+    // Wire pid + cwd so the claude-code adapter's writeInput can read
+    // ~/.claude/sessions/<pid>.json — Claude's authoritative current sessionId.
+    // The pinned claudeJsonlPath above is still used as the initial guess; the
+    // resolver corrects it on first write when Claude has rotated under us.
+    if (cfg.cliId === 'claude-code' && cliPid) {
+        backend.cliPid = cliPid;
+        backend.cliCwd = cfg.workingDir;
+    }
     // On tmux re-attach, keep awaitingFirstPrompt = true so screen updates are
     // suppressed until the idle detector fires markNewTurn() — this prevents the
     // full tmux scrollback history from leaking into the streaming card.
     if (tmuxBe?.isReattach) {
         log('Re-attached to existing tmux session');
     }
+    // Bridge fallback: claude-code only. Tail Claude's transcript JSONL so a
+    // turn the model finishes WITHOUT calling `botmux send` still gets its
+    // assistant text forwarded to Lark (the gate in emitReadyTurns suppresses
+    // the emit when a send did happen). Adopt mode wires this up separately
+    // (with baseline-existing); here we use fresh-empty for new sessions so
+    // the file Claude creates on first submit isn't absorbed as history,
+    // and baseline-existing on resume so prior-run turns ARE absorbed (we
+    // don't want to re-emit yesterday's conversation as fresh turns).
+    if (cfg.cliId === 'claude-code' && cfg.sessionId) {
+        const claudeJsonl = claudeJsonlPathForSession(cfg.sessionId, cfg.workingDir);
+        startBridgeWatcher(claudeJsonl, {
+            cliPid: cliPid ?? undefined,
+            cliCwd: cfg.workingDir,
+            mode: cfg.resume ? 'baseline-existing' : 'fresh-empty',
+        });
+    }
+    // Codex bridge fallback: same intent as the Claude block above but a
+    // different transcript layout. Resume-with-known-cliSessionId can attach
+    // immediately; new sessions / resume-without-id rely on flushPending to
+    // late-attach once writeInput returns the cliSessionId.
+    if (cfg.cliId === 'codex') {
+        if (cfg.cliSessionId) {
+            const rolloutPath = findCodexRolloutBySessionId(cfg.cliSessionId);
+            if (rolloutPath) {
+                codexBridgeAttach(rolloutPath, 'baseline-existing');
+            }
+            else {
+                // Resume but the rollout file isn't where we expected — start the
+                // poller so we keep looking; if the user submits and a new file
+                // appears, late-attach kicks in via writeInput's cliSessionId.
+                codexBridgePendingSessionId = cfg.cliSessionId;
+                codexBridgeStartTimer();
+            }
+        }
+        else {
+            // Brand-new Codex session: no path until first submit. Start the
+            // poller anyway so the CLI is ready to attach the moment we have
+            // a cliSessionId.
+            codexBridgeStartTimer();
+        }
+    }
     // Set up idle detection
     idleDetector = new IdleDetector(cliAdapter);
     idleDetector.onIdle(() => {
         log('Prompt detected (idle)');
+        // Bridge drain MUST run before markPromptReady() — the latter calls
+        // flushPending() which can immediately fire the next queued message
+        // (type-ahead adapters), shifting bridgeQueue's notion of "current
+        // turn" before we've had a chance to emit the previous one.
+        if (bridgeJsonlPath) {
+            try {
+                bridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Bridge emit error: ${err.message}`);
+            }
+        }
+        if (codexBridgeFallbackActive()) {
+            try {
+                codexBridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Codex bridge emit error: ${err.message}`);
+            }
+        }
         markPromptReady();
     });
     backend.onData(onPtyData);
@@ -671,6 +1914,11 @@ function killCli() {
     stopScreenUpdates();
     backend?.kill();
     backend = null;
+    // Tear down the bridge watcher (if any). spawnCli will rebuild it on
+    // restart with the proper mode based on the new cfg. Leaving it running
+    // would dangle a watcher pinned to a stale jsonl path.
+    stopBridgeWatcher();
+    stopCodexBridge();
     // Clean up CLI PID marker
     if (cliPidMarker) {
         try {
@@ -703,8 +1951,8 @@ function startWebServer(host, preferredPort) {
             if (hasWrite)
                 authedClients.add(ws);
             log(`WS client connected (total: ${wsClients.size}, write: ${hasWrite})`);
-            if (isTmuxMode && sessionId) {
-                // ── Tmux mode: per-client attach ──
+            if (isTmuxMode && !isPipeMode && sessionId) {
+                // ── Tmux-attach mode: per-client attach ──
                 // Each WS client gets its own `tmux attach-session` PTY.
                 // Scrollback is handled natively by tmux (history-limit).
                 // In adopt mode, attach to the user's original pane; otherwise use bmx-* session.
@@ -864,11 +2112,11 @@ body{display:flex;flex-direction:column}
   color:#565f89;background:#1a1b26cc;padding:2px 8px;border-radius:4px}
 #status.ok{color:#9ece6a}
 #status.err{color:#f7768e}
-#readonly-banner{display:none;position:fixed;top:0;left:0;right:0;z-index:50;
-  padding:6px 12px;text-align:center;font:12px monospace;color:#f7768e;
-  background:rgba(247,118,142,0.12);border-bottom:1px solid rgba(247,118,142,0.35);
-  backdrop-filter:blur(4px);-webkit-backdrop-filter:blur(4px);pointer-events:none}
-#readonly-banner.show{display:block}
+#readonly-banner{display:none;position:fixed;top:8px;left:50%;transform:translateX(-50%);z-index:50;
+  padding:4px 10px;font:12px monospace;color:#f7768e;white-space:nowrap;cursor:pointer;
+  background:rgba(247,118,142,0.12);border:1px solid rgba(247,118,142,0.35);border-radius:4px;
+  backdrop-filter:blur(4px);-webkit-backdrop-filter:blur(4px)}
+#readonly-banner.show{display:inline-block}
 </style>
 </head>
 <body>
@@ -894,7 +2142,7 @@ body{display:flex;flex-direction:column}
 var isTouch='ontouchstart'in window||navigator.maxTouchPoints>0;
 if(isTouch)document.getElementById('vp').content='width=1100,viewport-fit=cover';
 var hasToken=${hasWrite};
-if(!hasToken)document.getElementById('readonly-banner').classList.add('show');
+if(!hasToken){var _rb=document.getElementById('readonly-banner');_rb.classList.add('show');_rb.addEventListener('click',function(){_rb.classList.remove('show')});}
 
 var term=new Terminal({
   theme:{background:'#1a1b26',foreground:'#a9b1d6',cursor:'#c0caf5',
@@ -971,7 +2219,7 @@ window.addEventListener('resize',function(){fit.fit();sendResize()});
 })();
 
 // ── Read-only scroll handling ──
-if(!hasToken&&!${isTmuxMode}){
+if(!hasToken&&!${isTmuxMode && !isPipeMode}){
   // Non-tmux read-only: CLI mouse mode blocks local scroll, override with scrollLines
   document.getElementById('terminal').addEventListener('wheel',function(e){
     e.preventDefault();term.scrollLines(e.deltaY>0?3:-3);
@@ -981,7 +2229,7 @@ if(!hasToken&&!${isTmuxMode}){
 // ── Scroll helper (shared by toolbar buttons & two-finger touch) ──
 function _sendScroll(up,n){
   n=n||3;
-  if(${isTmuxMode}){
+  if(${isTmuxMode && !isPipeMode}){
     // SGR mouse wheel: 64=up 65=down — tmux enters copy-mode and scrolls
     var seq='\\x1b[<'+(up?64:65)+';1;1M';
     for(var i=0;i<n;i++){if(ws_&&ws_.readyState===1)ws_.send(JSON.stringify({type:'input',data:seq}))}
@@ -1070,7 +2318,15 @@ process.on('message', async (raw) => {
             // Capture credentials for direct image upload from worker
             larkAppIdForUpload = msg.larkAppId;
             larkAppSecretForUpload = msg.larkAppSecret;
-            log(`Init: session=${sessionId}, cwd=${msg.workingDir}`);
+            // Resolve render dimensions BEFORE startScreenUpdates() — the
+            // headless xterm and PNG canvas need to know the source pane size
+            // up-front. Setting them later (after the renderer was built at
+            // 160x50) wouldn't unwrap content xterm has already buffered, so
+            // adopt-mode wide-pane content would still come out stair-stepped.
+            const dims = resolveRenderDimensions(msg);
+            renderCols = dims.cols;
+            renderRows = dims.rows;
+            log(`Init: session=${sessionId}, cwd=${msg.workingDir}, render=${renderCols}x${renderRows}${msg.adoptMode ? ' (adopt-pane)' : ''}`);
             try {
                 const port = await startWebServer('0.0.0.0', msg.webPort);
                 startScreenUpdates();
@@ -1079,6 +2335,8 @@ process.on('message', async (raw) => {
                 // Queue the initial prompt — flushed when CLI shows idle.
                 // Adapters with passesInitialPromptViaArgs (e.g. Gemini -i) bake the
                 // prompt into CLI args, so we skip queuing to avoid double-send.
+                // Bridge mark is deferred to flushPending — see flushPending
+                // comment for why marking at enqueue is wrong.
                 if (msg.prompt && !cliAdapter?.passesInitialPromptViaArgs) {
                     pendingMessages.push(msg.prompt);
                 }
@@ -1098,6 +2356,18 @@ process.on('message', async (raw) => {
                 exitTmuxScrollMode();
             const content = msg.content;
             if (lastInitConfig?.adoptMode) {
+                // Bridge mode: capture transcript baseline BEFORE writing to the pane,
+                // so any assistant uuids appended after this point are attributed to
+                // *this* Lark turn (not local user activity in the pane). Mark may
+                // return false (baseline not ready) — we still write to the pane;
+                // user just won't get a final_output for this message.
+                if (bridgeJsonlPath) {
+                    try {
+                        bridgeIngest();
+                    }
+                    catch { /* best effort */ }
+                    bridgeMarkPendingTurn(content);
+                }
                 // Adopt mode: raw write to PTY (no adapter writeInput)
                 if (backend) {
                     if ('sendText' in backend && 'sendSpecialKeys' in backend) {
@@ -1112,6 +2382,11 @@ process.on('message', async (raw) => {
                 }
             }
             else {
+                // Non-adopt: enqueue only. Bridge mark is deferred to flushPending
+                // so markTimeMs anchors to the actual PTY-write moment, not IPC
+                // arrival. Marking now would race with a still-running previous
+                // turn whose `botmux send` could sneak its sentAtMs past this
+                // turn's markTimeMs and falsely suppress its fallback.
                 sendToPty(content);
             }
             break;
@@ -1192,6 +2467,11 @@ process.on('message', async (raw) => {
             // destroySession kills tmux session permanently; kill() only detaches
             backend?.destroySession?.();
             killCli();
+            // Bridge marker file outlives a single CLI process (we keep it across
+            // restarts so a mid-flight send is still credited), but a real close
+            // tears down the session — purge the file so a future re-use of the
+            // same sessionId starts clean.
+            clearSendMarkers();
             cleanup();
             process.exit(0);
         }