botmux 2.9.1 → 2.9.3

package/dist/worker.js

@@ -13,18 +13,30 @@
  *   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, findJsonlsContainingExactContent, findLatestJsonl, extractLastAssistantTurn, extractTurnStartText, splitTranscriptEventsByCutoff } from './services/claude-transcript.js';
+import { BridgeTurnQueue, makeFingerprint, normaliseForFingerprint } from './services/bridge-turn-queue.js';
+import { shouldSuppressBridgeEmit } from './services/bridge-fallback-gate.js';
+import { shouldRunQuietRotation, evaluatePidResolverPullback, decideFingerprintSwitch, sessionIdFromJsonlPath, SESSION_ID_FILENAME_RE, } from './services/bridge-rotation-policy.js';
+import { CodexBridgeQueue } from './services/codex-bridge-queue.js';
+import { drainCodexRollout, findCodexRolloutBySessionId, findCodexRolloutByPid, splitCodexEventsByCutoff, extractLastCodexTurn } from './services/codex-transcript.js';
+import { cocoEventsPathForSession, drainCocoEvents, findCocoSessionByPid } from './services/coco-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 { PtyBackend } from './adapters/backend/pty-backend.js';
+import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds } from './adapters/cli/claude-code.js';
 import { TmuxBackend } from './adapters/backend/tmux-backend.js';
+import { TmuxPipeBackend } from './adapters/backend/tmux-pipe-backend.js';
+import { selectSessionBackend } from './adapters/backend/session-backend-selector.js';
+import { tmuxEnv } from './setup/ensure-tmux.js';
 import { IdleDetector } from './utils/idle-detector.js';
 import { ScreenAnalyzer } from './utils/screen-analyzer.js';
 import { captureToPng } from './utils/screenshot-renderer.js';
+import { snapshotToPng, snapshotToText } from './utils/transient-snapshot.js';
 import { uploadImageBuffer } from './utils/lark-upload.js';
 import { config } from './config.js';
 import * as sessionStore from './services/session-store.js';
