botmux 2.55.0 → 2.56.0

package/dist/worker.js

@@ -34,6 +34,7 @@ import { DEFAULT_RENDER_COLS, DEFAULT_RENDER_ROWS, MAX_RENDER_COLS, MAX_RENDER_R
 import { createCliAdapterSync } from './adapters/cli/registry.js';
 import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds, DEFAULT_CLAUDE_DATA_DIR } from './adapters/cli/claude-code.js';
 import { mtrSessionIdForBotmuxSession } from './adapters/cli/mtr.js';
+import { HerdrBackend } from './adapters/backend/herdr-backend.js';
 import { TmuxBackend } from './adapters/backend/tmux-backend.js';
 import { TmuxPipeBackend } from './adapters/backend/tmux-pipe-backend.js';
 import { ZellijBackend, ZELLIJ_CONFIG_KDL } from './adapters/backend/zellij-backend.js';
@@ -64,6 +65,7 @@ let isTmuxMode = false;
  *  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 effectiveBackendType = 'pty';
 /** pty-under-zellij backend (BACKEND_TYPE=zellij). Behaves like the non-tmux
  *  pty path for the worker (renderer screenshots, relay web terminal) but owns
  *  a persistent zellij session that survives daemon restart. */
@@ -210,6 +212,8 @@ let bridgePendingTail = '';
 const bridgeQueue = new BridgeTurnQueue();
 let bridgeWatcher = null;
 let bridgeFallbackTimer = null;
