botmux 2.12.0 → 2.12.2

package/dist/worker.js

@@ -15,9 +15,12 @@
 import { randomBytes } from 'node:crypto';
 import { mkdirSync, writeFileSync, unlinkSync, existsSync, statSync, readdirSync, readlinkSync, readFileSync, watch as fsWatch } from 'node:fs';
 import { join } from 'node:path';
-import { drainTranscript, joinAssistantText, findJsonlContainingFingerprint, findLatestJsonl, extractLastAssistantTurn, stringifyUserContent } from './services/claude-transcript.js';
-import { BridgeTurnQueue, makeFingerprint } from './services/bridge-turn-queue.js';
+import { drainTranscript, joinAssistantText, findJsonlContainingFingerprint, findJsonlsContainingExactContent, findLatestJsonl, extractLastAssistantTurn, stringifyUserContent, 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 } from './services/codex-transcript.js';
 import { dirname } from 'node:path';
 import { createServer as createHttpServer } from 'node:http';
 import { WebSocketServer, WebSocket } from 'ws';
@@ -78,15 +81,37 @@ let bridgeJsonlPath;
  *  original path would silently stop receiving events. */
 let bridgeJsonlDir;
 /** PID + cwd of the adopted Claude Code process. Lets every poll re-read
- *  ~/.claude/sessions/<pid>.json — Claude's own authoritative record of the
- *  current sessionId — and switch the watched jsonl when Claude rotates
- *  (via /clear, /resume, --resume etc.) without waiting for a Lark message
- *  to land in the new file. */
+ *  ~/.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
@@ -108,6 +133,35 @@ 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;
 /** 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. */
@@ -211,6 +265,32 @@ function maybeEmitAdoptPreamble(events) {
     });
     log('Bridge adopt preamble emitted (last completed turn from baseline)');
 }