@@ -36,6 +48,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,15 +67,1571 @@ 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 pid-state record. Empirical
+ *  scope (Claude Code 2.1.123): the pid file's `sessionId` is set ONCE at
+ *  process start. `--resume` (which spawns a new process) does rotate the
+ *  recorded sessionId; `/clear` / in-pane `/resume` do NOT — those rely on
+ *  the fingerprint fallback (which anchors on a pending Lark turn) to
+ *  follow the new jsonl. */
+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;
+/** Sibling-pane hijack guard state.
+ *
+ *  Every sessionId we have evidence of belonging to our adopted Claude pid:
+ *  initial attach path, pid resolver hits, `/proc/<pid>/fd` hits. The
+ *  fingerprint fallback's two-phase decision (`decideFingerprintSwitch`
+ *  in `src/services/bridge-rotation-policy.ts`) consumes this set:
+ *  Phase 1 substring match runs against trusted sids only; Phase 2
+ *  exact-content recovery runs against UNTRUSTED sids only. Unknown
+ *  sessionIds never pass Phase 1 even when the file looks freshly
+ *  created — freshness/timestamp signals cannot prove pane ownership
+ *  across siblings in the same project dir. */
+const bridgeKnownSessionIds = new Set();
+/** Set when the fingerprint fallback accepts a candidate whose sessionId
+ *  doesn't match the pid file's current sessionId (Claude's pid file isn't
+ *  refreshed by in-pane `/clear`, so it keeps reporting the spawn-time sid
+ *  even after the user rotated). Suppresses pid resolver from pulling the
+ *  watcher back to that spawn-time sid every tick. Cleared when pid file
+ *  reports a NEW sid (fresh `--resume` / spawn), at which point a real
+ *  rotation has happened and we should follow it. */
+let bridgeStalePidStateSessionId;
+/** 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;
+/** Adopt-only: PID of the externally-running Codex process. Used by the
+ *  poller to fall back to /proc/<pid>/fd discovery when sessionId is
+ *  unknown (e.g. discovery probe missed the rollout fd). */
+let codexAdoptPendingPid;
+/** Adopt-only: wall-clock millis at adopt-spawn time. Late-attach uses
+ *  this as the cutoff for splitting an existing rollout into "history"
+ *  (absorb) vs "live" (ingest) — so events the user produced AFTER adopt
+ *  but BEFORE the rollout was located still reach the Lark thread. 5s
+ *  skew tolerance is applied on top, mirroring the Lark/Claude bridges. */
+let codexAdoptStartMs;
+/** Adopt-only: 一次性发送的 "/adopt 前最后一轮" preamble 是否已经触发过。
+ *  codexBridgeAttach 在 split-live 分支会查 history 取最后一对 user/assistant
+ *  发给 daemon —— late-attach poller 也会反复走这条分支（每秒一次），所以
+ *  必须有标志位防重发。镜像 claude 那套 bridgePreambleSent 的角色。 */
+let codexBridgePreambleSent = false;
+/** 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) + '…';
+}
+/** Prepare a local-turn `final_output` payload. The daemon owns the card
+ *  chrome (label/quote/markdown body), so we ship the user prompt and
+ *  assistant text as separate fields — see card-builder `buildContextualReplyCard`.
+ *  Returns null when both sides are empty so the caller can skip the emit. */
+function formatLocalTurnFields(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 { userText: u, content: a };
+}
+/** Same as `formatLocalTurnFields` but for HEADLESS local turns — daemon
+ *  restart cut off an in-flight model stream so we have an assistant side
+ *  with no resolvable user prompt. */
+function formatHeadlessLocalTurnContent(assistantText) {
+    const a = truncatePreambleText(assistantText.trim(), LOCAL_TURN_ASSISTANT_MAX);
+    return a || null;
+}
+// ─── 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;
+    // Same logic for /adopt sessions restored after a daemon restart: the
+    // Lark thread already has every prior turn pushed as cards, AND the
+    // baseline jsonl persisted in session metadata may be stale (Claude
+    // could have /clear'd since the original /adopt), so a preamble here
+    // would surface old, out-of-context content.
+    if (lastInitConfig?.adoptRestoredFromMetadata)
+        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)');
+}
+/** Codex / CoCo 镜像版：split-live 攒齐 history 后挑最后一对 user/assistant_final
+ *  发回 daemon 渲染成 "📜 /adopt 前最后一轮" 卡片。语义、跳过条件、字数截断都
+ *  对齐 maybeEmitAdoptPreamble；区别只在事件取出方式（codex/coco 是结构化
+ *  event，不需要走 claude 那套 jsonl turn assembly）。 */
+function maybeEmitCodexAdoptPreamble(history) {
+    if (!lastInitConfig?.adoptMode)
+        return;
+    if (lastInitConfig?.adoptRestoredFromMetadata)
+        return;
+    if (codexBridgePreambleSent)
+        return;
+    const turn = extractLastCodexTurn(history);
+    if (!turn)
+        return;
+    if (!turn.userText.trim() && !turn.assistantText.trim())
+        return;
+    codexBridgePreambleSent = true;
+    send({
+        type: 'adopt_preamble',
+        userText: truncatePreambleText(turn.userText, PREAMBLE_USER_MAX),
+        assistantText: truncatePreambleText(turn.assistantText, PREAMBLE_ASSISTANT_MAX),
+    });
+    log('Codex bridge adopt preamble emitted (last completed turn from split-live history)');
+}
+/** Extract the sessionId from a Claude jsonl path and add it to the
+ *  known-sid set. Validates the filename against Claude's UUID-shaped
+ *  sessionId pattern so non-Claude jsonls in the project dir (accidental
+ *  drops, third-party tooling) can't poison the trust set. No-op on
+ *  parse failure. */
+function bridgeRememberSessionIdForPath(path) {
+    if (!path)
+        return;
+    const sid = sessionIdFromJsonlPath(path);
+    if (!SESSION_ID_FILENAME_RE.test(sid))
+        return;
+    bridgeKnownSessionIds.add(sid);
+}
+/** Cheap per-tick probe: read /proc/<bridgeCliPid>/fd and add every jsonl
+ *  the adopted Claude pid currently has open into the known-sid set. fd
+ *  observation is intermittent (Claude opens-writes-closes per event), so
+ *  running this every tick raises our chances of catching a post-/clear
+ *  sessionId before the user's next Lark message arrives. No-op when there
+ *  is no pid or /proc isn't available. */
+function bridgeProbeOpenSessionIds() {
+    if (bridgeCliPid === undefined || !bridgeJsonlDir)
+        return;
+    const opened = findOpenJsonlsForPid(bridgeCliPid, bridgeJsonlDir);
+    for (const path of opened)
+        bridgeRememberSessionIdForPath(path);
+}
+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);
+}
+/** Record `bridgeStalePidStateSessionId` if the pid file's current sid
+ *  disagrees with the just-accepted candidate's sid. Stops the next pid
+ *  resolver tick from pulling the watcher back to the stale spawn-time
+ *  path Claude wrote into the pid file — which it never refreshes on
+ *  in-pane `/clear`. No-op when pid file is unavailable or already
+ *  agrees. */
+function bridgeMarkStalePidStateForAcceptedSid(acceptedSid) {
+    if (bridgeCliPid === undefined || bridgeCliCwd === undefined)
+        return;
+    const pidResolved = resolveJsonlFromPid(bridgeCliPid, bridgeCliCwd);
+    if (pidResolved && pidResolved.cliSessionId !== acceptedSid) {
+        bridgeStalePidStateSessionId = pidResolved.cliSessionId;
+    }
+}
+/** Apply a fingerprint-driven switch: drain old path, retire watcher,
+ *  pivot bridgeJsonlPath to `matched`, split the new path's existing
+ *  content by `cutoffMs` (history → absorbed into the seen set, live →
+ *  ingested), and install a new fs.watch. The split-live step is what
+ *  prevents the "switched into a long-lived /clear file → all prior
+ *  iTerm-typed turns get re-emitted as 🖥️ 终端本地对话" symptom: any
+ *  user/assistant events written before the Lark mark are pre-existing
+ *  pane history, not events to forward. `cutoffMs` should be the same
+ *  `markTimeMs - 5s` used for the fingerprint scan's lower bound. */
+function bridgeApplyFingerprintSwitch(matched, reason, cutoffMs) {
+    // 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} (${reason})`);
+    if (bridgeWatcher) {
+        try {
+            bridgeWatcher.close();
+        }
+        catch { /* ignore */ }
+        bridgeWatcher = null;
+    }
+    // Critically: do NOT clear pending turns. The switch was triggered by
+    // 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;
+    bridgeJsonlDir = dirname(matched);
+    bridgePendingTail = '';
+    // Split-live: drain `matched` from offset 0, partition by cutoffMs.
+    // History (pre-mark) is absorbed into the seen set so the iTerm-side
+    // turns the user accumulated before this Lark message DON'T re-emit
+    // as "🖥️ 终端本地对话" cards. Live (post-mark) goes through ingest
+    // so the Lark fingerprint can start its turn. Mirrors what
+    // performRotationSwitch already does for fd-rotation rotations.
+    const drained = drainTranscript(matched, 0);
+    bridgeOffset = drained.newOffset;
+    bridgePendingTail = drained.pendingTail;
+    const { history, live } = splitTranscriptEventsByCutoff(drained.events, cutoffMs);
+    bridgeQueue.absorb(history);
+    if (live.length > 0)
+        bridgeQueue.ingest(live, matched);
+    bridgeBaselineDone = true;
+    log(`Bridge fingerprint switch split: ${history.length} historical events absorbed, ${live.length} live events ingested (cutoff=${cutoffMs})`);
+    bridgeRememberSessionIdForPath(matched);
+    bridgeMarkStalePidStateForAcceptedSid(sessionIdFromJsonlPath(matched));
+    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`);
+    }
+}
+/** Detect /clear / /resume: when Claude Code starts a new session in the
+ *  user's pane it writes to a brand-new sessionId.jsonl. Two-phase scan:
+ *
+ *  - Phase 1 (known-sid substring): cheap path for trusted candidates
+ *    only. Same content fingerprint substring search as before — safe
+ *    here because we've gated it on the pid-derived trust set, so a
+ *    sibling pane in the same project dir (different sessionId) can
+ *    never be the match even when its content includes the fingerprint.
+ *
+ *  - Phase 2 (unknown-sid exact-content recovery): in-pane `/clear`
+ *    creates a new sessionId Claude does NOT write into its pid file.
+ *    If the fd probe didn't catch the brief open window, the new sid is
+ *    untrusted and Phase 1 rejects it. Phase 2 falls back to scanning
+ *    every UNTRUSTED candidate jsonl for a user/queue event whose
+ *    NORMALISED content equals our just-marked Lark message in full
+ *    (not a substring) — strong enough that "test" doesn't false-match
+ *    "run tests". When exactly one untrusted candidate matches, accept
+ *    it; when multiple match, abstain and surface an unambiguous log
+ *    line so the user can take recovery action.
+ *
+ *  Pending turns are preserved across the switch so the next ingest
+ *  can match and start the turn in the new file. */
+/** Per-fingerprint rate limit for the full-directory fingerprint scan.
+ *  Without this, a wedged pending turn (e.g. writeInput's Enter eaten by a
+ *  Claude TUI prompt so the user line never lands in any jsonl) drives this
+ *  function every 1s from the fallback timer and every idle tick — each
+ *  call reads the trailing 1MB of every jsonl in the project dir (hundreds
+ *  of files, 100s of MB total), pegging the worker at 99% CPU until
+ *  restart. The cleanup paths in #1/#2 (dropPendingTurn / pruneExpired)
+ *  are what actually *removes* the stuck mark; this rate limit just keeps
+ *  the windows in between cheap.
+ *
+ *  10s is much wider than the milliseconds Claude needs to write a normal
+ *  user line, but `maybeSwitchBridgeJsonl` is only consulted when the
+ *  primary jsonl scan in `bridgeIngest` already failed to find the line —
+ *  i.e. Claude rotated the file via `/clear` / `/resume`. Those rotations
+ *  happen hours apart in practice, so a 10s detection delay is invisible. */
+const BRIDGE_FINGERPRINT_SCAN_MIN_INTERVAL_MS = 10_000;
+const bridgeFingerprintScanLastMs = new Map();
+/** Pending+unstarted bridge marks expire after this long. Defensive TTL:
+ *  every known path that creates a mark also has an explicit
+ *  `dropPendingTurn` path, but TTL guarantees self-healing if a future
+ *  code path forgets one. 120s is well past Claude's deferred recheck
+ *  window (20s) and any plausible jsonl-flush delay; the only marks left
+ *  this long are real failures. */
+const BRIDGE_PENDING_TURN_TTL_MS = 120_000;
+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;
+    // Per-fingerprint rate limit — see BRIDGE_FINGERPRINT_SCAN_MIN_INTERVAL_MS.
+    const lastScan = bridgeFingerprintScanLastMs.get(candidate.contentFingerprint);
+    const now = Date.now();
+    if (lastScan !== undefined && now - lastScan < BRIDGE_FINGERPRINT_SCAN_MIN_INTERVAL_MS) {
+        return false;
+    }
+    bridgeFingerprintScanLastMs.set(candidate.contentFingerprint, now);
+    // 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 fingerprintScanOptions = {
+        excludePath: bridgeJsonlPath,
+        includeQueueOperations: true,
+        minEventTimestampMs,
+    };
+    const decision = decideFingerprintSwitch({
+        contentFingerprint: candidate.contentFingerprint,
+        contentNormalized: candidate.contentNormalized,
+        knownSessionIds: bridgeKnownSessionIds,
+        findSubstring: (acceptCandidate) => findJsonlContainingFingerprint(bridgeJsonlDir, candidate.contentFingerprint, {
+            ...fingerprintScanOptions,
+            acceptCandidate,
+        }),
+        findExact: (acceptCandidate) => candidate.contentNormalized
+            ? findJsonlsContainingExactContent(bridgeJsonlDir, candidate.contentNormalized, {
+                ...fingerprintScanOptions,
+                acceptCandidate,
+            })
+            : [],
+    });
+    if (decision.action === 'switch') {
+        const reason = decision.reason === 'known-sid-substring'
+            ? 'known-sid fingerprint match'
+            : 'unknown-sid exact-content recovery (in-pane /clear with stale pid file)';
+        // Boundary alignment with the fingerprint scanner:
+        //
+        //   scanner.minEventTimestampMs is INCLUSIVE — events with
+        //     timestamp >= (markTimeMs - 5s) are eligible to start the turn.
+        //   splitTranscriptEventsByCutoff puts timestamp <= cutoffMs in
+        //     history (absorbed) and > cutoffMs in live (ingested).
+        //
+        // If we hand split the same value as the scanner's lower bound, an
+        // event AT exactly that timestamp (e.g. the user's just-arrived
+        // Lark user event) is matched-eligible by the scanner — driving
+        // the switch — but absorbed as history by split, leaving the
+        // pending turn unstarted and the message silent. Subtract 1ms to
+        // make split's history strictly older than the scanner's
+        // eligibility floor.
+        const historyCutoffMs = ((candidate.markTimeMs ?? Date.now()) - 5_000) - 1;
+        bridgeApplyFingerprintSwitch(decision.path, reason, historyCutoffMs);
+        return true;
+    }
+    if (decision.action === 'abstain') {
+        log(`Bridge fingerprint switch ABSTAINED (${decision.reason}): ${decision.candidates.length} unknown jsonls have an exact-content match for the pending Lark turn (${decision.candidates.join(', ')}). User should re-/adopt or send a longer disambiguating message.`);
+        return false;
+    }
+    return false;
+}
+/** Last-resort rotation follower for the case where pid resolver returned
+ *  `'unavailable'` (no /proc, missing/invalid pid file). Originally also
+ *  ran on `'same'` to catch in-pane `/clear` with no pending Lark turn,
+ *  but that path is now intentionally dropped — the directory-mtime
+ *  heuristic in Path 2 below cannot tell our pane's rotation from a
+ *  sibling Claude pane in the same cwd, and the sibling-pane hijack
+ *  silently corrupts every multi-pane adopt setup (see
+ *  `bridge-rotation-policy.ts`). The Lark-message-driven /clear recovery
+ *  flow (fingerprint fallback) covers the dominant case.
+ *
+ *  Detection priority:
+ *    1. Linux first-class: read `/proc/<pid>/fd` and pick the .jsonl the
+ *       adopted Claude process actually has open. Bound to the real PID
+ *       — a sibling Claude pane has a different PID and cannot hijack
+ *       the result. Note: Claude Code opens-writes-closes per event, so
+ *       this often returns 0 entries between writes; the gate above
+ *       ensures we still skip Path 2 in that case when pid resolver
+ *       confirmed our path.
+ *    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. Only
+ *       runs when Path 1 returns 0 entries AND pid resolver was
+ *       unavailable.
+ *
+ *  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 a rotation
+ *  to a long-history jsonl NOT replay the entire past as one giant
+ *  local turn.
+ *
+ *  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, live } = splitTranscriptEventsByCutoff(result.events, cutoffMs);
+    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) {
+        // Every fd-observed jsonl belongs to our pid — feed all of them
+        // into the sibling-pane hijack guard's trust list, not just the
+        // newest. This is how a post-/clear sessionId enters the trust
+        // set: Claude opens the new jsonl briefly during the /clear
+        // handshake; if a fd probe lands in that window, fingerprint
+        // fallback can later accept the new sessionId on the user's next
+        // Lark message.
+        for (const path of opened)
+            bridgeRememberSessionIdForPath(path);
+        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 plus a trust-set filter on candidates.
+    //
+    // Without the trust-set filter, an actively-written sibling Claude pane
+    // in the same project dir always wins the mtime race; pid resolver then
+    // pulls the watcher back to our own (idle) jsonl on the next tick,
+    // re-arming the same condition. Result: 1 Hz path-flap that pegs CPU
+    // for as long as the sibling keeps writing (observed: 8 days, 6896
+    // switches on a single worker). Only candidates whose sid lives in
+    // `bridgeKnownSessionIds` (populated from initial attach, pid resolver
+    // hits, fd probes) are eligible — sibling sids are rejected.
+    const now = Date.now();
+    if (now - currentStat.mtimeMs < QUIET_ROTATION_MS)
+        return;
+    const latest = findLatestJsonl(bridgeJsonlDir, {
+        acceptCandidate: (path) => {
+            const sid = sessionIdFromJsonlPath(path);
+            return SESSION_ID_FILENAME_RE.test(sid) && bridgeKnownSessionIds.has(sid);
+        },
+    });
+    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)`);
+}
+/** Pid-state rotation follow: re-read ~/.claude/sessions/<cliPid>.json
+ *  and switch bridgeJsonlPath whenever the recorded sessionId differs
+ *  from what we're watching. Same source as the writeInput pid resolver,
+ *  with the same cwd + procStart validation.
+ *
+ *  Empirical scope (Claude Code 2.1.123): the pid file's `sessionId` is
+ *  written ONCE at process start. `--resume` rewrites it (it's a fresh
+ *  spawn → fresh pid file). In-pane `/clear` does NOT rewrite it —
+ *  `updatedAt` and `status` change but `sessionId` stays. So this probe
+ *  catches spawn-time / `--resume` rotations; `/clear` (and in-pane
+ *  `/resume` if Claude treats it the same) is left to the fingerprint
+ *  fallback that anchors on a pending Lark turn. Returns a tri-state
+ *  result rather than a bool so the caller can distinguish 'switched'
+ *  (we moved) from 'same' (path confirmed) from 'unavailable' (no
+ *  reliable answer) — the downstream gates use that distinction. */
+/** Tri-state result so callers can distinguish "pid file unreadable, fall
+ *  back to fingerprint heuristic" from "pid file confirmed current path"
+ *  vs "pid file said rotate to a new path".
+ *
+ *  Used by two downstream gates:
+ *  - Fingerprint fallback (`maybeSwitchBridgeJsonl`): runs whenever the
+ *    pid resolver did not actively switch (`!= 'switched'`). Safe even
+ *    on `'same'` because the fingerprint scan requires a pending Lark
+ *    turn — no risk of hijacking to a sibling pane.
+ *  - Quiet-mtime fallback (`maybeFollowQuietRotation`): runs only on
+ *    `'unavailable'`. The mtime heuristic can't distinguish our pane's
+ *    rotation from a sibling pane in the same cwd, so even when pid
+ *    resolver's `'same'` is not proof against in-process /clear (it
+ *    isn't — Claude doesn't refresh `sessionId` on /clear), we still
+ *    skip the heuristic. The cost is that a pure-local /clear with no
+ *    pending Lark turn won't auto-follow until the user sends a Lark
+ *    message; the alternative (running mtime fallback on 'same') would
+ *    silently corrupt every multi-pane adopt setup.
+ *
+ *  Type imported from `./services/bridge-rotation-policy` — the gate
+ *  function lives there so it's testable without dragging worker fs/IPC
+ *  side-effects into the unit suite. */
+function maybeFollowSessionRotationViaPid() {
+    if (!bridgeCliPid || !bridgeCliCwd)
+        return 'unavailable';
+    const resolved = resolveJsonlFromPid(bridgeCliPid, bridgeCliCwd);
+    if (!resolved)
+        return 'unavailable';
+    if (bridgeObservedCliSessionId !== resolved.cliSessionId) {
+        bridgeObservedCliSessionId = resolved.cliSessionId;
+    }
+    // Pid resolver always reports the spawn-time sessionId — this is a sid
+    // that genuinely belongs to our adopted Claude pid, so remember it for
+    // the sibling-pane hijack guard.
+    bridgeRememberSessionIdForPath(resolved.path);
+    if (resolved.path === bridgeJsonlPath)
+        return 'same';
+    // Stale-pid suppression: when the fingerprint fallback accepted a
+    // post-/clear jsonl (Claude's pid file isn't refreshed by in-pane
+    // /clear, so it keeps reporting the spawn-time sid), pid resolver
+    // would otherwise pull the watcher back to that spawn-time sid every
+    // tick — re-creating the flap loop the user reported. The decision
+    // lives in `bridge-rotation-policy.evaluatePidResolverPullback` so
+    // the four-cell matrix can be unit-tested in isolation.
+    const pullback = evaluatePidResolverPullback({
+        resolvedCliSessionId: resolved.cliSessionId,
+        resolvedPath: resolved.path,
+        currentBridgeJsonlPath: bridgeJsonlPath,
+        stalePidStateSessionId: bridgeStalePidStateSessionId,
+    });
+    if (pullback.clearStale)
+        bridgeStalePidStateSessionId = undefined;
+    if (pullback.suppress)
+        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() {
+    // Defensive TTL: sweep any pending+unstarted mark whose Lark message
+    // never matched a user line in the transcript (writeInput failure
+    // surface that didn't get caught, future paths that forget to call
+    // dropPendingTurn). Without this, a stranded mark drives
+    // `maybeSwitchBridgeJsonl` to do full-directory jsonl scans every tick
+    // until daemon restart — the 99% CPU bug. The explicit dropPendingTurn
+    // path in scheduleSubmitFailureNotify handles the known offender;
+    // this catches everything else.
+    const expired = bridgeQueue.pruneExpired(BRIDGE_PENDING_TURN_TTL_MS);
+    for (const t of expired) {
+        if (t.contentFingerprint)
+            bridgeFingerprintScanLastMs.delete(t.contentFingerprint);
+        log(`Bridge mark expired after ${Math.round(BRIDGE_PENDING_TURN_TTL_MS / 1000)}s without matching a jsonl user line (turnId=${t.turnId}) — dropped to prevent rotation-fallback scan loop.`);
+    }
+    // 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();
+    // Cheap probe: catch any jsonls our adopted pid currently has open
+    // and add their sessionIds to the sibling-pane hijack guard's trust
+    // list. Runs every tick (independent of rotation gates) because
+    // Claude opens-writes-closes the jsonl per event — fd observation
+    // is therefore intermittent, and more ticks = more chances to
+    // catch a post-/clear sessionId. This is the only hook by which
+    // an in-pane /clear becomes followable: without an fd-probe hit
+    // the fingerprint fallback will reject the new (unknown) sessionId
+    // and the user must re-adopt to recover.
+    bridgeProbeOpenSessionIds();
+    // 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. Empirically (verified
+    // on Claude Code 2.1.123) the pid file's `sessionId` field is set
+    // ONCE at process start; /clear refreshes `updatedAt` but does NOT
+    // rewrite `sessionId`, 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. Sibling-pane hijack protection is
+    // NOT delegated to the markTimeMs-5s event filter (short fingerprints
+    // substring-match unrelated content like "test" → "run tests"); the
+    // real gate is the sibling guard inside `maybeSwitchBridgeJsonl` that
+    // rejects every candidate whose sessionId isn't in the pid-derived
+    // trust set.
+    let switched = pidFollow === 'switched';
+    if (!switched) {
+        switched = maybeSwitchBridgeJsonl();
+    }
+    // Quiet-rotation fallback: directory-mtime heuristic that picks the
+    // newest jsonl in the same project dir when our current path goes
+    // quiet. Originally the safety net for "user runs /clear purely in
+    // iTerm with no pending Lark turn, so fingerprint fallback can't
+    // anchor on anything". Trade-off: when the user has a SIBLING Claude
+    // pane in the same cwd, that pane's busier jsonl always wins this
+    // race and the bridge gets hijacked, ingesting the sibling pane's
+    // user/assistant events as `isLocal: true` local turns and forwarding
+    // them to the adopted Lark thread (the user-reported "/adopt 一对话
+    // 出来一堆历史会话" symptom).
+    //
+    // We accept the asymmetry: sibling-pane hijack is silent, persistent
+    // and corrupts every adopted multi-pane setup; pure-local /clear
+    // without a pending Lark turn is a narrow corner case the user can
+    // unstick by sending one Lark message (which arms fingerprint
+    // fallback). So we ONLY consult the mtime heuristic when the pid
+    // probe was unavailable (non-Linux, missing/invalid pid file).
+    if (shouldRunQuietRotation(pidFollow, 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';
+    // Pid-state record ranks above the path the adopt scan computed. If
+    // Claude was launched with `--resume` (or the adopt scan picked a
+    // stale jsonl), the pid file points at the actual current sessionId
+    // and we swap to it 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;
+            bridgeRememberSessionIdForPath(resolved.path);
+            if (resolved.path !== bridgeJsonlPath) {
+                log(`Bridge transcript adjusted at start (pid resolver): ${bridgeJsonlPath} → ${resolved.path}`);
+                bridgeJsonlPath = resolved.path;
+                bridgeJsonlDir = dirname(resolved.path);
+            }
+        }
+    }
+    // fd probe at start: the pid file's `sessionId` is set ONCE at Claude's
+    // process start and is NOT refreshed by in-pane `/clear`. So if the user
+    // /clear'd between the original /adopt and this worker spawn (most
+    // commonly: daemon restart that restored a long-lived adopt session),
+    // pid resolver still points at the spawn-time jsonl while Claude has
+    // rotated to a new one. `/proc/<pid>/fd` shows what Claude *currently*
+    // has open — bound to our pid, so no sibling-pane hijack risk.
+    //
+    // Two signals matter: direct `.jsonl` fd (only present during a write
+    // window — Claude opens-writes-closes per event) and `~/.claude/tasks/
+    // <sid>` symlinks (Claude holds the tasks dir + its .lock file open
+    // continuously for the active session, so this catches the rotation
+    // even between writes). `findOpenClaudeSessionIds` unions both.
+    if (bridgeCliPid !== undefined && bridgeJsonlDir && bridgeCliCwd) {
+        const sids = findOpenClaudeSessionIds(bridgeCliPid);
+        const candidates = [];
+        for (const sid of sids) {
+            const path = claudeJsonlPathForSession(sid, bridgeCliCwd);
+            bridgeRememberSessionIdForPath(path);
+            if (existsSyncSafe(path))
+                candidates.push(path);
+        }
+        if (candidates.length > 0) {
+            const newest = newestPath(candidates);
+            if (newest && newest !== bridgeJsonlPath) {
+                log(`Bridge transcript adjusted at start (pid fd probe — Claude rotated since worker spawn): ${bridgeJsonlPath} → ${newest}`);
+                bridgeJsonlPath = newest;
+                bridgeJsonlDir = dirname(newest);
+                // Pid file's sessionId disagrees with the path Claude actually has
+                // open — record it as stale so the per-tick pid resolver doesn't
+                // pull us back to the spawn-time jsonl on every poll.
+                bridgeMarkStalePidStateForAcceptedSid(sessionIdFromJsonlPath(newest));
+            }
+        }
+    }
+    // Remember the initial path's sessionId — this is the ground-truth
+    // anchor for the sibling-pane hijack guard. Subsequent fingerprint
+    // candidates are accepted only if their sessionId is in this set
+    // (populated here, by pid resolver hits, and by per-tick fd probes).
+    bridgeRememberSessionIdForPath(bridgeJsonlPath);
+    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;
+    bridgeKnownSessionIds.clear();
+    bridgeStalePidStateSessionId = undefined;
+    bridgeSecondaryPaths.clear();
+    bridgeFingerprintScanLastMs.clear();
+    bridgePreambleSent = false;
+}
+/**
+ * Push a pending turn for the next Lark message.
+ *
+ * Returns the turnId on success, undefined if bridge-final-output isn't
+ * available for this message (transcript not yet baselined). On undefined
+ * 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.
+ *
+ * The turnId is returned so the writeInput failure path can call
+ * `bridgeQueue.dropPendingTurn(turnId)` after deferred recheck conclusively
+ * fails — otherwise an Enter-eaten-by-TUI submit leaves a fingerprint that
+ * no jsonl line will ever match, and `maybeSwitchBridgeJsonl` burns 99%
+ * CPU scanning all sibling jsonls for it on every poll tick.
+ */
+function bridgeMarkPendingTurn(messageText) {
+    if (!bridgeJsonlPath)
+        return undefined;
+    if (!bridgeBaselineDone) {
+        log('Bridge baseline not ready — this turn will not have transcript-driven final_output');
+        return undefined;
+    }
+    const fingerprint = makeFingerprint(messageText);
+    // Full normalised content powers the unknown-sid recovery path. When a
+    // user runs `/clear` and the bridge can't see the new sessionId yet
+    // (pid file lags, fd probe missed the brief open window), we fall back
+    // to scanning every untrusted candidate jsonl for an EXACT equality
+    // with this normalised string — substantially harder for a sibling
+    // pane to false-match than the 30-char substring fingerprint.
+    const normalised = normaliseForFingerprint(messageText);
+    const contentNormalized = normalised.length > 0 ? normalised : undefined;
+    const turnId = randomBytes(8).toString('hex');
+    bridgeQueue.mark(turnId, fingerprint, Date.now(), contentNormalized);
+    return turnId;
+}
+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) {
+            if (turn.userUuid) {
+                // 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.
+                // extractTurnStartText handles both `role:user` events (text in
+                // message.content) AND `attachment(queued_command)` events (text in
+                // attachment.prompt) so type-ahead'd local input renders the same as
+                // a normally-typed pane prompt.
+                const userEv = drained.events.find(e => e.uuid === turn.userUuid);
+                const rawUserText = userEv ? extractTurnStartText(userEv) : '';
+                const fields = formatLocalTurnFields(rawUserText, assistantText);
+                if (!fields)
+                    continue;
+                send({
+                    type: 'final_output',
+                    content: fields.content,
+                    lastUuid,
+                    turnId: turn.turnId,
+                    kind: 'local-turn',
+                    userText: fields.userText,
+                });
+                continue;
+            }
+            // Headless local turn — see formatHeadlessLocalTurnContent for context.
+            const headlessContent = formatHeadlessLocalTurnContent(assistantText);
+            if (!headlessContent)
+                continue;
+            send({
+                type: 'final_output',
+                content: headlessContent,
+                lastUuid,
+                turnId: turn.turnId,
+                kind: 'local-turn-headless',
+            });
+            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() {
+    // True for transcript-backed CLIs whose final output can be harvested
+    // from append-only JSONL when the model forgets to call `botmux send`.
+    // Codex uses ~/.codex rollouts; CoCo uses ~/.cache/coco events. Both
+    // work in adopt mode now that CoCo's PID→sessionId discovery is wired.
+    return lastInitConfig?.cliId === 'codex' || lastInitConfig?.cliId === 'coco';
+}
+function structuredBridgeIsCodex() {
+    return lastInitConfig?.cliId === 'codex';
+}
+function structuredBridgeIngestPath(path, offset) {
+    return structuredBridgeIsCodex()
+        ? drainCodexRollout(path, offset)
+        : drainCocoEvents(path, offset);
+}
+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) {
+                // Two discovery paths, in order: cliSessionId (known via writeInput
+                // result for non-adopt or daemon-side probe for adopt) → exact
+                // file by name; PID (adopt only) → walk /proc/<pid>/fd. Adopt
+                // attaches via split-live (history absorbed, live ingested);
+                // non-adopt uses fresh-empty (queue's markTimeMs - 5s lower bound
+                // gates historical fingerprint matches without needing a split).
+                // Discovery primitives differ per CLI: codex walks ~/.codex/sessions
+                // by sid suffix; CoCo's events.jsonl path is deterministic from
+                // sid, so the lookup is just a path computation + existence check.
+                const isCoco = lastInitConfig?.cliId === 'coco';
+                let path;
+                if (codexBridgePendingSessionId) {
+                    path = isCoco
+                        ? cocoEventsPathForSession(codexBridgePendingSessionId)
+                        : findCodexRolloutBySessionId(codexBridgePendingSessionId);
+                    if (path && isCoco && !existsSync(path))
+                        path = undefined;
+                }
+                if (!path && codexAdoptPendingPid) {
+                    if (isCoco) {
+                        const probed = findCocoSessionByPid(codexAdoptPendingPid);
+                        if (probed && existsSync(probed.eventsPath))
+                            path = probed.eventsPath;
+                    }
+                    else {
+                        const probed = findCodexRolloutByPid(codexAdoptPendingPid);
+                        if (probed)
+                            path = probed.path;
+                    }
+                }
+                if (path) {
+                    codexBridgePendingSessionId = undefined;
+                    codexAdoptPendingPid = undefined;
+                    // Adopt mode: split-live partitions drained events by
+                    // codexAdoptStartMs so anything the user did AFTER adopt but
+                    // BEFORE we found the rollout still emits (history is absorbed,
+                    // live is ingested). Non-adopt: fresh-empty as before — queue's
+                    // markTimeMs - 5s lower bound is enough since there's no
+                    // local-turn synthesis on that path.
+                    const mode = lastInitConfig?.adoptMode ? 'split-live' : 'fresh-empty';
+                    codexBridgeAttach(path, mode);
+                }
+            }
+            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 (mode === 'split-live' && existsSync(rolloutPath)) {
+        // Adopt mode: drain everything, then split by adoptStartMs. History
+        // (pre-adopt) is `absorb()`-ed so it can't replay; live (post-adopt)
+        // is `ingest()`-ed so a Lark turn already marked or an iTerm-typed
+        // local turn that landed before we found the rollout still gets
+        // attributed. Without this split, baseline-existing would absorb()
+        // the live events too, silently dropping anything the user did
+        // between adopt and rollout-discovery — that's the user-reported
+        // "iTerm 手动输入飞书没收到" symptom under late-attach.
+        const result = structuredBridgeIngestPath(rolloutPath, 0);
+        const cutoff = (codexAdoptStartMs ?? Date.now()) - 5_000;
+        const { history, live } = splitCodexEventsByCutoff(result.events, cutoff);
+        codexBridgeQueue.absorb(history);
+        codexBridgeQueue.ingest(live);
+        codexBridgeOffset = result.newOffset;
+        codexBridgePendingTail = result.pendingTail;
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge split-live: ${rolloutPath} (history=${history.length}, live=${live.length}, cutoff=${cutoff}, offset=${codexBridgeOffset})`);
+        maybeEmitCodexAdoptPreamble(history);
+    }
+    else if (mode === 'split-live') {
+        // split-live requested but file missing — degrade to fresh: the file
+        // will appear later via fs.watch / poller, and ingest from offset 0
+        // will pick up everything as live (consistent with split semantics
+        // when there's no history to absorb).
+        codexBridgeOffset = 0;
+        codexBridgePendingTail = '';
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge split-live degraded to fresh (file missing): ${rolloutPath}`);
+    }
+    else if (existsSync(rolloutPath)) {
+        const result = structuredBridgeIngestPath(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`);
+    }
+    // macOS 上 fs.watch 对 codex/coco 的外部进程追加 rollout / events.jsonl
+    // 经常静默丢事件（FSEvents 跨进程不可靠），所以无论 watcher 是否 attach
+    // 成功，都必须起 1s poller 兜底 —— 不然 split-live 成功的 adopt session
+    // 在 macOS 上会卡死，永远收不到模型回复。Linux 上 poller 多 tick 也无害
+    // （codexBridgeIngest 在 offset 未推进时是 no-op）。
+    codexBridgeStartTimer();
+}
+/** 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 = structuredBridgeIngestPath(codexBridgeRolloutPath, codexBridgeOffset);
+    codexBridgeOffset = result.newOffset;
+    codexBridgePendingTail = result.pendingTail;
+    codexBridgeQueue.ingest(result.events);
+    // Transcript-driven idle: an `assistant_final` event is the CLI declaring
+    // end-of-turn, far more reliable than the screen-pattern heuristic
+    // (CoCo's status bar varies by --yolo flag, version, theme; codex has
+    // its own moving targets). Pushing idle here lets the bridge emit
+    // immediately instead of waiting for readyPattern + quiescence to
+    // converge. Idempotent — IdleDetector.fireIdle no-ops while already idle.
+    if (result.events.some(e => e.kind === 'assistant_final')) {
+        idleDetector?.fireIdle();
+    }
+}
+/** 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 adoptMode = lastInitConfig?.adoptMode === true;
+    // Adopt mode: model is the user's external Codex, no botmux send to
+    // gate against — every assistant turn (Lark-driven OR locally typed)
+    // should reach the thread. Skip marker IO entirely.
+    const markers = adoptMode ? [] : 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];
+        if (!turn.finalText)
+            continue;
+        const nextBoundaryMs = (i + 1 < ready.length ? ready[i + 1].markTimeMs : nextPendingMarkTimeMs);
+        if (shouldSuppressBridgeEmit({ markTimeMs: turn.markTimeMs, isLocal: turn.isLocal }, nextBoundaryMs, markers, adoptMode)) {
+            log(`Codex bridge fallback suppressed for turn ${turn.turnId.substring(0, 8)} (gate)`);
+            continue;
+        }
+        if (turn.isLocal) {
+            // Local turn (adopt only): user typed in iTerm. Surface both sides
+            // so the Lark thread sees a complete exchange instead of an orphan
+            // reply. formatLocalTurnFields caps both texts to keep within
+            // Lark's per-message limit; daemon owns the card chrome.
+            const fields = formatLocalTurnFields(turn.userText ?? '', turn.finalText);
+            if (!fields)
+                continue;
+            send({
+                type: 'final_output',
+                content: fields.content,
+                lastUuid: turn.turnId,
+                turnId: turn.turnId,
+                kind: 'local-turn',
+                userText: fields.userText,
+            });
+            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();
+    codexBridgeQueue.setLocalTurns(false);
+    codexBridgePendingSessionId = undefined;
+    codexAdoptPendingPid = undefined;
+    codexAdoptStartMs = 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;
+/** Most recent unfiltered viewport text — kept in sync by the screen_update
+ *  timer for pipe-pane backends so ScreenAnalyzer (which is synchronous) has
+ *  a fresh snapshot to read without needing its own tmux capture-pane call. */
+let lastAnalyzerSnapshot = '';
 let screenUpdateTimer = null;
 const SCREEN_UPDATE_INTERVAL_MS = 2_000;
 // ─── Scrollback Buffer (replay to late-connecting WS clients) ───────────────
@@ -93,7 +1665,14 @@ function startScreenAnalyzer() {
         extraHeaders: sa.extraHeaders,
         extraBody: sa.extraBody,
     }, {
-        getSnapshot: () => renderer?.rawSnapshot() ?? '',
+        getSnapshot: () => {
+            // ScreenAnalyzer is called every ~5s for TUI-prompt detection. We
+            // can't make this async without overhauling the analyzer, so cache
+            // the last pipe-pane text snapshot here and refresh it eagerly.
+            // For pipe-pane backends, the cache is repopulated by the screen
+            // update timer; for others, fall through to the long-lived renderer.
+            return lastAnalyzerSnapshot || renderer?.rawSnapshot() || '';
+        },
         onAnalyzing: () => { },
         onTuiPrompt: (description, options, multiSelect) => {
             tuiPromptBlocking = true;
@@ -117,8 +1696,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;
@@ -128,10 +1709,12 @@ let larkAppSecretForUpload = '';
 function startScreenshotLoop() {
     stopScreenshotLoop();
     screenshotTimer = setInterval(() => { void captureAndUpload(); }, SCREENSHOT_INTERVAL_MS);
+    log(`Screenshot loop started (interval=${SCREENSHOT_INTERVAL_MS}ms)`);
     // Capture immediately so the user gets a first frame fast
     void captureAndUpload();
 }
 function stopScreenshotLoop() {
+    const wasRunning = !!screenshotTimer || !!pendingShotTimer;
     if (screenshotTimer) {
         clearInterval(screenshotTimer);
         screenshotTimer = null;
@@ -140,6 +1723,26 @@ function stopScreenshotLoop() {
         clearTimeout(pendingShotTimer);
         pendingShotTimer = null;
     }
+    if (wasRunning)
+        log('Screenshot loop stopped');
+}
+// Throttle silent-skip reasons so a wedged worker prints why once every 30s
+// without spamming. Each distinct reason has its own throttle clock.
+const screenshotSkipLogState = {};
+function logScreenshotSkip(reason) {
+    const now = Date.now();
+    if (now - (screenshotSkipLogState[reason] ?? 0) < 30_000)
+        return;
+    screenshotSkipLogState[reason] = now;
+    log(`Screenshot skipped: ${reason}`);
+}
+// Worker stderr is piped through worker-pool, where most CLI stderr stays at
+// info level to avoid polluting error.log. Mark true worker faults so the
+// parent can selectively promote only these lines to logger.error.
+const WORKER_ERROR_MARKER = '[botmux-worker-error]';
+function logError(msg) {
+    const ts = new Date().toISOString();
+    process.stderr.write(`[${ts}] [worker:${sessionId.substring(0, 8) || '??'}] ${WORKER_ERROR_MARKER} ${msg}\n`);
 }
 /** Schedule a single capture +1s, then resume the regular 10s cadence. */
 function scheduleOneShotAfterAction() {
@@ -160,28 +1763,55 @@ function scheduleOneShotAfterAction() {
     }, POST_ACTION_DELAY_MS);
 }
 async function captureAndUpload() {
-    if (displayMode !== 'screenshot')
+    // displayMode mismatch should be impossible during a running loop (start/stop
+    // gate on it). Logging here exists to surface the unexpected case — e.g. a
+    // stray scheduleOneShotAfterAction firing after user toggled back to hidden.
+    if (displayMode !== 'screenshot') {
+        logScreenshotSkip(`displayMode=${displayMode}`);
         return;
-    if (awaitingFirstPrompt)
-        return;
-    if (!renderer)
-        return;
-    if (!larkAppIdForUpload || !larkAppSecretForUpload)
+    }
+    if (awaitingFirstPrompt) {
+        logScreenshotSkip('awaitingFirstPrompt');
         return;
-    const term = renderer.xterm;
-    const startY = term.buffer.active.baseY;
-    // Hash dedup — same content → skip upload
-    const snap = renderer.rawSnapshot();
-    const hash = createHash('md5').update(snap).digest('hex');
-    if (hash === lastShotHash)
+    }
+    if (!larkAppIdForUpload || !larkAppSecretForUpload) {
+        logScreenshotSkip('lark credentials missing');
         return;
-    lastShotHash = hash;
+    }
     let png;
     try {
-        png = captureToPng(term, { cols: SHOT_COLS, rows: SHOT_ROWS, startY });
+        // Preferred path: pipe-pane backends ask tmux for a fresh viewport
+        // snapshot and render it through a transient xterm-headless. This
+        // avoids the accumulated-buffer drift that produced duplicated /
+        // staircase content under the legacy long-lived renderer.
+        const pipeResult = await snapshotToPng(backend, renderCols, renderRows);
+        if (pipeResult) {
+            if (pipeResult.ansi === lastShotHash)
+                return;
+            lastShotHash = pipeResult.ansi;
+            png = pipeResult.png;
+        }
+        else {
+            // Fallback path: non-pipe backends (PtyBackend, legacy TmuxBackend)
+            // still drive the long-lived renderer.
+            if (!renderer) {
+                logScreenshotSkip('renderer=null');
+                return;
+            }
+            const term = renderer.xterm;
+            const startY = term.buffer.active.baseY;
+            const snap = renderer.rawSnapshot();
+            const hash = createHash('md5').update(snap).digest('hex');
+            if (hash === lastShotHash)
+                return;
+            lastShotHash = hash;
+            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}`);
+        logError(`Screenshot render failed: ${err?.message ?? err}`);
         return;
     }
     let imageKey;