+let herdrAdoptBridgeQuietTimer = null;
+const HERDR_ADOPT_BRIDGE_QUIET_MS = 3_000;
 /** 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
@@ -421,6 +425,37 @@ function bridgeProbeOpenSessionIds() {
     for (const path of opened)
         bridgeRememberSessionIdForPath(path);
 }
+function bridgeShouldEmitAfterTranscriptQuiet() {
+    return lastInitConfig?.adoptMode === true
+        && lastInitConfig?.adoptSource === 'herdr'
+        && lastInitConfig?.cliId === 'claude-code'
+        && !!bridgeJsonlPath;
+}
+function clearHerdrAdoptBridgeQuietTimer() {
+    if (!herdrAdoptBridgeQuietTimer)
+        return;
+    clearTimeout(herdrAdoptBridgeQuietTimer);
+    herdrAdoptBridgeQuietTimer = null;
+}
+function scheduleHerdrAdoptBridgeQuietEmit() {
+    if (!bridgeShouldEmitAfterTranscriptQuiet())
+        return;
+    clearHerdrAdoptBridgeQuietTimer();
+    herdrAdoptBridgeQuietTimer = setTimeout(() => {
+        herdrAdoptBridgeQuietTimer = null;
+        if (!bridgeShouldEmitAfterTranscriptQuiet())
+            return;
+        try {
+            bridgeDrainAndMaybeEmit();
+            markPromptReady();
+            log('Bridge quiet emit attempted — herdr adopt mode');
+        }
+        catch (err) {
+            log(`Bridge quiet emit error: ${err.message}`);
+        }
+    }, HERDR_ADOPT_BRIDGE_QUIET_MS);
+    herdrAdoptBridgeQuietTimer.unref?.();
+}
 function bridgeAbsorbBaseline() {
     if (!bridgeJsonlPath)
         return;
@@ -523,7 +558,7 @@ function bridgeApplyFingerprintSwitch(matched, reason, cutoffMs) {
     try {
         bridgeWatcher = fsWatch(matched, { persistent: false }, () => {
             try {
-                bridgeIngest();
+                performBridgeIngestAndScheduleQuietEmit();
             }
             catch (err) {
                 log(`Bridge ingest error: ${err.message}`);
@@ -800,7 +835,7 @@ function performRotationSwitch(newPath, cutoffMs, reason) {
     try {
         bridgeWatcher = fsWatch(newPath, { persistent: false }, () => {
             try {
-                bridgeIngest();
+                performBridgeIngestAndScheduleQuietEmit();
             }
             catch (err) {
                 log(`Bridge ingest error: ${err.message}`);
@@ -985,7 +1020,7 @@ function maybeFollowSessionRotationViaPid() {
     try {
         bridgeWatcher = fsWatch(resolved.path, { persistent: false }, () => {
             try {
-                bridgeIngest();
+                performBridgeIngestAndScheduleQuietEmit();
             }
             catch (err) {
                 log(`Bridge ingest error: ${err.message}`);
@@ -1083,6 +1118,14 @@ function bridgeIngest() {
     bridgePendingTail = result.pendingTail;
     bridgeQueue.ingest(result.events, bridgeJsonlPath);
 }
+function performBridgeIngestAndScheduleQuietEmit() {
+    const beforePath = bridgeJsonlPath;
+    const beforeOffset = bridgeOffset;
+    bridgeIngest();
+    if (bridgeJsonlPath && (bridgeJsonlPath !== beforePath || bridgeOffset > beforeOffset)) {
+        scheduleHerdrAdoptBridgeQuietEmit();
+    }
+}
 function startBridgeWatcher(jsonlPath, opts) {
     bridgeJsonlPath = jsonlPath;
     bridgeJsonlDir = dirname(jsonlPath);
@@ -1172,7 +1215,7 @@ function startBridgeWatcher(jsonlPath, opts) {
     try {
         bridgeWatcher = fsWatch(bridgeJsonlPath, { persistent: false }, () => {
             try {
-                bridgeIngest();
+                performBridgeIngestAndScheduleQuietEmit();
             }
             catch (err) {
                 log(`Bridge ingest error: ${err.message}`);
@@ -1184,7 +1227,7 @@ function startBridgeWatcher(jsonlPath, opts) {
     }
     bridgeFallbackTimer = setInterval(() => {
         try {
-            bridgeIngest();
+            performBridgeIngestAndScheduleQuietEmit();
         }
         catch (err) {
             log(`Bridge ingest error: ${err.message}`);
@@ -1192,6 +1235,7 @@ function startBridgeWatcher(jsonlPath, opts) {
     }, 1000);
 }
 function stopBridgeWatcher() {
+    clearHerdrAdoptBridgeQuietTimer();
     if (bridgeWatcher) {
         try {
             bridgeWatcher.close();
@@ -2776,7 +2820,170 @@ function stopScreenUpdates() {
     lastAnalyzerSnapshot = '';
 }
 // ─── PTY Management ──────────────────────────────────────────────────────────
+function setupAdoptTranscriptBridges(cfg) {
+    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) {
+            codexBridgeAttach(rolloutPath, 'split-live');
+        }
+        else {
+            if (cfg.cliSessionId)
+                codexBridgePendingSessionId = cfg.cliSessionId;
+            codexAdoptPendingPid = cfg.adoptCliPid;
+            codexBridgeStartTimer();
+        }
+    }
+    else if (cfg.cliId === 'coco') {
+        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) {
+            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 {
+            codexAdoptPendingPid = cfg.adoptCliPid;
+        }
+        codexBridgeStartTimer();
+    }
+    else if (cfg.cliId === 'mtr') {
+        const adoptStartMs = Date.now();
+        codexAdoptStartMs = adoptStartMs;
+        codexBridgeQueue.setLocalTurns(true, adoptStartMs);
+        if (cfg.cliSessionId)
+            codexBridgePendingSessionId = cfg.cliSessionId;
+        const source = findMtrSessionById(cfg.cliSessionId)
+            ?? findLatestMtrSessionByDirectory(cfg.adoptCwd ?? cfg.workingDir);
+        if (source) {
+            codexBridgePendingSessionId = undefined;
+            mtrBridgeAttach(source, 'split-live');
+        }
+        else {
+            codexBridgeStartTimer();
+        }
+    }
+}
+function adoptIdleAdapter(cfg) {
+    return cfg.bridgeJsonlPath
+        ? createCliAdapterSync('claude-code', undefined)
+        : cfg.cliId === 'codex' || cfg.cliId === 'coco' || cfg.cliId === 'mtr'
+            ? createCliAdapterSync(cfg.cliId, undefined)
+            : { completionPattern: undefined, readyPattern: undefined };
+}
+function setupAdoptInputAdapter(cfg) {
+    if (cfg.cliId === 'codex') {
+        cliAdapter = createCliAdapterSync('codex', cfg.cliPathOverride);
+    }
+    else if (cfg.cliId === 'mtr') {
+        cliAdapter = createCliAdapterSync('mtr', cfg.cliPathOverride);
+    }
+}
+function setupAdoptIdleDetection(cfg, label) {
+    idleDetector = new IdleDetector(adoptIdleAdapter(cfg));
+    idleDetector.onIdle(() => {
+        log(`Prompt detected (idle) — ${label} adopt mode`);
+        try {
+            bridgeDrainAndMaybeEmit();
+        }
+        catch (err) {
+            log(`Bridge emit error: ${err.message}`);
+        }
+        try {
+            codexBridgeDrainAndMaybeEmit();
+        }
+        catch (err) {
+            log(`Codex bridge emit error: ${err.message}`);
+        }
+        markPromptReady();
+    });
+}
+function seedBackendScreen(source, be) {
+    try {
+        const initial = be.captureCurrentScreen?.() ?? '';
+        if (initial.length > 0)
+            onPtyData(initial);
+    }
+    catch (err) {
+        log(`${source} captureCurrentScreen failed: ${err.message}`);
+    }
+}
 function spawnCli(cfg) {
+    // ── Adopt mode: observe the user's existing terminal backend (no attach) ──
+    if (cfg.adoptMode && cfg.adoptSource === 'herdr' && cfg.adoptHerdrSessionName && (cfg.adoptHerdrPaneId || cfg.adoptHerdrTarget)) {
+        isTmuxMode = false;
+        isPipeMode = true;
+        isZellijMode = false;
+        const cols = cfg.adoptPaneCols ?? PTY_COLS;
+        const rows = cfg.adoptPaneRows ?? PTY_ROWS;
+        const target = cfg.adoptHerdrTarget ?? cfg.adoptHerdrPaneId;
+        const herdrBe = new HerdrBackend(cfg.adoptHerdrSessionName, {
+            externalTarget: {
+                sessionName: cfg.adoptHerdrSessionName,
+                target,
+                paneId: cfg.adoptHerdrPaneId,
+            },
+        });
+        effectiveBackendType = 'herdr';
+        backend = herdrBe;
+        herdrBe.spawn('', [], {
+            cwd: cfg.workingDir,
+            cols,
+            rows,
+            env: process.env,
+        });
+        seedBackendScreen('herdr adopt', herdrBe);
+        setupAdoptTranscriptBridges(cfg);
+        setupAdoptInputAdapter(cfg);
+        setupAdoptIdleDetection(cfg, 'herdr');
+        backend.onData(onPtyData);
+        backend.onExit((code, signal) => {
+            log(`Adopted herdr stream ended (code: ${code}, signal: ${signal})`);
+            backend = null;
+            isPromptReady = false;
+            stopBridgeWatcher();
+            send({ type: 'claude_exit', code, signal });
+        });
+        awaitingFirstPrompt = false;
+        renderer?.markNewTurn();
+        log(`Adopt mode (herdr): observing ${cfg.adoptHerdrSessionName}:${target} (${cols}x${rows})`);
+        return;
+    }
+    // ── Adopt mode: pipe-pane the user's existing tmux pane (no attach) ──
     // ── Adopt mode: observe the user's existing pane (no attach / non-invasive) ──
     // tmux: pipe-pane (raw stream). zellij: dump-screen poll + action drive.
     if (cfg.adoptMode && (cfg.adoptTmuxTarget || cfg.adoptZellijPaneId)) {
@@ -2786,11 +2993,13 @@ function spawnCli(cfg) {
         // PTY-per-WS — we don't attach to anything).
         isTmuxMode = true;
         isPipeMode = true;
+        isZellijMode = !!cfg.adoptZellijPaneId;
         const cols = cfg.adoptPaneCols ?? PTY_COLS;
         const rows = cfg.adoptPaneRows ?? PTY_ROWS;
         const observeBe = cfg.adoptZellijPaneId
             ? new ZellijObserveBackend(cfg.adoptZellijSession ?? '', cfg.adoptZellijPaneId, { cliPid: cfg.adoptCliPid })
             : new TmuxPipeBackend(cfg.adoptTmuxTarget);
+        effectiveBackendType = cfg.adoptZellijPaneId ? 'zellij' : 'tmux';
         backend = observeBe;
         observeBe.spawn('', [], {
             cwd: cfg.workingDir,
@@ -2801,162 +3010,10 @@ function spawnCli(cfg) {
         // 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 observe tick.
-        try {
-            const initial = observeBe.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();
-        }
-        else if (cfg.cliId === 'mtr') {
-            const adoptStartMs = Date.now();
-            codexAdoptStartMs = adoptStartMs;
-            codexBridgeQueue.setLocalTurns(true, adoptStartMs);
-            if (cfg.cliSessionId)
-                codexBridgePendingSessionId = cfg.cliSessionId;
-            const source = findMtrSessionById(cfg.cliSessionId)
-                ?? findLatestMtrSessionByDirectory(cfg.adoptCwd ?? cfg.workingDir);
-            if (source) {
-                codexBridgePendingSessionId = undefined;
-                mtrBridgeAttach(source, 'split-live');
-            }
-            else {
-                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' || cfg.cliId === 'mtr'
-                ? 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);
-        }
-        else if (cfg.cliId === 'mtr') {
-            cliAdapter = createCliAdapterSync('mtr', 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();
-        });
+        seedBackendScreen(`${effectiveBackendType} adopt`, observeBe);
+        setupAdoptTranscriptBridges(cfg);
+        setupAdoptIdleDetection(cfg, 'pipe');
+        setupAdoptInputAdapter(cfg);
         backend.onData(onPtyData);
         backend.onExit((code, signal) => {
             log(`Adopted pipe-pane stream ended (code: ${code}, signal: ${signal})`);
@@ -2967,7 +3024,8 @@ function spawnCli(cfg) {
         });
         awaitingFirstPrompt = false;
         renderer?.markNewTurn();
-        log(`Adopt mode (pipe): observing ${cfg.adoptTmuxTarget} (${cols}x${rows})`);
+        const target = cfg.adoptZellijPaneId ? `${cfg.adoptZellijSession}/${cfg.adoptZellijPaneId}` : cfg.adoptTmuxTarget;
+        log(`Adopt mode (${effectiveBackendType}): observing ${target} (${cols}x${rows})`);
         return;
     }
     cliAdapter = createCliAdapterSync(cfg.cliId, cfg.cliPathOverride);
@@ -2981,10 +3039,15 @@ function spawnCli(cfg) {
         log('tmux backend requested but functional probe failed — falling back to PTY backend');
         effectiveBackend = 'pty';
     }
+    if (effectiveBackend === 'herdr' && !HerdrBackend.isAvailable()) {
+        log('herdr backend requested but probe failed — falling back to PTY backend');
+        effectiveBackend = 'pty';
+    }
     if (effectiveBackend === 'zellij' && !ZellijBackend.isAvailable()) {
         log('zellij backend requested but functional probe failed (need zellij >= 0.44) — falling back to PTY backend');
         effectiveBackend = 'pty';
     }
+    effectiveBackendType = effectiveBackend;
     const selectedBackend = selectSessionBackend({ sessionId: cfg.sessionId, backendType: effectiveBackend });
     isTmuxMode = selectedBackend.isTmuxMode;
     isPipeMode = selectedBackend.isPipeMode;
@@ -3049,13 +3112,22 @@ function spawnCli(cfg) {
     // just `tmux attach-session`s — logging `Spawning: <new bin>` in that case
     // is misleading and has cost real debugging time. (CliId-mismatch reattach
     // is now blocked upstream in restoreActiveSessions / killStalePids.)
-    const willReattachTmux = isTmuxMode && TmuxBackend.hasSession(TmuxBackend.sessionName(cfg.sessionId));
-    const willReattachZellij = isZellijMode && ZellijBackend.hasSession(ZellijBackend.sessionName(cfg.sessionId));
-    if (willReattachTmux) {
-        log(`Re-attaching to existing tmux session: ${TmuxBackend.sessionName(cfg.sessionId)} (requested CLI: ${cliAdapter.resolvedBin})`);
-    }
-    else if (willReattachZellij) {
-        log(`Re-attaching to existing zellij session: ${ZellijBackend.sessionName(cfg.sessionId)} (requested CLI: ${cliAdapter.resolvedBin})`);
+    const persistentSessionName = effectiveBackendType === 'tmux'
+        ? TmuxBackend.sessionName(cfg.sessionId)
+        : effectiveBackendType === 'herdr'
+            ? HerdrBackend.sessionName(cfg.sessionId)
+            : effectiveBackendType === 'zellij'
+                ? ZellijBackend.sessionName(cfg.sessionId)
+                : undefined;
+    const willReattachPersistent = persistentSessionName
+        ? effectiveBackendType === 'tmux'
+            ? TmuxBackend.hasSession(persistentSessionName)
+            : effectiveBackendType === 'zellij'
+                ? ZellijBackend.hasSession(persistentSessionName)
+                : HerdrBackend.hasSession(persistentSessionName)
+        : false;
+    if (willReattachPersistent) {
+        log(`Re-attaching to existing ${effectiveBackendType} session: ${persistentSessionName} (requested CLI: ${cliAdapter.resolvedBin})`);
     }
     else {
         log(`Spawning fresh CLI: ${cliAdapter.resolvedBin} ${args.join(' ')} (cwd: ${cfg.workingDir})`);
@@ -3253,16 +3325,9 @@ function spawnCli(cfg) {
         isPromptReady = false;
         send({ type: 'claude_exit', code, signal });
     });
-    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}`);
-        }
+    if (isPipeMode && backend && 'isReattach' in backend && backend.isReattach) {
+        log(`Re-attached to existing ${effectiveBackendType} session via pipe backend: ${persistentSessionName}`);
+        seedBackendScreen(`${effectiveBackendType} reattach`, backend);
     }
     // 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
@@ -4014,6 +4079,13 @@ process.on('message', async (raw) => {
                 break;
             }
             log('Restart requested');
+            // Must destroySession(), not kill(): for persistent backends (tmux/herdr)
+            // kill() only detaches — the backing session + CLI process keep running,
+            // so the resume:true spawnCli below would re-attach to the SAME live CLI
+            // (selectSessionBackend reattaches whenever hasSession() is true) and the
+            // process would never actually restart. destroySession() tears the session
+            // down so the respawn starts a fresh CLI. (PTY has no destroySession, so
+            // the ?. no-ops and killCli()'s kill() does the teardown.)
             backend?.destroySession?.();
             killCli();
             awaitingFirstPrompt = true;