@openrig/cli 0.6.11 → 0.6.12

package/daemon/dist/adapters/tmux.js

@@ -3,6 +3,7 @@ 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";
+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.
@@ -60,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;
@@ -122,7 +129,7 @@ function parentSessionEnvWarning(target, err) {
 }
 /** 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, "'\"'\"'") + "'";
@@ -224,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,
@@ -285,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, () => { });
@@ -331,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)));
@@ -366,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()}`;
@@ -476,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 */ }
         }
@@ -540,13 +575,7 @@ export class TmuxAdapter {
      * 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 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);
-        }
+        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];
@@ -572,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;
@@ -584,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) {
@@ -626,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.
@@ -660,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;
@@ -690,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 {
@@ -793,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");
@@ -970,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))
@@ -989,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
@@ -1036,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}__`;
@@ -1082,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
             }
@@ -1114,9 +1245,10 @@ 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");
@@ -1138,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 /
@@ -1256,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