@@ -189,7 +1819,7 @@ async function captureAndUpload() {
         imageKey = await uploadImageBuffer(larkAppIdForUpload, larkAppSecretForUpload, png);
     }
     catch (err) {
-        log(`Screenshot upload failed: ${err.message}`);
+        logError(`Screenshot upload failed: ${err?.message ?? err}`);
         return;
     }
     let status = isPromptReady ? 'idle' : 'working';
@@ -377,9 +2007,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 +2085,71 @@ 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}`);
+    }
+}
+/** How long to wait before re-checking whether a submit-not-confirmed message
+ *  eventually landed. Cold-start sessions and slow third-party hooks
+ *  (UserPromptSubmit, SessionStart — e.g. superpowers' large skill injection)
+ *  can defer Claude's jsonl append by 5–15s; a 20s deferred recheck covers
+ *  both without being so long that a true failure goes unsurfaced. */
+const SUBMIT_DEFERRED_RECHECK_MS = 20_000;
+/** Worker-side handler for `submitted: false`. Defers the user-facing
+ *  warning and runs the adapter-supplied `recheck` closure first; if the
+ *  message has shown up in the transcript by then (slow path, hook delay),
+ *  suppresses the warning entirely. Adapters without a recheck still fall
+ *  through to the warning after the same delay so the UX is uniform.
+ *
+ *  `bridgeTurnId` is the BridgeTurnQueue mark created right before the
+ *  failing writeInput. When the deferred recheck conclusively fails (= no
+ *  jsonl line will ever match this fingerprint), we drop the mark — leaving
+ *  it would keep `maybeSwitchBridgeJsonl` doing full-directory scans every
+ *  poll tick for a fingerprint that's permanently dead, the 99% CPU bug
+ *  this whole patch series is fixing. */
+function scheduleSubmitFailureNotify(msg, recheck, transcriptLabel, bridgeTurnId) {
+    const preview = msg.length > 60 ? msg.slice(0, 60) + '…' : msg;
+    log(`writeInput: submit not confirmed after retries — deferred ${SUBMIT_DEFERRED_RECHECK_MS}ms recheck queued. preview="${preview}"`);
+    setTimeout(async () => {
+        if (recheck) {
+            try {
+                if (await recheck()) {
+                    log(`Deferred recheck found submit in ${transcriptLabel} — suppressing warning. preview="${preview}"`);
+                    return;
+                }
+            }
+            catch (err) {
+                log(`Deferred recheck threw (${err?.message ?? err}); falling through to warning.`);
+            }
+        }
+        if (bridgeTurnId) {
+            const dropped = bridgeQueue.dropPendingTurn(bridgeTurnId);
+            if (dropped) {
+                if (dropped.contentFingerprint)
+                    bridgeFingerprintScanLastMs.delete(dropped.contentFingerprint);
+                log(`Bridge mark dropped after submit failure (turnId=${bridgeTurnId}) — rotation-fallback scan will stop spinning on this fingerprint.`);
+            }
+        }
+        log(`Deferred recheck still missing — notifying user. preview="${preview}"`);
+        send({
+            type: 'user_notify',
+            message: `⚠️ 刚才那条消息发给 ${cliName()} 后没能确认提交（重试 Enter 后等了 ${Math.round(SUBMIT_DEFERRED_RECHECK_MS / 1000)}s 仍未在${transcriptLabel}里看到新记录）。可能卡在输入框里——请去 Web 终端看一下，手动按 Enter 或重发。\n开头：${preview}`,
+        });
+    }, SUBMIT_DEFERRED_RECHECK_MS);
+}
 /**
  * Drain the pending message queue sequentially.
  * Async with isFlushing mutex: awaits each writeInput, then immediately
@@ -466,8 +2163,19 @@ async function flushPending() {
         return;
     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)
+    // Type-ahead adapters flush even while the CLI is busy; others wait for
+    // idle. Claude bridge fallback used to also disable type-ahead because
+    // BridgeTurnQueue.ingest didn't recognise the `attachment(queued_command)`
+    // events Claude writes when it dequeues a queued submit — assistant text
+    // for the type-ahead'd turn was either dropped or attributed to the wrong
+    // Lark message. Now that the queue handles queued_command identically to
+    // role:user (and overrides markTimeMs to the dequeue-time event timestamp
+    // so the gate window is correct), Claude bridge can run with type-ahead
+    // again. Codex bridge stays serial because its queue hasn't been upgraded.
+    const claudeBridgeActive = !!bridgeJsonlPath && !lastInitConfig?.adoptMode;
+    const codexBridgeActive = codexBridgeFallbackActive();
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !codexBridgeActive;
+    if (!isPromptReady && !typeAheadAllowed)
         return;
     isFlushing = true;
     if (isPromptReady) {
@@ -477,16 +2185,56 @@ 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.
+            let bridgeTurnId;
+            if (claudeBridgeActive) {
+                try {
+                    bridgeIngest();
+                }
+                catch { /* best-effort */ }
+                bridgeTurnId = 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}"`);
-                send({
-                    type: 'user_notify',
-                    message: `⚠️ 刚才那条消息发给 ${cliName()} 后没能确认提交（重试 Enter 3 次仍未在会话 JSONL 中看到新记录）。可能卡在输入框里——请去 Web 终端看一下，手动按 Enter 或重发。\n开头：${preview}`,
-                });
+                scheduleSubmitFailureNotify(msg, result.recheck, '会话 JSONL', bridgeTurnId);
             }