+/** 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;
@@ -227,41 +307,30 @@ function bridgeAbsorbBaseline() {
     if (lastInitConfig?.adoptMode)
         maybeEmitAdoptPreamble(result.events);
 }
-/** Detect /clear / /resume: when Claude Code starts a new session in the
- *  user's pane it writes to a brand-new sessionId.jsonl. We *cannot* use
- *  "latest-mtime jsonl in the project dir" as the switch trigger — that
- *  hijacks our watcher whenever a sibling Claude pane in the same cwd
- *  writes anything. Instead, switch only when:
- *
- *    1. We have an unstarted pending Lark turn (otherwise no signal to
- *       chase, and switching would risk grabbing another pane's reply).
- *    2. The pending turn's content fingerprint shows up in a candidate
- *       jsonl other than our current one — that's the user's current
- *       session because they JUST typed our pane-write into it.
- *
- *  Pending turns are preserved across the switch so the next ingest can
- *  match the fingerprint and start the turn in the new file. */
-function maybeSwitchBridgeJsonl() {
-    if (!bridgeJsonlDir)
-        return false;
-    const pending = bridgeQueue.peek();
-    const candidate = pending.find(t => !t.started && !!t.contentFingerprint);
-    if (!candidate || !candidate.contentFingerprint)
-        return false;
-    // Bound the search to events written after the turn was marked. Short
-    // fingerprints ("hello", "test") would otherwise match old user lines
-    // in unrelated sibling jsonls. 5s skew absorbs clock drift between the
-    // mark and Claude's transcript write.
-    const minEventTimestampMs = candidate.markTimeMs !== undefined
-        ? candidate.markTimeMs - 5_000
-        : undefined;
-    const matched = findJsonlContainingFingerprint(bridgeJsonlDir, candidate.contentFingerprint, {
-        excludePath: bridgeJsonlPath,
-        includeQueueOperations: true,
-        minEventTimestampMs,
-    });
-    if (!matched)
-        return false;
+/** 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
@@ -281,7 +350,7 @@ function maybeSwitchBridgeJsonl() {
         }
         retainSecondaryPathIfStillReferenced(bridgeJsonlPath, postDrainOffset);
     }
-    log(`Bridge transcript switched: ${bridgeJsonlPath} → ${matched} (Lark fingerprint observed in new jsonl — user likely ran /clear or /resume)`);
+    log(`Bridge transcript switched: ${bridgeJsonlPath} → ${matched} (${reason})`);
     if (bridgeWatcher) {
         try {
             bridgeWatcher.close();
@@ -290,18 +359,30 @@ function maybeSwitchBridgeJsonl() {
         bridgeWatcher = null;
     }
     // Critically: do NOT clear pending turns. The switch was triggered by
-    // the fingerprint of the FIRST pending turn already living in `matched`,
-    // so the immediate next ingest from offset 0 will find that user event
-    // and start the turn. Clearing here would race-drop exactly the message
-    // we're trying to deliver.
+    // the FIRST pending turn already living in `matched`, so the immediate
+    // next ingest from offset 0 will find that user event and start the
+    // turn. Clearing here would race-drop exactly the message we're
+    // trying to deliver.
     bridgeJsonlPath = matched;
-    bridgeOffset = 0;
+    bridgeJsonlDir = dirname(matched);
     bridgePendingTail = '';
-    // baselineDone=false would absorb the new file's existing content
-    // (including the pending turn's user event) as history — defeating the
-    // switch. Skip baseline; fall straight into ingest from offset 0 so
-    // BridgeTurnQueue.ingest() can attribute the matching user/assistant.
+    // 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 {
@@ -315,31 +396,122 @@ function maybeSwitchBridgeJsonl() {
     catch (err) {
         log(`Bridge fs.watch unavailable on new target (${err.message}); relying on fallback poller`);
     }
-    return true;
 }
-/** /clear or /resume in the user's adopted pane creates (or touches) a new
- *  jsonl in the same Claude project directory. Neither pid-resolver nor
- *  fingerprint switch will fire when the rotation happened mid-process AND
- *  there's no pending Lark turn to anchor on (pure local-terminal use), so
- *  this fallback owns that case.
+/** 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. */
+function maybeSwitchBridgeJsonl() {
+    if (!bridgeJsonlDir)
+        return false;
+    const pending = bridgeQueue.peek();
+    const candidate = pending.find(t => !t.started && !!t.contentFingerprint);
+    if (!candidate || !candidate.contentFingerprint)
+        return false;
+    // Bound the search to events written after the turn was marked. Short
+    // fingerprints ("hello", "test") would otherwise match old user lines
+    // in unrelated sibling jsonls. 5s skew absorbs clock drift between the
+    // mark and Claude's transcript write.
+    const minEventTimestampMs = candidate.markTimeMs !== undefined
+        ? candidate.markTimeMs - 5_000
+        : undefined;
+    const 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. This is bound to the real
- *       PID — a sibling Claude pane in the same cwd has a different PID and
- *       therefore cannot hijack the result.
- *    2. Cross-platform fallback: directory-level mtime heuristic, gated on
- *       (a) our current jsonl quiet ≥ QUIET_ROTATION_MS, (b) candidate
- *       newer by ≥ QUIET_ROTATION_MS, (c) adopted Claude pid alive. Less
- *       robust than fd lookup but the best available without /proc.
+ *       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*
+ *  When a rotation is detected, the new jsonl is drained from offset 0
+ *  and events are split by timestamp against `rotationCutoffMs` (the
+ *  old jsonl's last-write time): events before the cutoff are *history*
  *  (absorbed into the seen-set, not emitted), events after are *live*
- *  (ingested → local-turn synthesis runs). This is what lets /resume to a
- *  long-history jsonl NOT replay the entire past as one giant local turn,
- *  while /clear's first new turn still gets forwarded.
+ *  (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
@@ -451,17 +623,7 @@ function performRotationSwitch(newPath, cutoffMs, reason) {
     const result = drainTranscript(newPath, 0);
     bridgeOffset = result.newOffset;
     bridgePendingTail = result.pendingTail;
-    const history = [];
-    const live = [];
-    for (const ev of result.events) {
-        let evMs = Number.NaN;
-        if (typeof ev.timestamp === 'string')
-            evMs = Date.parse(ev.timestamp);
-        if (Number.isFinite(evMs) && evMs <= cutoffMs)
-            history.push(ev);
-        else
-            live.push(ev);
-    }
+    const { history, live } = splitTranscriptEventsByCutoff(result.events, cutoffMs);
     bridgeQueue.absorb(history);
     if (live.length > 0)
         bridgeQueue.ingest(live, newPath);
@@ -500,6 +662,15 @@ function maybeFollowQuietRotation() {
     // 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}`);
@@ -525,6 +696,43 @@ function maybeFollowQuietRotation() {
         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';
@@ -534,8 +742,29 @@ function maybeFollowSessionRotationViaPid() {
     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
@@ -594,28 +823,56 @@ function bridgeIngest() {
     // 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. Claude's pid file has
-    // its sessionId field set ONCE at process start (see binary persistence
-    // schema) and is NOT rewritten on /clear, so pid resolver returning
-    // 'same' is NOT proof that no rotation happened. We skip the
-    // fingerprint scan only when pid resolver actively switched the path
-    // — in that case the authoritative source already moved us, and
-    // running fingerprint on top would risk a redundant flip.
+    // 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: catches /clear or /resume in pure-local
-    // sessions (no pending Lark turn → no fingerprint to match against).
-    // Without this, a user who hits /clear in the adopted pane and then
-    // continues in the terminal would never get those replies forwarded
-    // to Lark — the watcher stays stuck on the old, frozen jsonl.
-    if (!switched) {
+    // 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)
@@ -638,15 +895,19 @@ function startBridgeWatcher(jsonlPath, opts) {
     bridgeCliPid = opts?.cliPid;
     bridgeCliCwd = opts?.cliCwd;
     const mode = opts?.mode ?? 'baseline-existing';
-    // Authoritative: prefer Claude's own pid-state record over the path the
-    // adopt scan computed. If Claude has already rotated since adopt fired
-    // (e.g. user ran /clear before any Lark message arrived), this swaps the
-    // initial path before baseline so we don't waste a baseline on a frozen
-    // file.
+    // 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. Note: in-pane `/clear` between adopt and worker
+    // spawn would NOT show up here (pid file's `sessionId` is set once
+    // at process start) — that case is recovered later by the
+    // fingerprint fallback once a Lark turn arrives.
     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;
@@ -654,6 +915,11 @@ function startBridgeWatcher(jsonlPath, opts) {
             }
         }
     }
+    // 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
@@ -713,6 +979,8 @@ function stopBridgeWatcher() {
     bridgeCliPid = undefined;
     bridgeCliCwd = undefined;
     bridgeObservedCliSessionId = undefined;
+    bridgeKnownSessionIds.clear();
+    bridgeStalePidStateSessionId = undefined;
     bridgeSecondaryPaths.clear();
     bridgePreambleSent = false;
 }
@@ -739,7 +1007,15 @@ function bridgeMarkPendingTurn(messageText) {
         return false;
     }
     const fingerprint = makeFingerprint(messageText);
-    bridgeQueue.mark(randomBytes(8).toString('hex'), fingerprint);
+    // 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;
+    bridgeQueue.mark(randomBytes(8).toString('hex'), fingerprint, Date.now(), contentNormalized);
     return true;
 }
 function bridgeDrainAndMaybeEmit() {
@@ -823,6 +1099,249 @@ function drainPathInto(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 both adopt and non-adopt Codex sessions. The two modes
+    // differ in: emit gate (adopt skips marker check), local-turn synthesis
+    // (adopt only), and how the rollout path is resolved.
+    return lastInitConfig?.cliId === 'codex';
+}
+function codexBridgeStartTimer() {
+    if (codexBridgeTimer)
+        return;
+    // Single 1s ticker that handles three jobs: late-attach (poll for the
+    // rollout file once we know cliSessionId), ingest (fs.watch backup),
+    // and idle-window emit. The last is critical for the late-attach race:
+    // if the rollout path appears AFTER the CLI's idle event has fired,
+    // the idle callback's emit already ran (and saw an empty queue), so
+    // the next emit chance would be at the next idle — i.e. the user has
+    // to send another message before the previous turn's fallback shows
+    // up. Emitting here when isPromptReady=true closes that window.
+    // Codex's queue only releases turns on `assistant_final` (the model's
+    // declared end-of-turn), so a tick-driven emit can't accidentally
+    // publish a half-streamed response.
+    codexBridgeTimer = setInterval(() => {
+        try {
+            if (!codexBridgeRolloutPath) {
+                // 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).
+                let path;
+                if (codexBridgePendingSessionId) {
+                    path = findCodexRolloutBySessionId(codexBridgePendingSessionId);
+                }
+                if (!path && codexAdoptPendingPid) {
+                    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 = drainCodexRollout(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})`);
+    }
+    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 = drainCodexRollout(rolloutPath, 0);
+        codexBridgeOffset = result.newOffset;
+        codexBridgePendingTail = result.pendingTail;
+        codexBridgeQueue.absorb(result.events);
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge baselined: ${rolloutPath} (offset=${codexBridgeOffset})`);
+    }
+    else {
+        // baseline-existing requested but file missing — degrade to fresh
+        // semantics so the lazy-appearing file isn't accidentally absorbed.
+        codexBridgeOffset = 0;
+        codexBridgePendingTail = '';
+        codexBridgeBaselineDone = true;
+        log(`Codex bridge transcript not yet present at ${rolloutPath}; treating as fresh`);
+    }
+    try {
+        codexBridgeWatcher = fsWatch(rolloutPath, { persistent: false }, () => {
+            try {
+                codexBridgeIngest();
+            }
+            catch (err) {
+                log(`Codex bridge ingest error: ${err.message}`);
+            }
+        });
+    }
+    catch (err) {
+        log(`Codex bridge fs.watch unavailable (${err.message}); relying on poller`);
+    }
+}
+/** Called from flushPending after writeInput first returns a cliSessionId.
+ *  Tries to locate the rollout file immediately; if it's not on disk yet,
+ *  remembers the sid so the 1s poller can keep retrying. */
+function codexBridgeNotifyCliSessionId(cliSessionId) {
+    if (!codexBridgeFallbackActive() || codexBridgeRolloutPath)
+        return;
+    const path = findCodexRolloutBySessionId(cliSessionId);
+    if (path) {
+        codexBridgePendingSessionId = undefined;
+        codexBridgeAttach(path, 'fresh-empty');
+    }
+    else {
+        codexBridgePendingSessionId = cliSessionId;
+        codexBridgeStartTimer();
+    }
+}
+function codexBridgeIngest() {
+    if (!codexBridgeRolloutPath || !codexBridgeBaselineDone)
+        return;
+    const result = drainCodexRollout(codexBridgeRolloutPath, codexBridgeOffset);
+    codexBridgeOffset = result.newOffset;
+    codexBridgePendingTail = result.pendingTail;
+    codexBridgeQueue.ingest(result.events);
+}
+/** Mark a pending Lark turn for Codex. Crucially this works even before a
+ *  rollout path is known — the queue is path-agnostic, and ingest after
+ *  late-attach picks up the user_message and matches the fingerprint. */
+function codexBridgeMarkPendingTurn(messageText) {
+    if (!codexBridgeFallbackActive())
+        return false;
+    const turnId = `codex-${randomBytes(8).toString('hex')}`;
+    codexBridgeQueue.mark(turnId, messageText);
+    return true;
+}
+function codexBridgeDrainAndMaybeEmit() {
+    if (!codexBridgeFallbackActive())
+        return;
+    if (codexBridgeRolloutPath && codexBridgeBaselineDone) {
+        try {
+            codexBridgeIngest();
+        }
+        catch (err) {
+            log(`Codex bridge ingest error: ${err.message}`);
+        }
+    }
+    emitReadyCodexTurns();
+}
+function emitReadyCodexTurns() {
+    const ready = codexBridgeQueue.drainEmittable();
+    if (ready.length === 0)
+        return;
+    const 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. formatLocalTurnContent caps both texts to keep within
+            // Lark's per-message limit.
+            const content = formatLocalTurnContent(turn.userText ?? '', turn.finalText);
+            if (!content)
+                continue;
+            send({ type: 'final_output', content, lastUuid: turn.turnId, turnId: turn.turnId });
+            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
@@ -1340,10 +1859,17 @@ async function flushPending() {
     // so BridgeTurnQueue.ingest never starts the pending turn for them and
     // the assistant text would be dropped on the floor. Serialise instead —
     // worker holds messages in pendingMessages until the CLI reaches idle.
-    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !(bridgeJsonlPath && !lastInitConfig?.adoptMode);
+    const claudeBridgeActive = !!bridgeJsonlPath && !lastInitConfig?.adoptMode;
+    const codexBridgeActive = codexBridgeFallbackActive();
+    const bridgeFallbackActive = claudeBridgeActive || codexBridgeActive;
+    // Type-ahead must be disabled for any active bridge fallback (claude or
+    // codex). Claude type-ahead's queued submits never become role:user
+    // events; Codex doesn't declare supportsTypeAhead so this is mostly a
+    // belt-and-braces gate, but keep symmetry so future adapters with
+    // type-ahead get the same protection automatically.
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !bridgeFallbackActive;
     if (!isPromptReady && !typeAheadAllowed)
         return;
-    const bridgeFallbackActive = !!bridgeJsonlPath && !lastInitConfig?.adoptMode;
     isFlushing = true;
     if (isPromptReady) {
         isPromptReady = false;
@@ -1359,21 +1885,34 @@ async function flushPending() {
             // falls inside [markTimeMs(N), markTimeMs(N+1)). Marking earlier
             // (at IPC arrival) would let a slow-finishing turn N's send leak
             // into turn N+1's window and falsely suppress its emit.
-            if (bridgeFallbackActive) {
+            if (claudeBridgeActive) {
                 try {
                     bridgeIngest();
                 }
                 catch { /* best-effort */ }
                 bridgeMarkPendingTurn(msg);
             }
+            else if (codexBridgeActive) {
+                // Codex mark works even before the rollout path is known: the
+                // queue is path-agnostic, and the late-attach below will start
+                // ingest from offset 0 so the user_message that lands shortly
+                // after still fingerprint-matches this turn.
+                codexBridgeMarkPendingTurn(msg);
+            }
             log(`Writing to PTY (flush): "${msg.substring(0, 80)}"`);
             const result = await cliAdapter.writeInput(backend, msg);
             // Persist any sessionId the adapter observed via authoritative sources
             // (Claude's pid file, Codex's history). Done independently of submit
             // outcome — the rotation is real even when the current Enter didn't
             // land, and we want next-resume to use the right id.
-            if (result?.cliSessionId)
+            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}"`);
@@ -1415,8 +1954,9 @@ function sendToPty(content) {
         // Tear down the prompt card so the user doesn't see stale options.
         send({ type: 'tui_prompt_resolved', selectedText: 'user-override' });
     }
-    // See flushPending: bridge fallback gates type-ahead off.
-    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !(bridgeJsonlPath && !lastInitConfig?.adoptMode);
+    // See flushPending: bridge fallback gates type-ahead off (claude OR codex).
+    const bridgeFallbackActive = (!!bridgeJsonlPath && !lastInitConfig?.adoptMode) || codexBridgeFallbackActive();
+    const typeAheadAllowed = cliAdapter.supportsTypeAhead && !bridgeFallbackActive;
     if (isPromptReady || isFlushing || typeAheadAllowed) {
         log(`Writing to PTY: "${content.substring(0, 80)}"`);
         flushPending(); // fire-and-forget async; no-op if already flushing
@@ -1489,22 +2029,56 @@ function spawnCli(cfg) {
         catch (err) {
             log(`captureCurrentScreen failed: ${err.message}`);
         }
-        // Bridge mode: tail Claude Code's transcript JSONL to harvest assistant
-        // turns out-of-band. Only enabled when the daemon supplied a path
-        // (claude-code adopt with a known sessionId).
+        // 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,
             });
         }
-        // Idle detection. In bridge mode we use Claude Code's real
+        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();
+            }
+        }
+        // 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)
-            : { completionPattern: undefined, readyPattern: undefined };
+            : cfg.cliId === 'codex'
+                ? createCliAdapterSync('codex', undefined)
+                : { completionPattern: undefined, readyPattern: undefined };
         idleDetector = new IdleDetector(idleAdapter);
         idleDetector.onIdle(() => {
             log('Prompt detected (idle) — adopt mode');
@@ -1514,6 +2088,12 @@ function spawnCli(cfg) {
             catch (err) {
                 log(`Bridge emit error: ${err.message}`);
             }
+            try {
+                codexBridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Codex bridge emit error: ${err.message}`);
+            }
             markPromptReady();
         });
         backend.onData(onPtyData);
@@ -1592,9 +2172,13 @@ function spawnCli(cfg) {
         }
     }
     // Wire pid + cwd so the claude-code adapter's writeInput can read
-    // ~/.claude/sessions/<pid>.json — Claude's authoritative current sessionId.
-    // The pinned claudeJsonlPath above is still used as the initial guess; the
-    // resolver corrects it on first write when Claude has rotated under us.
+    // ~/.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;
@@ -1621,6 +2205,31 @@ function spawnCli(cfg) {
             mode: cfg.resume ? 'baseline-existing' : 'fresh-empty',
         });
     }
+    // Codex bridge fallback: same intent as the Claude block above but a
+    // different transcript layout. Resume-with-known-cliSessionId can attach
+    // immediately; new sessions / resume-without-id rely on flushPending to
+    // late-attach once writeInput returns the cliSessionId.
+    if (cfg.cliId === 'codex') {
+        if (cfg.cliSessionId) {
+            const rolloutPath = findCodexRolloutBySessionId(cfg.cliSessionId);
+            if (rolloutPath) {
+                codexBridgeAttach(rolloutPath, 'baseline-existing');
+            }
+            else {
+                // Resume but the rollout file isn't where we expected — start the
+                // poller so we keep looking; if the user submits and a new file
+                // appears, late-attach kicks in via writeInput's cliSessionId.
+                codexBridgePendingSessionId = cfg.cliSessionId;
+                codexBridgeStartTimer();
+            }
+        }
+        else {
+            // Brand-new Codex session: no path until first submit. Start the
+            // poller anyway so the CLI is ready to attach the moment we have
+            // a cliSessionId.
+            codexBridgeStartTimer();
+        }
+    }
     // Set up idle detection
     idleDetector = new IdleDetector(cliAdapter);
     idleDetector.onIdle(() => {
@@ -1637,6 +2246,14 @@ function spawnCli(cfg) {
                 log(`Bridge emit error: ${err.message}`);
             }
         }
+        if (codexBridgeFallbackActive()) {
+            try {
+                codexBridgeDrainAndMaybeEmit();
+            }
+            catch (err) {
+                log(`Codex bridge emit error: ${err.message}`);
+            }
+        }
         markPromptReady();
     });
     backend.onData(onPtyData);
@@ -1670,6 +2287,7 @@ function killCli() {
     // 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 {
@@ -2119,6 +2737,17 @@ process.on('message', async (raw) => {
                     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: raw write to PTY (no adapter writeInput)
                 if (backend) {
                     if ('sendText' in backend && 'sendSpecialKeys' in backend) {