@openrig/cli 0.6.10 → 0.6.12

package/daemon/dist/adapters/tmux.js

@@ -3,11 +3,23 @@ import { writeFile as fsWriteFile, unlink as fsUnlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as pathJoin } from "node:path";
 import { randomUUID } from "node:crypto";
-function defaultTmuxFileOps() {
+import { inspectComposerInput } from "../domain/session-transport.js";
+import { parentSessionEnvKeys } from "../domain/parent-session-env.js";
+// One source for the staged script's name: the generator (defaultTmuxFileOps) and the matcher
+// (isStagedSendScriptPath) are both built from it.
+const SEND_SCRIPT_PREFIX = "openrig-tmux-send-";
+const SEND_SCRIPT_SUFFIX = ".txt";
+const SEND_SCRIPT_NAME = new RegExp(`^${SEND_SCRIPT_PREFIX}\\d+-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}${SEND_SCRIPT_SUFFIX.replace(".", "\\.")}$`);
+/** Whether `path` names a launch script sendShellCommand staged (an absolute path with the name
+ *  defaultTmuxFileOps gives it). The script removes itself first, so this is a name check only. */
+export function isStagedSendScriptPath(path) {
+    return path.startsWith("/") && SEND_SCRIPT_NAME.test(path.split("/").pop() ?? "");
+}
+export function defaultTmuxFileOps() {
     return {
         writeFile: (p, content, options) => fsWriteFile(p, content, { encoding: "utf8", ...options }),
         unlink: (p) => fsUnlink(p),
-        tmpName: () => pathJoin(tmpdir(), `openrig-tmux-send-${process.pid}-${randomUUID()}.txt`),
+        tmpName: () => pathJoin(tmpdir(), `${SEND_SCRIPT_PREFIX}${process.pid}-${randomUUID()}${SEND_SCRIPT_SUFFIX}`),
         bufferName: () => `openrig_${process.pid}_${randomUUID().replace(/-/g, "")}`,
     };
 }
@@ -49,6 +61,12 @@ const CURSOR_FORMAT = [
 function isNoServerError(err) {
     return err instanceof Error && err.message.includes("no server running");
 }
+/** The error tmux reported, without the stdout an exec error carries: in a chain that stdout is the earlier panes'
+ *  text, which an agent controls. Errors that kept no stderr classify on their message. */
+function tmuxReportedError(err) {
+    const stderr = err?.execStderr;
+    return typeof stderr === "string" ? new Error(stderr) : err;
+}
 function isSessionAbsenceError(err) {
     if (!(err instanceof Error))
         return false;
@@ -104,9 +122,14 @@ function classifyWriteError(err) {
     }
     return { ok: false, code: "unknown", message: err.message };
 }
+/** The launch warning when the parent-session identity cleanup could not finish (#771). */
+function parentSessionEnvWarning(target, err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return `${target}: could not remove the launching session's identity (for example CLAUDECODE) from this seat's environment, so the seat may still see it: ${reason}`;
+}
 /** The most sessions one batched capture chains (#308). Not a byte bound: a chunk whose output overflows exec's buffer
  *  fails and is split in half. */
-const CAPTURE_BATCH = 24;
+export const CAPTURE_BATCH = 24;
 function shellQuote(s) {
     // Replace each ' with '"'"' (end quote, double-quote the apostrophe, resume quote)
     return "'" + s.replace(/'/g, "'\"'\"'") + "'";
@@ -208,7 +231,22 @@ export class TmuxAdapter {
     exec;
     fileOps;
     argvExec;
-    deliveryGuard;
+    inputGuard;
+    get deliveryGuard() { return this.inputGuard; }
+    set deliveryGuard(guard) {
+        this.inputGuard = guard;
+        guard?.attachInputInspection(async (target, owned) => inspectComposerInput(await this.captureComposerSnapshot(target.pane ?? target.session), null, owned), async (target) => {
+            if (!target.pane)
+                return true;
+            const probe = await this.probeSession(target.session);
+            if (probe.state === "absent")
+                return true;
+            if (probe.state !== "present")
+                return false;
+            const panes = await this.listPanes(target.session);
+            return panes.length === 1 && panes[0].id === target.pane && await this.isPaneDead(target.pane);
+        });
+    }
     freshProbes = new Map();
     freshManaged = new Map();
     /** Only the private metadata probe uses this door. Success proves allocation,
@@ -269,7 +307,7 @@ export class TmuxAdapter {
             return classifyWriteError(err);
         }
     }
-    async guardedInput(target, write, allowAbsent = false) {
+    async guardedInput(target, write, allowAbsent = false, inputKind = "control") {
         const guard = this.deliveryGuard;
         if (!guard)
             return write(target, () => { });
@@ -315,6 +353,13 @@ export class TmuxAdapter {
                 const pane = fresh ? created.pane : bound.pane;
                 if (!pane || panes.length !== 1 || panes[0].id !== pane)
                     throw new Error("Managed pane identity unavailable or changed; no input written.");
+                if (inputKind === "control" && guard.needsInputCheck(identity))
+                    await guard.beforeInput(identity);
+                if (inputKind === "respawn" && guard.needsInputCheck(identity)) {
+                    if (!guard.ownsLifecycle(bound.nodeId) || !await this.isPaneDead(pane)) {
+                        throw new DeliveryGuardError("draft_aware_lifecycle", "Only a dead pane in its lifecycle operation may be respawned under draft-aware protection.");
+                    }
+                }
                 // Revalidate registry/occupant after the asynchronous observation. Write
                 // to the immutable pane ID, not a session name which could be recycled.
                 return guard.input(identity, () => write(pane, () => guard.checkInput(identity)));
@@ -350,6 +395,10 @@ export class TmuxAdapter {
             return this.argvExec(argv);
         return this.exec(legacy ?? posixJoinArgv(argv));
     }
+    /** Ends the daemon's tmux control client, and with it its session (tmux-control.ts), when tmux is driven through one. */
+    async closeControlClient() {
+        await this.argvExec?.close?.();
+    }
     /** Start an empty native terminal server, without inventing a seat/session. */
     async startServer() {
         const probeName = `openrig-startup-${randomUUID()}`;
@@ -460,8 +509,10 @@ export class TmuxAdapter {
         if (result.ok && this.deliveryGuard && env?.OPENRIG_NODE_ID) {
             try {
                 const panes = await this.listPanes(name);
-                if (panes.length === 1)
+                if (panes.length === 1) {
+                    this.deliveryGuard.noteFreshLifecyclePane(env.OPENRIG_NODE_ID, panes[0].id);
                     this.freshManaged.set(name, { nodeId: env.OPENRIG_NODE_ID, pane: panes[0].id });
+                }
             }
             catch { /* no fresh pane proof: subsequent writes remain refused */ }
         }
@@ -484,18 +535,53 @@ export class TmuxAdapter {
             argv.push("-c", cwd);
         for (const [k, v] of Object.entries(seatEnv))
             argv.push("-e", `${k}=${v}`);
+        // The pane new-session itself made: an after-new-session hook may select another window.
+        argv.push("-P", "-F", "#{pane_id}");
         const legacyParts = ["tmux", "new-session", "-d", "-s", shellQuote(name)];
         if (cwd != null)
             legacyParts.push("-c", shellQuote(cwd));
         for (const [k, v] of Object.entries(seatEnv))
             legacyParts.push("-e", shellQuote(`${k}=${v}`));
+        legacyParts.push("-P", "-F", shellQuote("#{pane_id}"));
+        let created;
         try {
-            await this.run(argv, legacyParts.join(" "));
-            return { ok: true };
+            created = (await this.run(argv, legacyParts.join(" "))).trim();
         }
         catch (err) {
             return classifyWriteError(err);
         }
+        // A tmux server started from a Claude Code session or Herdr pane hands
+        // their identity to every new pane. Mark it removed for this session only
+        // and restart the fresh pane so its shell starts without it. The session
+        // exists either way, so a failure here is a warning, never a failed launch.
+        try {
+            if (await this.excludeParentSessionEnv(exactTarget(name, "session"), Object.keys(seatEnv))) {
+                if (!/^%\d+$/.test(created))
+                    throw new Error(`new-session reported no pane id ("${created}"), so no pane was restarted`);
+                const respawn = ["tmux", "respawn-pane", "-k", "-t", created];
+                if (cwd != null)
+                    respawn.push("-c", cwd);
+                await this.run(respawn, posixJoinArgv(respawn));
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: true, warnings: [parentSessionEnvWarning(name, err)] };
+        }
+    }
+    /** Mark the server's inherited parent-session identity as removed in one
+     * session's environment, never the server's global one. Explicit seat
+     * values stay. Returns whether anything was marked. Throws when the global
+     * environment can't be read: the caller can't tell whether the seat inherits
+     * an identity, so it reports a warning (the launch still goes ahead). */
+    async excludeParentSessionEnv(sessionTarget, keep = []) {
+        const inherited = await this.globalEnvironment();
+        const keys = parentSessionEnvKeys(inherited).filter((key) => !keep.includes(key));
+        for (const key of keys) {
+            const argv = ["tmux", "set-environment", "-t", sessionTarget, "-r", key];
+            await this.run(argv, posixJoinArgv(argv));
+        }
+        return keys.length > 0;
     }
     /**
      * Bracketed paste by default, at every size. Unbracketed input can be consumed as individual
@@ -515,9 +601,17 @@ export class TmuxAdapter {
      * seats from colliding.
      */
     async sendText(target, text, beforeInput, options) {
-        return this.guardedInput(target, (pane, beforeWrite) => this.sendTextUnchecked(pane, text, () => { beforeWrite(); beforeInput?.(); }, options?.bracketed));
+        return this.guardedInput(target, (pane, beforeWrite) => {
+            const guard = this.deliveryGuard;
+            const identity = this.freshManaged.get(target)?.nodeId ?? target;
+            const policy = guard?.needsInputCheck(identity) ? {
+                beforePaste: () => guard.beforeInput(identity),
+                afterPaste: () => guard.notePasted(identity, text),
+            } : undefined;
+            return this.sendTextUnchecked(pane, text, () => { beforeWrite(); beforeInput?.(); }, options?.bracketed, policy);
+        }, false, "text");
     }
-    async sendTextUnchecked(target, text, beforeWrite, bracketed = true) {
+    async sendTextUnchecked(target, text, beforeWrite, bracketed = true, policy) {
         const path = this.fileOps.tmpName();
         const buffer = this.fileOps.bufferName();
         let bufferLoaded = false;
@@ -527,11 +621,15 @@ export class TmuxAdapter {
             created = true;
             await this.run(["tmux", "load-buffer", "-b", buffer, path], `tmux load-buffer -b ${shellQuote(buffer)} ${shellQuote(path)}`);
             bufferLoaded = true;
+            if (policy)
+                await policy.beforePaste();
             beforeWrite();
             // Explicit prompt answers need key input, not bracketed-paste framing.
             // Keep their bytes in the file: tmux command parsing and argv limits must
             // not alter semicolons or reject long answers (#519, #602).
             await this.run(["tmux", "paste-buffer", "-t", target, "-b", buffer, "-d", "-r", ...(bracketed ? ["-p"] : [])], `tmux paste-buffer -t ${shellQuote(target)} -b ${shellQuote(buffer)} -d -r${bracketed ? " -p" : ""}`);
+            if (policy)
+                await policy.afterPaste();
             return { ok: true };
         }
         catch (err) {
@@ -569,6 +667,7 @@ export class TmuxAdapter {
         // Each nested write still validates the lease and targets its observed pane.
         return this.guardedInput(target, () => this.sendShellCommandUnchecked(target, command, beforeInput, options));
     }
+    /** Stage or send a launch while leaving a consumed script's cleanup to the receiving shell. */
     async sendShellCommandUnchecked(target, command, beforeInput, options) {
         const commandBytes = Buffer.byteLength(command, "utf8");
         // POSIX shells retain subshell isolation; unknown/unreadable panes use sh.
@@ -603,15 +702,13 @@ export class TmuxAdapter {
         let created = false;
         try {
             if (path) {
-                await this.fileOps.writeFile(path, `/bin/rm -f -- ${shellQuote(path)}\n${options.execInScript ? "exec " : ""}${command}\n`, { mode: 0o600, flag: "wx" });
+                await this.fileOps.writeFile(path, `/bin/rm -f -- ${shellQuote(path)} 2>/dev/null || command rm -f -- ${shellQuote(path)} || true\n${options.execInScript ? "exec " : ""}${command}\n`, { mode: 0o600, flag: "wx" });
                 created = true;
             }
-            const text = beforeInput ? await this.guardedInput(target, (pane, check) => this.sendTextUnchecked(pane, invocation, () => { check(); beforeInput(); }))
-                : await this.sendText(target, invocation);
+            const text = await this.sendText(target, invocation, beforeInput);
             if (!text.ok)
                 return text;
-            const enter = beforeInput ? await this.guardedInput(target, pane => { beforeInput(); return this.sendKeysUnchecked(pane, ["Enter"]); })
-                : await this.sendKeys(target, ["Enter"]);
+            const enter = await this.sendKeys(target, ["Enter"], beforeInput);
             if (!enter.ok) {
                 await this.sendKeys(target, ["C-c"]);
                 return enter;
@@ -633,7 +730,18 @@ export class TmuxAdapter {
         }
     }
     async sendKeys(target, keys, beforeInput) {
-        return this.guardedInput(target, (pane, beforeWrite) => { beforeWrite(); beforeInput?.(); return this.sendKeysUnchecked(pane, keys); });
+        return this.guardedInput(target, async (pane, beforeWrite) => {
+            const identity = this.freshManaged.get(target)?.nodeId ?? target;
+            const submit = keys.some(key => key === "Enter" || key === "C-m");
+            if (this.deliveryGuard?.needsInputCheck(identity))
+                await this.deliveryGuard.beforeInput(identity, submit);
+            beforeWrite();
+            beforeInput?.();
+            const result = await this.sendKeysUnchecked(pane, keys);
+            if (result.ok && submit)
+                this.deliveryGuard?.noteSubmitted(identity);
+            return result;
+        }, false, "keys");
     }
     async sendKeysUnchecked(target, keys) {
         try {
@@ -736,7 +844,15 @@ export class TmuxAdapter {
      *  harness invocation there (`codex … resume <old-token>`), so an undefined respawn silently boots the
      *  OLD context. Callers that need a blank pane must pass an explicit shell (see getDefaultShell). */
     async respawnPane(paneTarget, command, opts) {
-        return this.guardedInput(paneTarget, pane => this.respawnPaneUnchecked(pane, command, opts));
+        return this.guardedInput(paneTarget, async (pane, beforeWrite) => {
+            beforeWrite();
+            const result = await this.respawnPaneUnchecked(pane, command, opts);
+            const guard = this.deliveryGuard;
+            const target = guard?.maybeTarget(pane);
+            if (result.ok && target && guard.ownsLifecycle(target.nodeId))
+                guard.noteFreshLifecyclePane(target.nodeId, pane);
+            return result;
+        }, false, "respawn");
     }
     async respawnPaneUnchecked(paneTarget, command, opts) {
         const exact = exactTarget(paneTarget, "pane");
@@ -757,9 +873,19 @@ export class TmuxAdapter {
                 legacyRespawn.push("-e", shellQuote(`${k}=${v}`));
         if (command != null && command.length > 0)
             legacyRespawn.push(shellQuote(command));
+        // The successor starts from the session environment: exclude inherited
+        // parent-session identity there first (sessions made before this existed).
+        // A failure here is a warning; the respawn goes ahead as it did before.
+        let warnings;
+        try {
+            await this.excludeParentSessionEnv(exact, Object.keys(opts?.env ?? {}));
+        }
+        catch (err) {
+            warnings = [parentSessionEnvWarning(exact, err)];
+        }
         try {
             await this.run(argv, legacyRespawn.join(" "));
-            return { ok: true };
+            return warnings ? { ok: true, warnings } : { ok: true };
         }
         catch (err) {
             return classifyWriteError(err);
@@ -779,6 +905,58 @@ export class TmuxAdapter {
             return classifyWriteError(err);
         }
     }
+    /** The pane's OWN value for an option, without inherited window/global values: the string, null when the
+     *  pane sets none, undefined when tmux could not be read. A caller that changes the option for a while
+     *  restores exactly this with restorePaneOption. */
+    async getPaneLocalOption(paneTarget, option) {
+        const exact = exactTarget(paneTarget, "pane");
+        try {
+            const output = await this.run(["tmux", "show-options", "-p", "-v", "-t", exact, option], `tmux show-options -p -v -t ${shellQuote(exact)} ${shellQuote(option)}`);
+            // tmux prints nothing for an unset option and the value plus a newline when set (an empty value prints
+            // a bare newline), so only the line ending is removed: the value comes back exactly as it was set.
+            return output.length === 0 ? null : output.replace(/\r?\n$/, "");
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Put back what getPaneLocalOption read: set the value, or unset the pane's own value when it had none. */
+    async restorePaneOption(paneTarget, option, value) {
+        const exact = exactTarget(paneTarget, "pane");
+        const argv = value === null
+            ? ["tmux", "set-option", "-p", "-u", "-t", exact, option]
+            : ["tmux", "set-option", "-p", "-t", exact, option, value];
+        try {
+            await this.run(argv, argv.map((part, index) => index < 2 ? part : shellQuote(part)).join(" "));
+            return { ok: true };
+        }
+        catch (err) {
+            return classifyWriteError(err);
+        }
+    }
+    /** The pane's whole text, history and visible screen, with wrapped lines joined. Null when unreadable. */
+    async capturePaneHistory(paneTarget) {
+        const exact = exactTarget(paneTarget, "pane");
+        try {
+            return await this.run(["tmux", "capture-pane", "-p", "-J", "-t", exact, "-S", "-", "-E", "-"], `tmux capture-pane -p -J -t ${shellQuote(exact)} -S - -E -`);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Signal one process by pid. signalPaneProcess signals the pane's root, which in a shell-backed pane is
+     *  the shell, not the runtime running under it. Unix `kill`, like signalPaneProcess. */
+    async signalPid(pid, signal) {
+        if (!Number.isInteger(pid) || pid <= 1)
+            return { ok: false, code: "invalid_pid", message: `Refusing to signal pid ${pid}.` };
+        try {
+            await this.exec(`kill -${signal} ${pid}`);
+            return { ok: true };
+        }
+        catch (err) {
+            return classifyWriteError(err);
+        }
+    }
     /** Seat-handover cutover: is the pane's process dead (the retiree exited; the pane held by
      *  remain-on-exit)? A known-missing pane also proves physical cutover; unknown probe errors stay false. */
     async isPaneDead(paneId) {
@@ -851,6 +1029,25 @@ export class TmuxAdapter {
             return null;
         }
     }
+    /** Whether a pane is in a mode such as copy mode. tmux reports #{pane_in_mode} as the number of
+     *  modes the pane is in, so any count above 0 is in a mode. Returns null if unavailable. */
+    async isPaneInMode(paneId) {
+        const target = exactTarget(paneId, "pane");
+        try {
+            const output = await this.run(["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"], `tmux display-message -p -t ${shellQuote(target)} "#{pane_in_mode}"`);
+            const trimmed = output.trim();
+            if (!/^\d+$/.test(trimmed))
+                return null;
+            return Number(trimmed) > 0;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Leave the pane's current mode (copy mode) with `send-keys -X cancel`, through the same input guard as sendKeys. */
+    async cancelPaneMode(target) {
+        return this.guardedInput(target, (pane, beforeWrite) => { beforeWrite(); return this.sendKeysUnchecked(pane, ["-X", "cancel"]); });
+    }
     /** A launch metadata read. Callers must never put credential values in terminal input. */
     async getSessionEnv(session, key) {
         if (!/^[A-Z_][A-Z0-9_]*$/.test(key))
@@ -870,6 +1067,36 @@ export class TmuxAdapter {
             throw new Error("Cannot read the session's launch environment.");
         }
     }
+    /** Set one variable in a session's environment: what its next spawned process inherits, not a
+     *  running one. Callers that pass a value are putting it on a tmux command line. */
+    async setSessionEnv(session, key, value) {
+        if (!/^[A-Z_][A-Z0-9_]*$/.test(key))
+            throw new Error("Invalid session environment key.");
+        const target = exactTarget(session, "session");
+        await this.run(["tmux", "set-environment", "-t", target, key, value], `tmux set-environment -t ${shellQuote(target)} ${shellQuote(key)} ${shellQuote(value)}`);
+    }
+    /** Remove one variable from a session's environment, so a process spawned there afterwards
+     *  inherits the server's value for it, or none. A name that is the launching session's own
+     *  identity in the server's environment (see parent-session-env) is marked removed instead, as a
+     *  launch does, so the server's value does not come back. */
+    async unsetSessionEnv(session, key) {
+        if (!/^[A-Z_][A-Z0-9_]*$/.test(key))
+            throw new Error("Invalid session environment key.");
+        const target = exactTarget(session, "session");
+        const parentIdentity = parentSessionEnvKeys(await this.globalEnvironment()).includes(key);
+        const flag = parentIdentity ? "-r" : "-u";
+        await this.run(["tmux", "set-environment", "-t", target, flag, key], `tmux set-environment -t ${shellQuote(target)} ${flag} ${shellQuote(key)}`);
+    }
+    async globalEnvironment() {
+        const global = await this.run(["tmux", "show-environment", "-g"], "tmux show-environment -g");
+        const inherited = {};
+        for (const line of global.split(/\r?\n/)) {
+            const eq = line.indexOf("=");
+            if (eq > 0)
+                inherited[line.slice(0, eq)] = line.slice(eq + 1);
+        }
+        return inherited;
+    }
     /** OPR.0.4.3.28 Part C — usable-presence check for a session-env variable.
      *  Returns whether the var has a nonblank value, NEVER that value, and null
      *  when the session environment cannot be inspected. Listing the environment
@@ -917,38 +1144,27 @@ export class TmuxAdapter {
     }
     /** Capture pane content (last N lines). Returns null if unavailable. */
     /**
-     * Capture many sessions' panes with a few tmux calls instead of one per session (#308). One `list-sessions` says
-     * which targets exist: a missing one maps to null (as a failed per-target capture) without a fork. The live ones
-     * are captured in chunks of CAPTURE_BATCH chained commands (a `display-message` marker, then `capture-pane`), each
-     * pane's output delimited by a marker unique to the call, so the text equals what `capturePaneContent` returns.
-     * Targets are exact (`=<name>:`): no prefix match, and a name with a "." still resolves. tmux stops a chain at its
-     * first failing command, so a chunk that fails is split in half and retried (an oversized output, or a session gone
-     * since the listing); a single session that still fails is left OUT of the map, and the caller reads it per target.
-     * Null when tmux can't be listed at all. Each entry carries the time its own chunk was read (`capturedAt`), so a
-     * slow later chunk can't make an earlier capture look fresh.
+     * Capture many sessions' panes with a few tmux calls instead of one per session (#308). A `list-sessions` runs next
+     * to the first chained call and is read only when a chain fails: a target it lacks maps to null (as a failed
+     * per-target capture) without a fork. The targets are captured in chunks of CAPTURE_BATCH chained commands (a
+     * `display-message` marker, then `capture-pane`), each pane's output delimited by a marker unique to the call, so the
+     * text equals what `capturePaneContent` returns. Targets are exact (`=<name>:`): no prefix match, and a name with a
+     * "." still resolves. tmux stops a chain at its first failing command, so a failed chunk drops the targets the
+     * listing lacks (`missing`) and retries, or is split in half (an oversized output, or a session gone since the
+     * listing); a single session that still fails is left OUT of the map, and the caller reads it per target. A server
+     * gone since the listing maps the chunk to null without a retry. Any other chain error leaves the chunk out, so the
+     * caller reads each pane per target, as an unbatched read does. Null when a chain fails because the server is gone
+     * or its socket can't be reached, and tmux can't be listed; a chain that fails for another reason while the listing
+     * fails too leaves the chunk to per-target reads. Each entry carries the time its own chunk was read (`capturedAt`), so a slow later
+     * chunk can't make an earlier capture look fresh.
      */
     async capturePanesContent(targets, lines = 20, now = () => new Date()) {
-        let live;
-        try {
-            const listing = await this.run(["tmux", "list-sessions", "-F", "#{session_name}"], "tmux list-sessions -F '#{session_name}'");
-            live = new Set(listing.split(/\r?\n/).filter(Boolean));
-        }
-        catch {
-            return null;
-        }
+        const listing = this.run(["tmux", "list-sessions", "-F", "#{session_name}"], "tmux list-sessions -F '#{session_name}'")
+            .then((output) => new Set(output.split(/\r?\n/).filter(Boolean)), () => null);
         const out = new Map();
-        const listedAt = now();
-        const present = [];
-        for (const t of new Set(targets)) {
-            if (live.has(t))
-                present.push(t);
-            else
-                out.set(t, { text: null, capturedAt: listedAt });
-        }
-        // A chunk that fails is split in half and retried, down to one session: its output overflowed exec's buffer (wide,
-        // colour-dense panes: each capture is the visible pane plus the requested history) or a session vanished since
-        // the listing. A single session that still fails is left out: the caller reads it per target.
-        /** Capture one chunk with a single chained tmux call into `out`; on failure, split it in half and retry each half. */
+        let unlisted = false;
+        /** Capture one chunk with a single chained tmux call into `out`; on failure, retry it without the unlisted targets
+         *  or split it in half. */
         const captureChunk = async (chunk) => {
             const nonce = randomUUID().replace(/-/g, "");
             const mark = (k) => `__openrig_capture_${nonce}_${k}__`;
@@ -963,11 +1179,45 @@ export class TmuxAdapter {
                 output = await this.run(argv, legacy);
                 capturedAt = now(); // when THIS chunk's panes were read, not when the sweep ends
             }
-            catch {
-                if (chunk.length > 1) {
+            catch (err) {
+                const live = await listing;
+                if (!live) {
+                    // A failed listing doesn't show the server is gone; the chain's own error does.
+                    const cause = tmuxReportedError(err);
+                    if (isNoServerError(cause) || isTmuxTransportAbsentError(cause))
+                        unlisted = true;
+                    return;
+                }
+                // The listing answered, so the server was up: the targets it lacks are dropped first.
+                const listedAt = now();
+                const present = [];
+                for (const t of chunk) {
+                    if (live.has(t))
+                        present.push(t);
+                    else
+                        out.set(t, { text: null, capturedAt: listedAt, missing: true });
+                }
+                if (present.length < chunk.length) {
+                    if (present.length)
+                        await captureChunk(present);
+                    return;
+                }
+                const cause = tmuxReportedError(err);
+                // Every half would fail the same way: the server is gone.
+                if (isNoServerError(cause) || isTmuxTransportAbsentError(cause)) {
+                    for (const t of chunk)
+                        out.set(t, { text: null, capturedAt: listedAt });
+                    return;
+                }
+                // Halving helps only an output that overflowed exec's buffer (wide, colour-dense panes) or a session that
+                // vanished since the listing. Any other error would fail every half, so the chunk is left to per-target reads.
+                // Node's overflow error is the message's first line; pane text follows it.
+                if (!/^.*maxBuffer length exceeded/.test(err.message) && !isSessionAbsenceError(cause) && !isPaneAbsenceError(cause)) {
+                    return;
+                }
+                else if (chunk.length > 1) {
                     const half = Math.ceil(chunk.length / 2);
-                    await captureChunk(chunk.slice(0, half));
-                    await captureChunk(chunk.slice(half));
+                    await Promise.all([captureChunk(chunk.slice(0, half)), captureChunk(chunk.slice(half))]);
                 }
                 return; // a single session that failed: read per target by the caller
             }
@@ -995,16 +1245,19 @@ export class TmuxAdapter {
                 out.set(t, { text: text === "" ? null : text, capturedAt });
             });
         };
-        for (let i = 0; i < present.length; i += CAPTURE_BATCH)
-            await captureChunk(present.slice(i, i + CAPTURE_BATCH));
-        return out;
+        const unique = [...new Set(targets)];
+        for (let i = 0; i < unique.length && !unlisted; i += CAPTURE_BATCH)
+            await captureChunk(unique.slice(i, i + CAPTURE_BATCH));
+        return unlisted && out.size === 0 ? null : out;
     }
     async capturePaneContent(paneId, lines = 20, opts) {
         const target = exactTarget(paneId, "pane");
         // `-e` keeps text styling, such as the faint rendering of a suggestion.
         const styled = opts?.escapeSequences === true;
+        // Verification can recover mid-word soft wraps without erasing logical newlines.
+        const joined = opts?.joinWrappedLines === true;
         try {
-            const output = await this.run(["tmux", "capture-pane", "-p", ...(styled ? ["-e"] : []), "-t", target, "-S", `-${lines}`], `tmux capture-pane -p${styled ? " -e" : ""} -t ${shellQuote(target)} -S -${lines}`);
+            const output = await this.run(["tmux", "capture-pane", "-p", ...(styled ? ["-e"] : []), ...(joined ? ["-J"] : []), "-t", target, "-S", `-${lines}`], `tmux capture-pane -p${styled ? " -e" : ""}${joined ? " -J" : ""} -t ${shellQuote(target)} -S -${lines}`);
             return output || null;
         }
         catch {
@@ -1017,16 +1270,35 @@ export class TmuxAdapter {
      * screen, NOT `-S -<lines>` scrollback: scrollback reintroduces the row drift
      * the absolute-paint seed exists to eliminate.
      */
-    async capturePaneScreen(paneId) {
+    async capturePaneScreen(paneId, escapeSequences = false) {
         const target = exactTarget(paneId, "pane");
         try {
-            const output = await this.run(["tmux", "capture-pane", "-p", "-t", target], `tmux capture-pane -p -t ${shellQuote(target)}`);
+            const output = await this.run(["tmux", "capture-pane", "-p", ...(escapeSequences ? ["-e"] : []), "-t", target], `tmux capture-pane -p${escapeSequences ? " -e" : ""} -t ${shellQuote(target)}`);
             return output || null;
         }
         catch {
             return null;
         }
     }
+    /** Cursor movement during capture is an unknown input, never permission to type. */
+    async captureComposerSnapshot(paneId) {
+        try {
+            const before = await this.getPaneCursorPosition(paneId);
+            if (!before)
+                return null;
+            const screen = await this.capturePaneScreen(paneId, true);
+            if (screen === null)
+                return null;
+            const mode = (await this.run(["tmux", "display-message", "-p", "-t", exactTarget(paneId, "pane"), "#{pane_in_mode}"])).trim();
+            const after = await this.getPaneCursorPosition(paneId);
+            if (!after || JSON.stringify(before) !== JSON.stringify(after) || !/^\d+$/.test(mode))
+                return null;
+            return { screen, cursor: after, inMode: Number(mode) !== 0 };
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Get the current cursor coordinates and pane geometry. Coordinates are
      * zero-based. Returns null if unavailable or if tmux yields non-finite /
@@ -1135,6 +1407,29 @@ export class TmuxAdapter {
      *   - `null` when the target is missing OR the value is unparseable
      *     (consumers treat null as "no signal", distinct from "idle").
      */
+    /** readAllSessionWindowActivity with a key of each current window's active pane from the same call. tmux changes
+     *  what a capture returns without counting activity on a resize, a reset, a respawn, a pane switch or a
+     *  clear-history; each moves the pane's id, pid, size, history size or bytes, or its cursor. The session name stays last. */
+    async readAllSessionWindows() {
+        try {
+            const format = ["#{window_active}", "#{window_activity}", "#{window_width}x#{window_height}:#{pane_id}:#{pane_pid}:#{pane_width}x#{pane_height}:#{history_size}:#{history_bytes}:#{cursor_x},#{cursor_y}", "#{session_name}"].join(TMUX_FIELD_SEPARATOR);
+            const output = await this.run(["tmux", "list-windows", "-a", "-F", format], `tmux list-windows -a -F '${format}'`);
+            const out = new Map();
+            for (const line of output.split("\n")) {
+                const f1 = line.indexOf(TMUX_FIELD_SEPARATOR), f2 = line.indexOf(TMUX_FIELD_SEPARATOR, f1 + 1), f3 = line.indexOf(TMUX_FIELD_SEPARATOR, f2 + 1);
+                if (f1 < 0 || f2 < 0 || f3 < 0)
+                    continue;
+                const activity = line.slice(f1 + 1, f2).trim(), session = line.slice(f3 + 1);
+                if (!session || line.slice(0, f1) !== "1" || !/^\d+$/.test(activity) || Number(activity) <= 0)
+                    continue;
+                out.set(session, { activity: Number(activity), size: line.slice(f2 + 1, f3) });
+            }
+            return out;
+        }
+        catch {
+            return null;
+        }
+    }
     /** Every session's current-window `#{window_activity}` in ONE tmux call, keyed by session name: the same value
      *  `readPaneLastActivity(<session name>)` reads (display-message -t <session> resolves to the session's current
      *  window). Only well-formed timestamps are included, so a missing key means "read it the per-target way". Null when