+            // Codex bridge: stop after one writeInput per idle cycle. Codex's
+            // bridge queue doesn't yet attribute queued_command-equivalents, so
+            // type-ahead'd submits would have their assistant text dropped or
+            // mis-attributed. We resume on the next idle, by which point Codex
+            // has finished and the next message can be a normal user_message
+            // submit. Claude bridge no longer takes this break — its
+            // BridgeTurnQueue handles `attachment(queued_command)` events
+            // identically to `role:user`, so type-ahead'd turns are correctly
+            // attributed and no longer need the serial-per-idle guard.
+            if (codexBridgeActive && pendingMessages.length > 0)
+                break;
         }
     }
     finally {
@@ -497,11 +2245,26 @@ 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: only Codex bridge still serialises type-ahead.
+    // Claude bridge now attributes `attachment(queued_command)` events
+    // identically to `role:user`, so type-ahead'd submits land in the right
+    // turn and we no longer need to gate the entry path on claudeBridgeActive.
+    const codexBridgeActive = codexBridgeFallbackActive();
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !codexBridgeActive;
+    if (isPromptReady || isFlushing || typeAheadAllowed) {
         log(`Writing to PTY: "${content.substring(0, 80)}"`);
         flushPending(); // fire-and-forget async; no-op if already flushing
     }
@@ -511,20 +2274,53 @@ 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;
+    let lastTextSnapshotHash = '';
     screenUpdateTimer = setInterval(() => {
-        if (!renderer || awaitingFirstPrompt)
+        if (awaitingFirstPrompt)
             return;
-        const { content, changed } = renderer.snapshot();
         let status = isPromptReady ? 'idle' : 'working';
         if (screenAnalyzer?.isAnalyzing)
             status = 'analyzing';
-        // Send update when content changed OR status changed (e.g. idle → analyzing)
-        if (changed || status !== lastSentStatus) {
-            lastSentStatus = status;
-            send({ type: 'screen_update', content, status });
-        }
+        void (async () => {
+            let content;
+            let changed;
+            // Preferred path: pipe-pane backends pull a fresh viewport snapshot
+            // from tmux every tick. This eliminates the accumulated-buffer drift
+            // that produced duplicated/staircase text in 'text' display mode.
+            const pipeText = await snapshotToText(backend, renderCols, renderRows, { filter: true });
+            if (pipeText) {
+                content = pipeText.content;
+                const hash = pipeText.ansi;
+                changed = hash !== lastTextSnapshotHash;
+                lastTextSnapshotHash = hash;
+                // Refresh the unfiltered cache that ScreenAnalyzer reads from. Same
+                // tmux call would otherwise need to fire twice per tick.
+                if (changed) {
+                    const rawSnap = await snapshotToText(backend, renderCols, renderRows, { filter: false });
+                    if (rawSnap)
+                        lastAnalyzerSnapshot = rawSnap.content;
+                }
+            }
+            else if (renderer) {
+                const snap = renderer.snapshot();
+                content = snap.content;
+                changed = snap.changed;
+            }
+            else {
+                return;
+            }
+            if (changed || status !== lastSentStatus) {
+                lastSentStatus = status;
+                send({ type: 'screen_update', content, status });
+            }
+        })();
     }, SCREEN_UPDATE_INTERVAL_MS);
 }
 function stopScreenUpdates() {
@@ -536,46 +2332,196 @@ function stopScreenUpdates() {
         renderer.dispose();
         renderer = null;
     }
+    lastAnalyzerSnapshot = '';
 }
 // ─── 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 the adopted CLI's transcript to harvest assistant
+        // turns out-of-band. Two paths:
+        //   - claude-code: cfg.bridgeJsonlPath is set when adopt knew the sid.
+        //   - codex: locate rollout via cliSessionId (daemon's discovery probe)
+        //     or by reading /proc/<pid>/fd. Both modes enable adopt-only local
+        //     turn synthesis so iTerm-typed conversation also reaches Lark.
+        if (cfg.bridgeJsonlPath) {
+            startBridgeWatcher(cfg.bridgeJsonlPath, {
+                cliPid: cfg.adoptCliPid,
+                cliCwd: cfg.adoptCwd,
+            });
+        }
+        else if (cfg.cliId === 'codex') {
+            const adoptStartMs = Date.now();
+            codexAdoptStartMs = adoptStartMs;
+            codexBridgeQueue.setLocalTurns(true, adoptStartMs);
+            let rolloutPath;
+            if (cfg.cliSessionId)
+                rolloutPath = findCodexRolloutBySessionId(cfg.cliSessionId);
+            if (!rolloutPath && cfg.adoptCliPid) {
+                const probed = findCodexRolloutByPid(cfg.adoptCliPid);
+                if (probed)
+                    rolloutPath = probed.path;
+            }
+            if (rolloutPath) {
+                // Adopt-time attach: split-live so any iTerm activity that
+                // happened in the brief window between adopt detection and worker
+                // spawn (or between codex's own startup writes and now) lands as
+                // live, not absorbed history.
+                codexBridgeAttach(rolloutPath, 'split-live');
+            }
+            else {
+                // Couldn't locate yet — start poller. The 1s timer keeps trying
+                // both findCodexRolloutBySessionId (if cliSessionId is set) and
+                // findCodexRolloutByPid (passed via the discovery hooks below).
+                if (cfg.cliSessionId)
+                    codexBridgePendingSessionId = cfg.cliSessionId;
+                codexAdoptPendingPid = cfg.adoptCliPid;
+                codexBridgeStartTimer();
+            }
+        }
+        else if (cfg.cliId === 'coco') {
+            // CoCo adopt: parallel to codex, but the events.jsonl path is
+            // deterministic from cliSessionId, so once the daemon-side discovery
+            // surfaced an sid we know the path immediately. The file may not
+            // exist yet (CoCo creates it on first event); codexBridgeAttach's
+            // split-live-with-missing-file branch degrades to fresh, and the
+            // late-attach poller catches re-creation.
+            const adoptStartMs = Date.now();
+            codexAdoptStartMs = adoptStartMs;
+            codexBridgeQueue.setLocalTurns(true, adoptStartMs);
+            let eventsPath;
+            if (cfg.cliSessionId)
+                eventsPath = cocoEventsPathForSession(cfg.cliSessionId);
+            if (!eventsPath && cfg.adoptCliPid) {
+                const probed = findCocoSessionByPid(cfg.adoptCliPid);
+                if (probed)
+                    eventsPath = probed.eventsPath;
+            }
+            if (eventsPath) {
+                // If the session DIRECTORY is missing (not just events.jsonl), CoCo
+                // is operating on an unlinked inode — common after an e2e test or
+                // manual cleanup wiped the dir while CoCo kept its fds open. The
+                // bridge file will never appear, so warn the user once via Lark
+                // instead of polling forever in silence.
+                const sessionDir = dirname(eventsPath);
+                if (!existsSync(sessionDir)) {
+                    send({
+                        type: 'final_output',
+                        content: '⚠️ 当前 CoCo 进程的会话目录已被删除（可能是 e2e 测试清理或手动 rm），写到 events.jsonl 的内容会落到一个失效 inode 上，桥接读不到。请重启 CoCo 后重新 /adopt。',
+                        lastUuid: `coco-adopt-stale-${randomBytes(4).toString('hex')}`,
+                        turnId: 'coco-adopt-stale',
+                    });
+                    log(`CoCo adopt: session dir missing, bridge disabled (${sessionDir})`);
+                }
+                else {
+                    codexBridgeAttach(eventsPath, 'split-live');
+                }
+            }
+            else {
+                // No sid known yet — fall back to PID-walk in the late-attach
+                // poller. Reuses codexAdoptPendingPid since the timer dispatches
+                // by cliId at probe time (see codexBridgeStartTimer).
+                codexAdoptPendingPid = cfg.adoptCliPid;
+            }
+            // Always run the bridge poller for CoCo adopt — events.jsonl is created
+            // lazily on first event, so fs.watch typically ENOENTs at attach time.
+            // The 1s timer covers ingest + emit even when the watcher never armed,
+            // and is idempotent (no-op if already started).
+            codexBridgeStartTimer();
+        }
+        // Idle detection. In bridge mode we use the adopted CLI'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)
+            : cfg.cliId === 'codex' || cfg.cliId === 'coco'
+                ? createCliAdapterSync(cfg.cliId, undefined)
+                : { completionPattern: undefined, readyPattern: undefined };
+        idleDetector = new IdleDetector(idleAdapter);
+        // Codex adopt write path: route Lark messages through the codex
+        // adapter's writeInput so they pick up the 200 ms paste-detection
+        // delay + Enter-retry + ~/.codex/history.jsonl verification loop
+        // (see src/adapters/cli/codex.ts:125-178). Without it, Codex TUI's
+        // "\n treated as Enter" handling leaves multi-line submits stuck
+        // in the input box. Other adopt CLIs keep the simpler raw
+        // sendText+Enter path — claude-code adopt has its own bridge
+        // verify path; gemini / coco / opencode / aiden haven't surfaced
+        // this failure mode and we don't want to risk regressing them.
+        if (cfg.cliId === 'codex') {
+            cliAdapter = createCliAdapterSync('codex', cfg.cliPathOverride);
+        }
         idleDetector.onIdle(() => {
             log('Prompt detected (idle) — adopt mode');
+            try {
+                bridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Bridge emit error: ${err.message}`);
+            }
+            try {
+                codexBridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Codex 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);
-    const useTmux = cfg.backendType === 'tmux';
-    isTmuxMode = useTmux;
-    const tmuxBe = useTmux ? new TmuxBackend(TmuxBackend.sessionName(cfg.sessionId)) : null;
-    backend = tmuxBe ?? new PtyBackend();
+    // backendType=tmux trust-but-verify: an explicit per-bot config (or
+    // BACKEND_TYPE=tmux env override) bypasses config.ts's auto-detect, so
+    // the worker re-probes here. If tmux can't start a server we silently
+    // fall back to PTY rather than letting attach-session / new-session spam
+    // the daemon error log every poll cycle.
+    let useTmux = cfg.backendType === 'tmux';
+    if (useTmux && !TmuxBackend.isAvailable()) {
+        log('tmux backend requested but functional probe failed — falling back to PTY backend');
+        useTmux = false;
+    }
+    const selectedBackend = selectSessionBackend({ sessionId: cfg.sessionId, useTmux });
+    isTmuxMode = selectedBackend.isTmuxMode;
+    isPipeMode = selectedBackend.isPipeMode;
+    backend = selectedBackend.backend;
     // Claude Code appends a line to ~/.claude/projects/<cwd-hash>/<sid>.jsonl each
     // time the user submits. The adapter uses this file to verify paste+Enter
     // actually committed (rather than trusting a fixed sleep), so wire it up now.
@@ -588,6 +2534,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,
@@ -596,15 +2543,29 @@ function spawnCli(cfg) {
     const extra = (process.env.CLI_EXTRA_ARGS ?? '').trim();
     if (extra)
         args.push(...extra.split(/\s+/).filter(Boolean));
+    // Claude Code 在 root/sudo 下会拒绝 --dangerously-skip-permissions 并立即 exit。
+    // botmux 必须带这个 flag（话题里没法弹交互式审批），所以为 root 自动注入
+    // IS_SANDBOX=1 走 Claude Code 的受控环境逃生舱。用户显式设了就尊重不覆盖。
+    const injectClaudeSandbox = cfg.cliId === 'claude-code' &&
+        process.getuid?.() === 0 &&
+        !process.env.IS_SANDBOX;
+    if (injectClaudeSandbox) {
+        log('Detected root user — injecting IS_SANDBOX=1 for Claude Code');
+    }
     log(`Spawning: ${cliAdapter.resolvedBin} ${args.join(' ')} (cwd: ${cfg.workingDir})`);
     backend.spawn(cliAdapter.resolvedBin, args, {
         cwd: cfg.workingDir,
         cols: PTY_COLS,
         rows: PTY_ROWS,
-        env: { ...process.env, CLAUDECODE: undefined },
+        env: {
+            ...process.env,
+            CLAUDECODE: undefined,
+            ...(injectClaudeSandbox ? { IS_SANDBOX: '1' } : {}),
+        },
     });
-    // Write CLI PID marker so the MCP server can verify it was spawned by botmux.
-    // The MCP server checks if process.ppid has a marker in this directory.
+    // Write CLI PID marker so agent-facing subcommands (`botmux send`, etc.)
+    // can verify they were spawned inside a botmux session by walking the
+    // process tree and looking for a matching pid file in this directory.
     const cliPid = backend.getChildPid?.();
     if (cliPid && process.env.SESSION_DATA_DIR) {
         const markersDir = join(process.env.SESSION_DATA_DIR, '.botmux-cli-pids');
@@ -618,16 +2579,86 @@ 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 — the spawn-time pid-state record. Its
+    // `sessionId` is set ONCE at process start (Claude Code 2.1.123); a
+    // `--resume` lookup will surface here, but in-pane `/clear` won't, so a
+    // 'matching sessionId' answer is "no spawn-time rotation observed", not
+    // "no rotation at all". The pinned claudeJsonlPath above is still the
+    // initial guess; the resolver corrects it on first write when Claude was
+    // started with `--resume`.
+    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',
+        });
+    }
+    // Structured transcript bridge fallback: if the model finishes without
+    // calling `botmux send`, harvest the final answer from the CLI transcript
+    // and post it to Lark. Codex needs late attach because its rollout id is
+    // discovered after the first submit; CoCo's events path is deterministic
+    // from botmux sessionId.
+    if (cfg.cliId === 'codex') {
+        if (cfg.cliSessionId) {
+            const rolloutPath = findCodexRolloutBySessionId(cfg.cliSessionId);
+            if (rolloutPath) {
+                codexBridgeAttach(rolloutPath, 'baseline-existing');
+            }
+            else {
+                codexBridgePendingSessionId = cfg.cliSessionId;
+                codexBridgeStartTimer();
+            }
+        }
+        else {
+            codexBridgeStartTimer();
+        }
+    }
+    else if (cfg.cliId === 'coco') {
+        const eventsPath = cocoEventsPathForSession(cfg.sessionId);
+        codexBridgeAttach(eventsPath, cfg.resume ? 'baseline-existing' : 'fresh-empty');
+        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);
@@ -637,10 +2668,22 @@ function spawnCli(cfg) {
         isPromptReady = false;
         send({ type: 'claude_exit', code, signal });
     });
-    // Fallback: if the CLI takes too long to show its prompt (e.g. slow MCP
-    // server init), unblock screen updates so the card doesn't stay at "启动中"
-    // forever.  markNewTurn() sets a clean baseline at the current cursor
-    // position so only content written *after* this point appears in the card.
+    if (isPipeMode && backend instanceof TmuxPipeBackend && backend.isReattach) {
+        log(`Re-attached to existing tmux session via pipe-pane: ${TmuxBackend.sessionName(cfg.sessionId)}`);
+        try {
+            const initial = backend.captureCurrentScreen();
+            if (initial.length > 0)
+                onPtyData(initial);
+        }
+        catch (err) {
+            log(`captureCurrentScreen failed: ${err.message}`);
+        }
+    }
+    // Fallback: if the CLI takes too long to show its prompt (e.g. slow
+    // plugin init), unblock screen updates so the card doesn't stay at
+    // "启动中" forever.  markNewTurn() sets a clean baseline at the current
+    // cursor position so only content written *after* this point appears in
+    // the card.
     setTimeout(() => {
         if (awaitingFirstPrompt) {
             awaitingFirstPrompt = false;
@@ -656,6 +2699,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 {
@@ -688,8 +2736,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.
@@ -711,6 +2759,7 @@ function startWebServer(host, preferredPort) {
                         name: 'xterm-256color',
                         cols,
                         rows,
+                        env: tmuxEnv(),
                     });
                     clientPtys.set(ws, cp);
                     cp.onData((d) => {
@@ -849,11 +2898,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>
@@ -879,7 +2928,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',
@@ -956,7 +3005,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);
@@ -966,7 +3015,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}))}
@@ -1055,7 +3104,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();
@@ -1064,6 +3121,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);
                 }
@@ -1083,10 +3142,70 @@ process.on('message', async (raw) => {
                 exitTmuxScrollMode();
             const content = msg.content;
             if (lastInitConfig?.adoptMode) {
-                // Adopt mode: raw write to PTY (no adapter writeInput)
+                // 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);
+                }
+                else if (codexBridgeFallbackActive()) {
+                    // Codex adopt: same idea, different bridge. ingest first so any
+                    // in-flight events from a local-typed prior turn close before
+                    // this Lark turn's fingerprint window opens. Mark works even
+                    // pre-attach (queue is path-agnostic).
+                    try {
+                        codexBridgeIngest();
+                    }
+                    catch { /* best effort */ }
+                    codexBridgeMarkPendingTurn(content);
+                }
+                // Adopt mode write:
+                //   - codex routes through cliAdapter.writeInput so the adapter's
+                //     paste-detection delay + Enter-retry + history.jsonl verify
+                //     loop handles Codex TUI's "\n treated as Enter" submit
+                //     behaviour. Without it, Lark messages get stranded in the
+                //     input box (user-reported "卡在输入框中").
+                //   - everything else keeps the simple raw sendText+Enter — the
+                //     claude-code adopt bridge has its own dual-write recovery
+                //     path, and the other CLIs' adopt flows haven't surfaced
+                //     this submit-detection issue.
                 if (backend) {
-                    if ('sendText' in backend && 'sendSpecialKeys' in backend) {
+                    if (lastInitConfig?.cliId === 'codex' && cliAdapter) {
+                        // writeInput is async but we're already inside an async
+                        // message handler. Errors are best-effort logged; the bridge
+                        // ingest path is unaffected because mark already happened
+                        // above (codexBridgeMarkPendingTurn / bridgeMarkPendingTurn).
+                        try {
+                            const result = await cliAdapter.writeInput(backend, content);
+                            if (result?.cliSessionId) {
+                                persistCliSessionId(result.cliSessionId);
+                                codexBridgeNotifyCliSessionId(result.cliSessionId);
+                            }
+                            if (result && result.submitted === false) {
+                                scheduleSubmitFailureNotify(content, result.recheck, 'Codex history');
+                            }
+                        }
+                        catch (err) {
+                            log(`Codex adopt writeInput error: ${err.message}`);
+                        }
+                    }
+                    else if ('sendText' in backend && 'sendSpecialKeys' in backend) {
                         backend.sendText(content);
+                        // Beat between text and Enter so the adopted CLI's input layer
+                        // has time to register the typed chars before submit. Without
+                        // this, Ink-based TUIs (CoCo, Claude Code) flag the rapid
+                        // input+Enter as paste continuation and treat the trailing
+                        // Enter as a soft-newline, leaving the message stranded in the
+                        // input box. 200ms mirrors the per-adapter writeInput delay
+                        // that fresh-spawn mode goes through and matches the slash-
+                        // command (raw_input) fix.
+                        await new Promise(r => setTimeout(r, 200));
                         backend.sendSpecialKeys('Enter');
                     }
                     else {
@@ -1097,6 +3216,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;
@@ -1113,6 +3237,14 @@ process.on('message', async (raw) => {
             if (backend) {
                 if ('sendText' in backend && 'sendSpecialKeys' in backend) {
                     backend.sendText(msg.content);
+                    // Beat between text and Enter so the CLI's slash-command picker has
+                    // time to register the match before submit. Without this, Codex
+                    // (and likely other Ink-based TUIs) fires Enter while the picker
+                    // is still building, dismisses the match, and submits the literal
+                    // `/clear` as a regular user prompt — visible to the user as
+                    // "/clear + 换行" stuck in conversation history. 200ms mirrors the
+                    // codex adapter's own writeInput paste-detection delay.
+                    await new Promise(r => setTimeout(r, 200));
                     backend.sendSpecialKeys('Enter');
                 }
                 else {
@@ -1177,6 +3309,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);
         }
@@ -1207,5 +3344,33 @@ process.on('SIGTERM', () => { stopScreenshotLoop(); killCli(); cleanup(); proces
 process.on('SIGINT', () => { stopScreenshotLoop(); killCli(); cleanup(); process.exit(0); });
 // If parent daemon dies, IPC channel closes — clean up
 process.on('disconnect', () => { log('Daemon disconnected'); stopScreenshotLoop(); killCli(); cleanup(); process.exit(0); });
+// Watchdog: belt-and-braces parent-death detection. SIGTERM and 'disconnect'
+// should both reach us when the daemon dies, but if main thread is stuck in
+// a sync path V8 silently buffers the signal and we end up as a ppid=1
+// orphan forever (we accumulated 841 such orphans before this guard, eating
+// ~65GB of RAM). setInterval itself depends on the event loop, so a
+// permanently-stuck thread would still orphan — but real-world stuck
+// patterns are periodic (e.g. the v2.9.2 bridge scan was 1s-on / 0.x-off),
+// so the 30s tick gets many landing windows. `unref()` keeps the timer
+// from preventing a normal exit. `getppid()` is the read fd from /proc/self
+// — cheap, sync, no allocation. The daemon-side SIGKILL grace window
+// (SHUTDOWN_GRACE_MS in daemon.ts) is the harder backstop.
+const ORIGINAL_PARENT_PID = process.ppid;
+setInterval(() => {
+    const currentPpid = process.ppid;
+    if (currentPpid !== ORIGINAL_PARENT_PID || currentPpid === 1) {
+        log(`Watchdog: parent pid changed (${ORIGINAL_PARENT_PID} → ${currentPpid}) — daemon died, exiting`);
+        stopScreenshotLoop();
+        try {
+            killCli();
+        }
+        catch { /* best-effort */ }
+        try {
+            cleanup();
+        }
+        catch { /* best-effort */ }
+        process.exit(0);
+    }
+}, 30_000).unref();
 log('Worker started, waiting for init...');
 //# sourceMappingURL=worker.js.map