@monotykamary/localterm-server 2.66.8 → 2.66.10

package/dist/session-manager.js

@@ -1,49 +1,16 @@
-import { randomBytes } from "node:crypto";
 import path from "node:path";
-import zlib from "node:zlib";
-import { CaptureRenderer } from "./capture-renderer.js";
-import { CAPTURE_PANE_MAX_LINES, EXEC_DEFAULT_OUTPUT_LIMIT_BYTES, EXEC_DEFAULT_TIMEOUT_MS, EXEC_EPHEMERAL_SCROLLBACK, EXEC_MAX_OUTPUT_LIMIT_BYTES, EXEC_MAX_TIMEOUT_MS, EXEC_RAW_ACCUMULATE_CAP_BYTES, EXEC_TIMEOUT_INTERRUPT_GRACE_MS, MAX_AUTOMATION_LOG_LENGTH, MAX_CONCURRENT_SESSIONS, MAX_OUTPUT_BYTES, OUTPUT_BATCH_FLUSH_BYTES, OUTPUT_BATCH_WINDOW_MS, SESSION_ACTIVITY_WINDOW_MS, SESSION_GRACE_MS, SESSION_PENDING_PROMOTE_TIMEOUT_MS, WAIT_IDLE_POLL_INTERVAL_MS, WS_BACKPRESSURE_THRESHOLD_BYTES, WS_CLOSE_BACKPRESSURE, WS_OUTBOUND_DRAIN_POLL_MS, WS_OUTBOUND_PAUSE_HIGH_WATER_BYTES, WS_OUTBOUND_RESUME_LOW_WATER_BYTES, WS_READY_STATE_OPEN, WS_OUTPUT_BROTLI, WS_OUTPUT_BROTLI_CTX, WS_OUTPUT_BROTLI_QUALITY, WS_OUTPUT_COMPRESS_THRESHOLD_BYTES, WS_OUTPUT_CTX_HEADER_BYTES, WS_OUTPUT_GZIP, WS_OUTPUT_GZIP_LEVEL, WS_OUTPUT_RAW, } from "./constants.js";
-import { GitDiffWatcher, GIT_DIFF_WATCHER_EVENT_NAMES, } from "./git-diff-watcher.js";
-import { GitMetadataCoordinator } from "./git-metadata-coordinator.js";
+import { SESSION_GRACE_MS, SESSION_PENDING_PROMOTE_TIMEOUT_MS } from "./constants.js";
+import { GitDiffWatcher } from "./git-diff-watcher.js";
 import { Session } from "./session.js";
-const makeBrotliEncoder = (level) => {
-    const enc = zlib.createBrotliCompress({
-        params: { [zlib.constants.BROTLI_PARAM_QUALITY]: level },
-    });
-    let buf = Buffer.alloc(0);
-    enc.on("data", (d) => {
-        buf = Buffer.concat([buf, d]);
-    });
-    let chain = Promise.resolve(Buffer.alloc(0));
-    const flush = (bytes) => {
-        chain = chain.then(() => new Promise((resolve) => {
-            const before = buf.length;
-            enc.write(bytes);
-            enc.flush(zlib.constants.BROTLI_OPERATION_FLUSH, () => {
-                setImmediate(() => {
-                    const out = buf.subarray(before, buf.length);
-                    buf = buf.subarray(buf.length);
-                    resolve(out);
-                });
-            });
-        }));
-        return chain;
-    };
-    const release = () => {
-        try {
-            enc.destroy();
-        }
-        catch {
-            /* already closed */
-        }
-    };
-    return { flush, release };
-};
+import { SessionClientHub } from "./session-client-hub.js";
+import { SessionCommandExecutor } from "./session-command-executor.js";
+import { SessionGitEventBridge } from "./session-git-event-bridge.js";
+import { SessionLifecyclePolicy } from "./session-lifecycle-policy.js";
+import { SessionOutputCoordinator } from "./session-output-coordinator.js";
+import { SessionOutputTransport } from "./session-output-transport.js";
 import { createSynchronizedOutputEndDetector, } from "./utils/create-synchronized-output-end-detector.js";
 import { resolveNamedKeys } from "./utils/named-keys.js";
 import { deletePasteImagesForSession } from "./utils/paste-image-store.js";
-import { stripAnsi } from "./utils/strip-ansi.js";
-import { getBufferedAmount } from "./utils/ws-socket.js";
 // Owns every live PTY for the daemon's lifetime. A Session is created on spawn
 // and stays here until its shell exits, it's explicitly killed, or its
 // no-clients grace timer fires — NOT the instant its client disconnects. One
@@ -59,36 +26,44 @@ import { getBufferedAmount } from "./utils/ws-socket.js";
 // backpressure instead of dropping the connection.
 export class SessionManager {
     sessions = new Map();
-    wsToClient = new Map();
     lastOutputAtByPid = new Map();
-    coordinatorsByCwd = new Map();
     hooks;
     sendControl;
-    getGraceMs;
-    pendingPromoteTimeoutMs;
+    outputTransport;
+    clientHub;
+    commandExecutor;
+    gitEventBridge;
+    lifecyclePolicy;
+    outputCoordinator;
     shimsDir;
     constructor(options) {
         this.hooks = options.hooks;
         this.sendControl = options.sendControl;
-        this.getGraceMs = options.getGraceMs ?? (() => SESSION_GRACE_MS);
-        this.pendingPromoteTimeoutMs =
-            options.pendingPromoteTimeoutMs ?? SESSION_PENDING_PROMOTE_TIMEOUT_MS;
+        this.outputTransport = new SessionOutputTransport(options.sendControl);
+        this.lifecyclePolicy = new SessionLifecyclePolicy(options.getGraceMs ?? (() => SESSION_GRACE_MS), (managed) => this.tearDown(managed), () => this.hooks.onSessionActivity());
+        this.clientHub = new SessionClientHub({
+            outputTransport: this.outputTransport,
+            sendControl: this.sendControl,
+            pendingPromoteTimeoutMs: options.pendingPromoteTimeoutMs ?? SESSION_PENDING_PROMOTE_TIMEOUT_MS,
+            sessionFor: (id, owner) => this.sessionFor(id, owner),
+            cancelGrace: (managed) => this.lifecyclePolicy.cancelGrace(managed),
+            startGrace: (managed) => this.lifecyclePolicy.startGrace(managed),
+            onSessionActivity: () => this.hooks.onSessionActivity(),
+        });
+        this.commandExecutor = new SessionCommandExecutor();
+        this.gitEventBridge = new SessionGitEventBridge(this.clientHub, (event, cwd) => this.hooks.onSessionEvent(event, cwd));
+        this.outputCoordinator = new SessionOutputCoordinator({
+            outputTransport: this.outputTransport,
+            noteOutputActivity: (pid) => this.noteOutput(pid),
+            onOutputActivity: () => this.hooks.onOutputActivity(),
+        });
         this.shimsDir = options.shimsDir;
     }
     size() {
         return this.sessions.size;
     }
     atCapacity() {
-        if (this.sessions.size < MAX_CONCURRENT_SESSIONS)
-            return false;
-        for (const managed of this.sessions.values()) {
-            // A dormant, non-pinned session can be evicted to make room. Pinned
-            // sessions hold their slots (never silently reaped), so a full cap of
-            // pinned sessions surfaces a real capacity error instead of a steal.
-            if (managed.clients.size === 0 && !managed.pinned)
-                return false;
-        }
-        return true;
+        return this.lifecyclePolicy.atCapacity(this.sessions);
     }
     // Shell pids of every live session. The keep-awake manager scopes its `ps`
     // tree walk to these so automatic mode only reacts to programs running inside
@@ -144,83 +119,19 @@ export class SessionManager {
             createdAt: managed.createdAt,
             lastOutputAt: managed.lastOutputAt,
             clients: managed.clients.size,
-            clientProfiles: this.clientProfilesFor(managed),
-            state: this.computeState(managed),
+            clientProfiles: this.clientHub.clientProfilesFor(managed),
+            state: this.lifecyclePolicy.computeState(managed),
             pinned: managed.pinned,
         }));
     }
-    // The attached clients grouped by their per-browser-profile handle, for the
-    // session picker's per-profile peer display. Each entry counts how many of
-    // that profile's windows are viewing this PTY; sorted by count desc then id
-    // for a stable order (the picker re-ranks its own profile to the front).
-    clientProfilesFor(managed) {
-        const counts = new Map();
-        for (const client of managed.clients) {
-            counts.set(client.windowId, (counts.get(client.windowId) ?? 0) + 1);
-        }
-        return [...counts.entries()]
-            .map(([windowId, count]) => ({ windowId, count }))
-            .sort((a, b) => b.count - a.count || a.windowId.localeCompare(b.windowId));
-    }
-    // The persisted workspace manifest: every currently-open tab, grouped by
-    // (owner, windowId), recording the live cwd + shell to respawn it in. A
-    // session with N attached clients of one windowId contributes N tabs (each
-    // viewer is a tab). Automation-run sessions are skipped (their tabs are
-    // one-shot), and sessions with no clients (dormant/orphaned) contribute
-    // nothing — only tabs that are actively open are restored. Computed from
-    // in-memory state, so the daemon snapshots it to disk before a graceful
-    // stop (and debounced during life for crash recovery).
     workspaceEntries() {
-        const byKey = new Map();
-        const now = Date.now();
-        for (const managed of this.sessions.values()) {
-            if (managed.automation)
-                continue;
-            if (managed.clients.size === 0)
-                continue;
-            const cwd = managed.session.lastEmittedCwd || managed.session.cwd;
-            const shell = managed.session.shell;
-            const tab = { cwd, shell };
-            for (const client of managed.clients) {
-                if (!client.windowId)
-                    continue;
-                const key = `${managed.owner ?? ""}\u0000${client.windowId}`;
-                let entry = byKey.get(key);
-                if (!entry) {
-                    entry = { owner: managed.owner, windowId: client.windowId, tabs: [], savedAt: now };
-                    byKey.set(key, entry);
-                }
-                entry.tabs.push(tab);
-            }
-        }
-        return [...byKey.values()];
+        return this.clientHub.workspaceEntries(this.sessions.values());
     }
-    // The (owner, windowId) a socket's tab is viewing, for scoping a CDP
-    // workspace restore to the browser profile that just reconnected. Returns
-    // null when the socket isn't attached to a session (e.g. a transient
-    // mid-detach state).
     clientProfile(ws) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry)
-            return null;
-        return { owner: entry.session.owner, windowId: entry.client.windowId };
+        return this.clientHub.clientProfile(ws);
     }
-    // How many of a browser profile's tabs are currently attached to a (non-
-    // automation) session — the "already open" count the restore reconciles
-    // the persisted manifest against. Surviving tabs that reattach after a
-    // daemon restart are counted here so the daemon only opens the deficit.
     attachedClientCount(owner, windowId) {
-        let count = 0;
-        for (const managed of this.sessions.values()) {
-            if (owner !== null && managed.owner !== owner)
-                continue;
-            if (managed.automation)
-                continue;
-            for (const client of managed.clients)
-                if (client.windowId === windowId)
-                    count++;
-        }
-        return count;
+        return this.clientHub.attachedClientCount(this.sessions.values(), owner, windowId);
     }
     // Every live PTY whose current cwd is inside `targetPath` (or equals it). A
     // live PTY — attached, dormant (parked in the no-clients grace window), or
@@ -287,9 +198,7 @@ export class SessionManager {
         managed.session.emit("notification", body);
     }
     spawn(input, automation, owner = null) {
-        if (this.sessions.size >= MAX_CONCURRENT_SESSIONS)
-            this.evictOldestDormant();
-        if (this.sessions.size >= MAX_CONCURRENT_SESSIONS)
+        if (!this.lifecyclePolicy.makeRoomForSession(this.sessions))
             return null;
         const session = new Session(this.shimsDir ? { ...input, shimsDir: this.shimsDir } : input);
         const managed = {
@@ -345,211 +254,23 @@ export class SessionManager {
             return null;
         return managed;
     }
-    // Attach `ws` to a live PTY by id. Returns the session to reattach to, or
-    // null when the id is unknown / already exited — the caller spawns fresh.
     attach(ws, id, owner = null, windowId = "") {
-        const managed = this.sessionFor(id, owner);
-        if (!managed)
-            return null;
-        // Re-subscribing cancels the no-clients grace timer (if armed): the shell
-        // has a viewer again, so it stays alive.
-        this.cancelGrace(managed);
-        // Notify existing subscribers a peer joined (a mobile ingested this
-        // session's share QR) so a host can react — e.g. the desktop's QR modal
-        // auto-closes. Gated on existing clients so a fresh spawn's first attach
-        // stays silent, and fired before adding the joiner so it isn't told about
-        // itself. See peerAttachedMessageSchema for the frame's payload rationale.
-        if (managed.clients.size > 0)
-            this.broadcast(managed, { type: "peer-attached" });
-        const coordinator = this.coordinatorForCwd(managed.session.cwd);
-        const client = {
-            ws,
-            pending: true,
-            pendingControl: [],
-            pendingBytes: [],
-            pendingTimer: null,
-            cols: 0,
-            rows: 0,
-            windowId,
-            coordinator,
-            compressMode: null,
-            brotliEncoder: null,
-            terminalResponder: false,
-        };
-        coordinator.add(ws);
-        managed.clients.add(client);
-        this.wsToClient.set(ws, { client, session: managed });
-        this.recomputeResize(managed);
-        // Seed a joiner with the current effective size when it's entering an
-        // already-multi-viewer session whose min its own (possibly wider) report
-        // doesn't change — recomputeResize only broadcasts on a change, so without
-        // this the new viewer would never learn it's constrained and would render
-        // no mask. A fresh spawn (now the lone viewer) has no stored size and is
-        // skipped, and a joiner that changes the min is reached by the broadcast.
-        if (managed.clients.size > 1 && managed.ptySizeCols !== null && managed.ptySizeRows !== null) {
-            this.sendToClient(client, {
-                type: "pty-size",
-                cols: managed.ptySizeCols,
-                rows: managed.ptySizeRows,
-            });
-        }
-        // Auto-promote a client that never sends {type:"ready"} — a back-compat
-        // client (an older bundled terminal, or any plain WS reader) would otherwise
-        // stay pending and never receive output. The localterm client sends ready
-        // within milliseconds of the session frame; the window is sized to clear a
-        // mobile/tailscale RTT (often DERP-relayed) so its {ready} lands first and
-        // its scrollback replay still lands before live fan-out. `promote` always
-        // sends `replay-end`, so even a slow link that auto-promotes with
-        // `replay: false` can't deadlock the client in its replay window.
-        client.pendingTimer = setTimeout(() => void this.promote(ws, false), this.pendingPromoteTimeoutMs);
-        client.pendingTimer.unref?.();
-        this.hooks.onSessionActivity();
-        return managed;
+        return this.clientHub.attach(ws, id, owner, windowId);
     }
-    // Promote a pending client to live fan-out. Idempotent (a no-op once the
-    // client is already live), so the pending timeout and an explicit {ready}
-    // can race safely. When `replay` is true the session's scrollback ring
-    // buffer is sent as one binary frame first, then the control messages and
-    // output bytes buffered while pending flush in order — so a tab switching
-    // to this PTY lands on recent output instead of a blank screen, with no
-    // live frame interleaving between replay and the buffered fan-out.
-    //
-    // `replay-end` is sent on EVERY promote (not just `replay: true`): the
-    // localterm client opens its suppressed-replay window on the {session}
-    // frame — before its {ready} reaches us — so a slow link whose pending
-    // timeout auto-promotes with `replay: false` would otherwise never send the
-    // marker the client is waiting on, deadlocking it on a blank screen with
-    // every output frame buffered client-side. The auto-promote's `replay-end`
-    // lets the client flush whatever it buffered (the pending bytes that raced
-    // ahead of the marker) and rejoin live fan-out. A client that didn't open the
-    // window (a silent reattach, or a back-compat reader) treats it as a no-op.
     async promote(ws, replay, compress = null) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry)
-            return;
-        const client = entry.client;
-        if (!client.pending)
-            return;
-        if (client.pendingTimer !== null) {
-            clearTimeout(client.pendingTimer);
-            client.pendingTimer = null;
-        }
-        client.compressMode = compress;
-        this.ensureTerminalResponder(entry.session, client);
-        // Reset the persistent Brotli encoder: a new promote is a fresh attach (a
-        // PTY switch or reconnect), so the prior screen's LZ77 context is stale.
-        // The first frame of the new stream has no prior context (the per-frame
-        // equivalent); subsequent frames compress against it.
-        if (client.brotliEncoder !== null) {
-            client.brotliEncoder.release();
-            client.brotliEncoder = null;
-        }
-        if (compress === "br-ctx")
-            client.brotliEncoder = makeBrotliEncoder(WS_OUTPUT_BROTLI_QUALITY);
-        // Tell the client the chosen compress mode BEFORE the scrollback replay so
-        // it knows how to parse the compressed replay frames. A back-compat server
-        // that doesn't know "br-ctx" never sends this frame, so an old-server +
-        // new-client pair degrades to raw (no header) instead of mis-parsing.
-        this.sendControl(ws, { type: "compress", mode: compress });
-        if (replay) {
-            await this.sendScrollback(ws, entry.session, client);
-        }
-        // Tell the client the replay bytes have all landed so it can write them as
-        // one suppressed block (dropping xterm's responses to the stale query
-        // requests in the ring buffer). Sent on every promote — even when the
-        // snapshot was empty or replay wasn't requested — so the client always
-        // exits its suppressed-replay window and never deadlocks on a slow link.
-        this.sendControl(ws, { type: "replay-end" });
-        for (const payload of client.pendingControl)
-            this.sendControl(ws, payload);
-        for (const bytes of client.pendingBytes)
-            await this.sendOutputFrame(ws, bytes, client);
-        client.pendingControl = [];
-        client.pendingBytes = [];
-        client.pending = false;
-        // Re-push the ambient git-diff summary to the now-live client so a summary
-        // pushed while pending (and wiped by the client's cwd-driven null-reset on
-        // a cwd change during the pending window) is restored. See
-        // GitMetadataCoordinator.replayLastSummary.
-        client.coordinator?.replayLastSummary(ws);
+        return this.clientHub.promote(ws, replay, compress);
     }
     writeInput(ws, data) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry)
-            return;
-        // A client sending input is clearly live and wants output. Promote it out
-        // of the pending hold without a scrollback replay — a back-compat client
-        // that never sends {type:"ready"} still unblocks on its first keystroke.
-        // The localterm client sends {type:"ready"} before any input, so this is a
-        // no-op for it. Promote flushes any buffered output before the input echoes.
-        if (entry.client.pending)
-            void this.promote(ws, false);
-        // Query replies follow the viewer that most recently drove the PTY.
-        this.assignTerminalResponder(entry.session, entry.client);
-        entry.session.session.write(data);
+        this.clientHub.writeInput(ws, data);
     }
     writeTerminalResponse(ws, data) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry?.client.terminalResponder)
-            return;
-        this.writeInput(ws, data);
-    }
-    ensureTerminalResponder(managed, preferredClient) {
-        for (const client of managed.clients) {
-            if (client.terminalResponder)
-                return;
-        }
-        const nextClient = preferredClient ??
-            Array.from(managed.clients).find((client) => !client.pending) ??
-            managed.clients.values().next().value;
-        if (nextClient)
-            this.assignTerminalResponder(managed, nextClient);
-    }
-    assignTerminalResponder(managed, responder) {
-        for (const client of managed.clients)
-            client.terminalResponder = client === responder;
+        this.clientHub.writeTerminalResponse(ws, data);
     }
     resize(ws, cols, rows, pixelWidth, pixelHeight) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry)
-            return;
-        entry.client.cols = cols;
-        entry.client.rows = rows;
-        entry.client.pixelWidth = pixelWidth;
-        entry.client.pixelHeight = pixelHeight;
-        this.recomputeResize(entry.session);
+        this.clientHub.resize(ws, cols, rows, pixelWidth, pixelHeight);
     }
-    // Detach a single client. If this was the last subscriber, arm the
-    // no-clients grace timer: the PTY stays alive for SESSION_GRACE_MS so a
-    // transient drop or a switch can re-attach, then is reaped if nobody does.
     detach(ws) {
-        const entry = this.wsToClient.get(ws);
-        if (!entry)
-            return;
-        this.wsToClient.delete(ws);
-        const managed = entry.session;
-        const client = entry.client;
-        if (client.pendingTimer !== null) {
-            clearTimeout(client.pendingTimer);
-            client.pendingTimer = null;
-        }
-        if (client.brotliEncoder !== null) {
-            client.brotliEncoder.release();
-            client.brotliEncoder = null;
-        }
-        client.pendingControl = [];
-        client.pendingBytes = [];
-        if (client.coordinator) {
-            client.coordinator.remove(ws);
-            this.releaseCoordinator(client.coordinator);
-        }
-        managed.clients.delete(client);
-        if (client.terminalResponder)
-            this.ensureTerminalResponder(managed);
-        this.recomputeResize(managed);
-        if (managed.clients.size === 0 && !managed.session.isExited)
-            this.startGrace(managed);
-        this.hooks.onSessionActivity();
+        this.clientHub.detach(ws);
     }
     kill(id, owner = null) {
         const managed = this.sessions.get(id);
@@ -572,7 +293,7 @@ export class SessionManager {
     disposeAll() {
         for (const managed of [...this.sessions.values()])
             this.tearDown(managed);
-        this.coordinatorsByCwd.clear();
+        this.clientHub.dispose();
         this.lastOutputAtByPid.clear();
     }
     // Spawn a PTY with no attached WebSocket — the REST/CLI path (POST /api/sessions,
@@ -588,8 +309,9 @@ export class SessionManager {
         managed.pinned = pinned;
         // A detached session has no client to detach from, so arm the grace now (a
         // no-op arm when pinned — startGrace parks it indefinitely instead).
-        if (managed.clients.size === 0 && !managed.session.isExited)
-            this.startGrace(managed);
+        if (managed.clients.size === 0 && !managed.session.isExited) {
+            this.lifecyclePolicy.startGrace(managed);
+        }
         return managed.id;
     }
     // Write input to a session by id — the REST/CLI send-keys path. Unlike the
@@ -622,9 +344,7 @@ export class SessionManager {
         const managed = this.sessionFor(id, owner);
         if (!managed)
             return null;
-        const capped = lines && lines > 0 ? Math.min(lines, CAPTURE_PANE_MAX_LINES) : undefined;
-        const renderer = await this.ensureCaptureRenderer(managed);
-        return renderer.capture(capped);
+        return this.commandExecutor.capturePane(managed, lines);
     }
     // Toggle a session's pinned flag — PATCH /api/sessions/:id. Re-arms (or
     // cancels) the grace timer live for a dormant session so the change takes
@@ -634,8 +354,9 @@ export class SessionManager {
         if (!managed || (owner !== null && managed.owner !== owner))
             return false;
         managed.pinned = pinned;
-        if (managed.clients.size === 0 && !managed.session.isExited)
-            this.startGrace(managed);
+        if (managed.clients.size === 0 && !managed.session.isExited) {
+            this.lifecyclePolicy.startGrace(managed);
+        }
         return true;
     }
     // Rename a session — PATCH /api/sessions/:id. The shell's next OSC title or
@@ -672,68 +393,7 @@ export class SessionManager {
         const managed = this.sessionFor(id, owner);
         if (!managed)
             return null;
-        const session = managed.session;
-        const startedAt = Date.now();
-        let resolved = false;
-        let lastChangeAt = Date.now();
-        let timeoutHandle = null;
-        let idleTimer = null;
-        return new Promise((resolve) => {
-            const finalize = async (matched) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
-                if (idleTimer)
-                    clearInterval(idleTimer);
-                session.off("output", onOutput);
-                session.off("exit", onExit);
-                const snapshot = await this.capturePane(id).catch(() => "");
-                resolve({
-                    matched,
-                    elapsedMs: Date.now() - startedAt,
-                    snapshot: snapshot ?? "",
-                });
-            };
-            const testPredicate = async () => {
-                const renderer = await this.ensureCaptureRenderer(managed);
-                await renderer.flush();
-                return predicate.test(renderer.capture());
-            };
-            const onOutput = () => {
-                lastChangeAt = Date.now();
-                void testPredicate().then((hit) => {
-                    if (hit && !resolved)
-                        finalize(true);
-                });
-            };
-            const onExit = () => {
-                void finalize(false);
-            };
-            // Idle mode: resolve once no output has arrived for `idleMs`. The interval
-            // checks recency without forcing a renderer read each tick (the output
-            // listener already bumps lastChangeAt).
-            if (predicate.kind === "idle") {
-                idleTimer = setInterval(() => {
-                    if (!resolved && Date.now() - lastChangeAt >= (idleMs ?? 0))
-                        finalize(true);
-                }, WAIT_IDLE_POLL_INTERVAL_MS);
-                idleTimer.unref?.();
-            }
-            else {
-                // Text/regex: test once up front in case the pane already matches, then
-                // react to output events.
-                void testPredicate().then((hit) => {
-                    if (hit && !resolved)
-                        finalize(true);
-                });
-            }
-            session.on("output", onOutput);
-            session.on("exit", onExit);
-            timeoutHandle = setTimeout(() => finalize(false), timeoutMs);
-            timeoutHandle.unref?.();
-        });
+        return this.commandExecutor.waitFor(managed, predicate, timeoutMs, idleMs);
     }
     // Resolve the (col, row) of a label on the session's visible viewport — the
     // `mouse --on-text` coord source. Reads the capture renderer's grid (the same
@@ -743,9 +403,7 @@ export class SessionManager {
         const managed = this.sessionFor(id, owner);
         if (!managed)
             return null;
-        const renderer = await this.ensureCaptureRenderer(managed);
-        await renderer.flush();
-        return renderer.findTextInViewport(needle);
+        return this.commandExecutor.findTextInViewport(managed, needle);
     }
     // Whether the session's foreground app enabled a mouse tracking mode — gates
     // the SGR-1006 fallback for `mouse` when no CDP tab is available.
@@ -763,22 +421,6 @@ export class SessionManager {
             return { cols: 0, rows: 0 };
         return { cols: managed.session.cols, rows: managed.session.rows };
     }
-    // Lazily create (and prime) a session's capture renderer. Fed the scrollback
-    // snapshot at creation so it catches up on recent history before the renderer
-    // existed, then kept alive and fed live output by onSessionOutput. Awaits the
-    // snapshot's async parse so the first capture-pane read lands on a populated
-    // grid instead of a blank one (xterm parses `write` on a timer).
-    async ensureCaptureRenderer(managed) {
-        if (managed.captureRenderer)
-            return managed.captureRenderer;
-        const renderer = new CaptureRenderer(managed.session.cols, managed.session.rows);
-        const snapshot = managed.session.snapshotScrollback();
-        if (snapshot)
-            renderer.write(snapshot);
-        await renderer.flush();
-        managed.captureRenderer = renderer;
-        return renderer;
-    }
     // Run a single shell command line inside a persistent session, capture its
     // rendered output, and return its exit code — the blocking tmux send-keys +
     // capture-pane replacement for agents. The command and its completion marker
@@ -792,432 +434,20 @@ export class SessionManager {
         const managed = this.sessionFor(id, owner);
         if (!managed)
             return null;
-        const session = managed.session;
-        const timeoutMs = this.clampInt(options.timeoutMs ?? EXEC_DEFAULT_TIMEOUT_MS, 1, EXEC_MAX_TIMEOUT_MS);
-        const outputLimit = this.clampInt(options.outputLimitBytes ?? EXEC_DEFAULT_OUTPUT_LIMIT_BYTES, 1, EXEC_MAX_OUTPUT_LIMIT_BYTES);
-        const token = randomBytes(8).toString("hex");
-        const startMarker = `__LT_S_${token}__`;
-        const endMarkerPrefix = `__LT_E_${token}__`;
-        const endPattern = new RegExp(`${endMarkerPrefix} (\\d+)`);
-        const cmd = command.trim() || ":";
-        const wrapped = `printf '${startMarker}\\n'; ${cmd}; printf '${endMarkerPrefix} %d\\n' "$?"`;
-        const startedAt = Date.now();
-        let accumulated = "";
-        let capped = false;
-        let exitCode = null;
-        let didTimeout = false;
-        let resolved = false;
-        let timeoutHandle = null;
-        let interruptHandle = null;
-        return new Promise((resolve) => {
-            const finalize = async (finalExit, finalTimedOut) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
-                if (interruptHandle)
-                    clearTimeout(interruptHandle);
-                session.off("output", onOutput);
-                session.off("exit", onExit);
-                resolve(await this.buildExecResult(session.cols, session.rows, accumulated, startMarker, endMarkerPrefix, finalExit, finalTimedOut, outputLimit, startedAt));
-            };
-            const onOutput = (data) => {
-                if (!capped) {
-                    if (accumulated.length + data.length <= EXEC_RAW_ACCUMULATE_CAP_BYTES) {
-                        accumulated += data;
-                    }
-                    else {
-                        const room = EXEC_RAW_ACCUMULATE_CAP_BYTES - accumulated.length;
-                        if (room > 0)
-                            accumulated += data.slice(0, room);
-                        capped = true;
-                    }
-                }
-                // Once the timeout has fired we've committed to a timed-out result; a
-                // marker arriving during the interrupt grace (Ctrl-C kills the command,
-                // the trailing `printf END $?` runs with the interrupt exit code) is
-                // ignored so the call resolves as timed out, not as a normal completion.
-                if (didTimeout)
-                    return;
-                const match = accumulated.match(endPattern);
-                if (match) {
-                    exitCode = Number.parseInt(match[1], 10);
-                    finalize(exitCode, false);
-                }
-            };
-            const onExit = (code) => {
-                exitCode = code;
-                finalize(code, false);
-            };
-            session.on("output", onOutput);
-            session.on("exit", onExit);
-            timeoutHandle = setTimeout(() => {
-                // Commit to a timed-out result: the command didn't finish within
-                // timeoutMs. Send Ctrl-C to interrupt it (so the session returns to a
-                // prompt for a follow-up call), then resolve after a short grace so any
-                // output already in flight is captured into the partial result. A marker
-                // arriving during the grace is ignored (see onOutput).
-                didTimeout = true;
-                session.write("\x03");
-                interruptHandle = setTimeout(() => finalize(null, true), EXEC_TIMEOUT_INTERRUPT_GRACE_MS);
-                interruptHandle.unref?.();
-            }, timeoutMs);
-            timeoutHandle.unref?.();
-            // A client sending input is live; for a detached session there's no
-            // pending handshake, so the bytes reach the PTY directly.
-            session.write(`${wrapped}\r`);
-        });
-    }
-    async buildExecResult(cols, rows, accumulated, startMarker, endMarkerPrefix, exitCode, timedOut, outputLimit, startedAt) {
-        // Render the captured raw stream through a fresh headless terminal and slice
-        // between the start/end marker rows for clean, ANSI-processed text. A fresh
-        // (not the persistent) renderer so this exec's output is isolated and the
-        // markers are always near the bottom of the buffer.
-        const renderer = new CaptureRenderer(cols, rows, EXEC_EPHEMERAL_SCROLLBACK);
-        let output;
-        try {
-            renderer.write(accumulated);
-            await renderer.flush();
-            const endRow = exitCode !== null && !timedOut ? renderer.findRow(`${endMarkerPrefix} ${exitCode}`) : -1;
-            const startRow = renderer.findRow(startMarker);
-            output = renderer.extractBetween(startRow, endRow);
-        }
-        finally {
-            renderer.dispose();
-        }
-        const textBytes = Buffer.byteLength(output, "utf8");
-        const truncated = textBytes > outputLimit;
-        if (truncated) {
-            output = Buffer.from(output, "utf8").subarray(0, outputLimit).toString("utf8");
-        }
-        return {
-            exitCode,
-            output,
-            timedOut,
-            truncated,
-            durationMs: Date.now() - startedAt,
-        };
-    }
-    clampInt(value, min, max) {
-        return Math.min(Math.max(Math.trunc(value), min), max);
-    }
-    async sendScrollback(ws, managed, client) {
-        const snapshot = managed.session.snapshotScrollback();
-        if (!snapshot)
-            return;
-        const bytes = Buffer.from(snapshot, "utf8");
-        for (let offset = 0; offset < bytes.byteLength; offset += MAX_OUTPUT_BYTES) {
-            await this.sendOutputFrame(ws, bytes.subarray(offset, offset + MAX_OUTPUT_BYTES), client);
-        }
-    }
-    sendOutputBytes(ws, bytes) {
-        if (ws.readyState !== WS_READY_STATE_OPEN)
-            return;
-        if (getBufferedAmount(ws) > WS_BACKPRESSURE_THRESHOLD_BYTES) {
-            ws.close(WS_CLOSE_BACKPRESSURE, "backpressure");
-            return;
-        }
-        try {
-            ws.send(bytes);
-        }
-        catch {
-            /* socket closed between readyState check and send */
-        }
-    }
-    compressPayload(bytes, mode) {
-        return mode === "br"
-            ? zlib.brotliCompressSync(bytes, {
-                params: { [zlib.constants.BROTLI_PARAM_QUALITY]: WS_OUTPUT_BROTLI_QUALITY },
-            })
-            : zlib.gzipSync(bytes, { level: WS_OUTPUT_GZIP_LEVEL });
-    }
-    frameWithHeader(header, payload) {
-        const out = Buffer.allocUnsafe(1 + payload.length);
-        out[0] = header;
-        out.set(payload, 1);
-        return out;
-    }
-    // 5-byte header for the context-takeover mode: 0x03 + 4-byte LE raw size, so
-    // the client can size-delimit a frame out of the persistent DecompressionStream
-    // (which doesn't end per frame and emits in arbitrary 16KB chunks).
-    frameWithCtxHeader(compressed, rawSize) {
-        const out = Buffer.allocUnsafe(WS_OUTPUT_CTX_HEADER_BYTES + compressed.length);
-        out[0] = WS_OUTPUT_BROTLI_CTX;
-        out.writeUInt32LE(rawSize, 1);
-        out.set(compressed, WS_OUTPUT_CTX_HEADER_BYTES);
-        return out;
-    }
-    async sendOutputFrame(ws, bytes, client) {
-        const mode = client.compressMode;
-        if (mode === null) {
-            this.sendOutputBytes(ws, bytes);
-            return;
-        }
-        if (bytes.length < WS_OUTPUT_COMPRESS_THRESHOLD_BYTES) {
-            this.sendOutputBytes(ws, this.frameWithHeader(WS_OUTPUT_RAW, bytes));
-            return;
-        }
-        if (mode === "br-ctx") {
-            const compressed = await client.brotliEncoder.flush(bytes);
-            this.sendOutputBytes(ws, this.frameWithCtxHeader(compressed, bytes.length));
-            return;
-        }
-        const compressed = this.compressPayload(bytes, mode);
-        this.sendOutputBytes(ws, this.frameWithHeader(mode === "br" ? WS_OUTPUT_BROTLI : WS_OUTPUT_GZIP, compressed));
-    }
-    broadcastBytes(managed, bytes) {
-        if (bytes.length === 0)
-            return;
-        const compressible = bytes.length >= WS_OUTPUT_COMPRESS_THRESHOLD_BYTES;
-        let brotli = null;
-        let gzip = null;
-        for (const client of managed.clients) {
-            if (client.pending) {
-                client.pendingBytes.push(bytes);
-                continue;
-            }
-            const mode = client.compressMode;
-            if (mode === null) {
-                this.sendOutputBytes(client.ws, bytes);
-                continue;
-            }
-            if (!compressible) {
-                this.sendOutputBytes(client.ws, this.frameWithHeader(WS_OUTPUT_RAW, bytes));
-                continue;
-            }
-            if (mode === "br-ctx") {
-                // Per-client persistent stream: the flush is async (chained per encoder
-                // in PTY order), so fire-and-forget here — the chain preserves order
-                // across this client's frames and sendOutputBytes checks
-                // readyState/backpressure at send time.
-                void client
-                    .brotliEncoder.flush(bytes)
-                    .then((compressed) => this.sendOutputBytes(client.ws, this.frameWithCtxHeader(compressed, bytes.length)));
-                continue;
-            }
-            if (mode === "br") {
-                if (brotli === null)
-                    brotli = this.compressPayload(bytes, "br");
-                this.sendOutputBytes(client.ws, this.frameWithHeader(WS_OUTPUT_BROTLI, brotli));
-            }
-            else {
-                if (gzip === null)
-                    gzip = this.compressPayload(bytes, "gzip");
-                this.sendOutputBytes(client.ws, this.frameWithHeader(WS_OUTPUT_GZIP, gzip));
-            }
-        }
-    }
-    sendToClient(client, payload) {
-        if (client.pending) {
-            client.pendingControl.push(payload);
-            return;
-        }
-        this.sendControl(client.ws, payload);
-    }
-    broadcast(managed, payload) {
-        for (const client of managed.clients)
-            this.sendToClient(client, payload);
-    }
-    // Fan a control message out to every client currently viewing any session
-    // owned by the same identity as `managed`, not just `managed`'s own viewers.
-    // Used for notifications so a user who stepped away to another session still
-    // gets the ping; owner-scoped so a notification never crosses an identity
-    // boundary (a non-operator client can only be attached to an owner-matching
-    // session, so matching session.owner === managed.owner is the partition).
-    broadcastToOwner(managed, payload) {
-        for (const { client, session } of this.wsToClient.values()) {
-            if (session.owner === managed.owner)
-                this.sendToClient(client, payload);
-        }
-    }
-    onSessionOutput(managed, data) {
-        const didEndSynchronizedOutput = managed.synchronizedOutputEndDetector.push(data);
-        managed.outputBatch += data;
-        managed.lastOutputAt = Date.now();
-        if (managed.automation)
-            this.appendAutomationLog(managed, data);
-        this.noteOutput(managed.session.pid);
-        this.hooks.onOutputActivity();
-        // Keep the capture renderer (if one exists) in lockstep with the PTY so a
-        // later capture-pane reads current rendered text. Lazily created, so this
-        // is a no-op for sessions nobody has captured (the common browser case).
-        managed.captureRenderer?.write(data);
-        // DEC synchronized output supplies the exact safe redraw boundary. Flush
-        // when DECRST 2026 arrives instead of waiting for the idle fallback, while
-        // unsynchronized output keeps the existing anti-flicker window unchanged.
-        if (didEndSynchronizedOutput || managed.outputBatch.length >= OUTPUT_BATCH_FLUSH_BYTES) {
-            if (managed.outputBatchTimer !== null) {
-                clearTimeout(managed.outputBatchTimer);
-                managed.outputBatchTimer = null;
-            }
-            this.flushOutput(managed);
-            return;
-        }
-        // Without a synchronized-output boundary, reset the coalescing window on
-        // every chunk so the flush lands OUTPUT_BATCH_WINDOW_MS after the LAST
-        // chunk of a burst, not a fixed window after the first. A full-screen TUI
-        // redraw of a large session emits across more than the window (node-pty
-        // delivers it as many 1024-byte data events over successive event-loop
-        // turns); a one-shot window flushed mid-redraw and split the frame across
-        // multiple WebSocket messages. Over a bandwidth-limited link each split
-        // arrives as its own atomic message and xterm paints it separately — the
-        // visible top-to-bottom crawl. A resetting window holds the whole burst until the
-        // PTY goes idle, then sends one message; the browser receives it atomically
-        // and xterm renders it in a single paint regardless of link bandwidth.
-        // Sustained high-throughput output never idles, so OUTPUT_BATCH_FLUSH_BYTES
-        // still gates the message rate there (unchanged).
-        if (managed.outputBatchTimer !== null) {
-            managed.outputBatchTimer.refresh();
-            return;
-        }
-        managed.outputBatchTimer = setTimeout(() => {
-            managed.outputBatchTimer = null;
-            this.flushOutput(managed);
-        }, OUTPUT_BATCH_WINDOW_MS);
-        managed.outputBatchTimer.unref?.();
-    }
-    // Accumulate ANSI-stripped PTY output for an automation shell run, keeping
-    // the tail within the log cap so a long command's final output survives.
-    appendAutomationLog(managed, data) {
-        const stripped = stripAnsi(data);
-        if (stripped.length === 0)
-            return;
-        const combined = managed.automationLog + stripped;
-        if (combined.length <= MAX_AUTOMATION_LOG_LENGTH) {
-            managed.automationLog = combined;
-            return;
-        }
-        const overflow = combined.length - MAX_AUTOMATION_LOG_LENGTH;
-        managed.automationLog = combined.slice(overflow);
-    }
-    flushOutput(managed) {
-        const batch = managed.outputBatch;
-        managed.outputBatch = "";
-        if (!batch)
-            return;
-        const bytes = Buffer.from(batch, "utf8");
-        if (bytes.byteLength <= MAX_OUTPUT_BYTES) {
-            this.broadcastBytes(managed, bytes);
-        }
-        else {
-            for (let offset = 0; offset < bytes.byteLength; offset += MAX_OUTPUT_BYTES) {
-                this.broadcastBytes(managed, bytes.subarray(offset, offset + MAX_OUTPUT_BYTES));
-            }
-        }
-        this.maybePauseAfterFlush(managed);
-    }
-    maybePauseAfterFlush(managed) {
-        if (managed.session.isPaused)
-            return;
-        for (const client of managed.clients) {
-            if (client.pending)
-                continue;
-            if (getBufferedAmount(client.ws) >= WS_OUTBOUND_PAUSE_HIGH_WATER_BYTES) {
-                managed.session.pause();
-                this.ensureDrainPoll(managed);
-                return;
-            }
-        }
-    }
-    ensureDrainPoll(managed) {
-        if (managed.drainPollTimer !== null)
-            return;
-        managed.drainPollTimer = setInterval(() => {
-            if (!managed.session.isPaused) {
-                this.stopDrainPoll(managed);
-                return;
-            }
-            let allLow = true;
-            for (const client of managed.clients) {
-                if (client.pending)
-                    continue;
-                if (getBufferedAmount(client.ws) > WS_OUTBOUND_RESUME_LOW_WATER_BYTES) {
-                    allLow = false;
-                    break;
-                }
-            }
-            if (allLow) {
-                managed.session.resume();
-                this.stopDrainPoll(managed);
-            }
-        }, WS_OUTBOUND_DRAIN_POLL_MS);
-        managed.drainPollTimer.unref?.();
-    }
-    stopDrainPoll(managed) {
-        if (managed.drainPollTimer === null)
-            return;
-        clearInterval(managed.drainPollTimer);
-        managed.drainPollTimer = null;
-    }
-    recomputeResize(managed) {
-        const session = managed.session;
-        if (session.isExited)
-            return;
-        let cols = Infinity;
-        let rows = Infinity;
-        let single = null;
-        let count = 0;
-        for (const client of managed.clients) {
-            count++;
-            single = client;
-            if (client.cols > 0 && client.cols < cols)
-                cols = client.cols;
-            if (client.rows > 0 && client.rows < rows)
-                rows = client.rows;
-        }
-        if (count === 0)
-            return;
-        if (!Number.isFinite(cols) || !Number.isFinite(rows))
-            return;
-        if (count === 1 && single?.pixelWidth !== undefined && single?.pixelHeight !== undefined) {
-            session.resize(cols, rows, single.pixelWidth, single.pixelHeight);
-        }
-        else {
-            session.resize(cols, rows);
-        }
-        // Keep the capture renderer's grid at the PTY's effective size so a
-        // capture-pane reflects the same line wrapping a viewer would see.
-        managed.captureRenderer?.resize(cols, rows);
-        // The PTY's effective size is the min across attached clients (tmux-style):
-        // a narrower peer constrains everyone. Broadcast it on change so each
-        // viewer can mask the dead area beyond its own (possibly wider) grid as
-        // inactive chrome. A lone viewer is never constrained (its effective size
-        // always equals its own), so it's left quiet except for one clear frame when
-        // a peer detaches and drops it back to solo — that erases the mask the
-        // leaving peer had imposed. A joiner entering an already-constrained
-        // session without changing the min is seeded in attach.
-        const sizeChanged = managed.ptySizeCols !== cols || managed.ptySizeRows !== rows;
-        managed.ptySizeCols = cols;
-        managed.ptySizeRows = rows;
-        if (count > 1) {
-            managed.ptySizeWasMultiViewer = true;
-            if (sizeChanged) {
-                this.broadcast(managed, { type: "pty-size", cols, rows });
-            }
-        }
-        else if (managed.ptySizeWasMultiViewer) {
-            managed.ptySizeWasMultiViewer = false;
-            this.broadcast(managed, { type: "pty-size", cols, rows });
-        }
+        return this.commandExecutor.execute(managed, command, options);
     }
     installSessionListeners(managed) {
         const session = managed.session;
-        session.on("output", (data) => this.onSessionOutput(managed, data));
-        session.on("title", (title) => this.broadcast(managed, { type: "title", title }));
+        session.on("output", (data) => this.outputCoordinator.onSessionOutput(managed, data));
+        session.on("title", (title) => this.outputTransport.broadcast(managed, { type: "title", title }));
         session.on("cwd", (cwd) => {
-            this.broadcast(managed, { type: "cwd", cwd });
-            managed.gitWatcher.stop();
-            managed.gitWatcher.start(cwd);
-            for (const client of managed.clients)
-                this.moveClientCoordinator(client, cwd);
-            if (!managed.automation)
-                this.hooks.onSessionEvent("cwd", cwd);
+            this.outputTransport.broadcast(managed, { type: "cwd", cwd });
+            this.gitEventBridge.handleCwdChange(managed, cwd);
         });
         session.on("foreground", (process) => {
             managed.hasForeground = process !== null;
             managed.foregroundName = process;
-            this.broadcast(managed, { type: "foreground", process });
+            this.outputTransport.broadcast(managed, { type: "foreground", process });
             this.hooks.onSessionActivity();
             if (!managed.automation && session.lastEmittedCwd) {
                 this.hooks.onSessionEvent("foreground", session.lastEmittedCwd);
@@ -1229,7 +459,7 @@ export class SessionManager {
             // lets each receiving tab suppress the notification when the session is
             // already viewed in another browser profile, and tells the SW's click
             // handler whether to open a fresh tab (orphaned) or not (avoid a duplicate).
-            this.broadcastToOwner(managed, {
+            this.clientHub.broadcastToOwner(managed, {
                 type: "notification",
                 sessionId: managed.id,
                 body,
@@ -1239,48 +469,16 @@ export class SessionManager {
                 this.hooks.onSessionEvent("notification", session.lastEmittedCwd);
             }
         });
-        session.on("git-dirty", () => {
-            const cwd = session.lastEmittedCwd;
-            if (cwd)
-                this.coordinatorForCwd(cwd).signal();
-            if (!managed.automation && cwd)
-                this.hooks.onSessionEvent("git-dirty", cwd);
-        });
+        this.gitEventBridge.installSessionListener(managed);
         session.on("exit", (code) => this.handleExit(managed, code));
         const automation = managed.automation;
         if (automation) {
             session.on("automation-exit", (exitCode) => this.hooks.onAutomationExit(automation.automationId, automation.runId, exitCode, managed.automationLog));
         }
-        managed.gitWatcher.on("git-dirty", () => {
-            const cwd = session.lastEmittedCwd;
-            if (cwd)
-                this.coordinatorForCwd(cwd).signal();
-        });
-        for (const refEvent of GIT_DIFF_WATCHER_EVENT_NAMES) {
-            if (refEvent === "git-dirty")
-                continue;
-            const eventName = refEvent;
-            managed.gitWatcher.on(eventName, () => {
-                if (!managed.automation && session.lastEmittedCwd) {
-                    this.hooks.onSessionEvent(eventName, session.lastEmittedCwd);
-                }
-            });
-        }
-        managed.gitWatcher.start(session.cwd);
-    }
-    moveClientCoordinator(client, cwd) {
-        const next = this.coordinatorForCwd(cwd);
-        if (client.coordinator === next)
-            return;
-        if (client.coordinator) {
-            client.coordinator.remove(client.ws);
-            this.releaseCoordinator(client.coordinator);
-        }
-        client.coordinator = next;
-        next.add(client.ws);
+        this.gitEventBridge.installWatcher(managed);
     }
     handleExit(managed, code) {
-        this.flushOutput(managed);
+        this.outputCoordinator.flushOutput(managed);
         for (const client of managed.clients) {
             this.hooks.onClientExit(client.ws, code);
             this.sendControl(client.ws, { type: "exit", code });
@@ -1298,11 +496,7 @@ export class SessionManager {
         this.hooks.onSessionActivity();
     }
     tearDown(managed) {
-        if (managed.graceTimer !== null) {
-            clearTimeout(managed.graceTimer);
-            managed.graceTimer = null;
-        }
-        managed.parkedAt = null;
+        this.lifecyclePolicy.cancelGrace(managed);
         managed.captureRenderer?.dispose();
         managed.captureRenderer = undefined;
         deletePasteImagesForSession(managed.id);
@@ -1310,22 +504,9 @@ export class SessionManager {
             clearTimeout(managed.outputBatchTimer);
             managed.outputBatchTimer = null;
         }
-        this.stopDrainPoll(managed);
-        managed.gitWatcher.dispose();
-        for (const client of managed.clients) {
-            if (client.pendingTimer !== null) {
-                clearTimeout(client.pendingTimer);
-                client.pendingTimer = null;
-            }
-            client.pendingControl = [];
-            client.pendingBytes = [];
-            if (client.coordinator) {
-                client.coordinator.remove(client.ws);
-                this.releaseCoordinator(client.coordinator);
-            }
-            this.wsToClient.delete(client.ws);
-        }
-        managed.clients.clear();
+        this.outputCoordinator.stopDrainPoll(managed);
+        this.gitEventBridge.dispose(managed);
+        this.clientHub.tearDown(managed);
         this.sessions.delete(managed.id);
         this.lastOutputAtByPid.delete(managed.session.pid);
         try {
@@ -1335,114 +516,18 @@ export class SessionManager {
             /* already torn down */
         }
     }
-    evictOldestDormant() {
-        let oldest = null;
-        let oldestKey = Infinity;
-        for (const managed of this.sessions.values()) {
-            if (managed.clients.size > 0)
-                continue;
-            // Pinned sessions are never silently evicted — they're explicitly held.
-            if (managed.pinned)
-                continue;
-            // Evict the parked session whose grace fires soonest (armed earliest); a
-            // parked session with no timer is a fresh spawn nobody attached yet —
-            // yield it only after all armed ones.
-            const key = managed.parkedAt ?? managed.createdAt;
-            if (key < oldestKey) {
-                oldestKey = key;
-                oldest = managed;
-            }
-        }
-        if (oldest)
-            this.tearDown(oldest);
-    }
-    startGrace(managed) {
-        this.cancelGrace(managed);
-        managed.parkedAt = Date.now();
-        // Pinned sessions park indefinitely — never reaped by the idle grace and
-        // never evicted at the cap. They live until an explicit kill or shell exit.
-        if (managed.pinned)
-            return;
-        const graceMs = this.getGraceMs();
-        // "Never reap": park the shell with no timer. It lingers until a viewer
-        // reattaches, it's killed from the switcher, the shell exits, or it's
-        // evicted at MAX_CONCURRENT_SESSIONS. parkedAt stays set so eviction
-        // ordering still treats it as dormant.
-        if (graceMs === null)
-            return;
-        managed.graceTimer = setTimeout(() => {
-            managed.graceTimer = null;
-            managed.parkedAt = null;
-            // Re-check on fire: reschedule while the shell is still doing something —
-            // output still arriving (running), or a foreground program still alive
-            // though quiet (alive-quiet) — so a closed tab never kills a running
-            // command mid-stream, even after it's gone quiet. The shell only dies on
-            // a real idle (ready: no recent output and no foreground program, no
-            // clients), the same "no activity" signal that turns the tab's favicon
-            // grey.
-            if (this.computeState(managed) !== "ready") {
-                this.startGrace(managed);
-                return;
-            }
-            this.tearDown(managed);
-            this.hooks.onSessionActivity();
-        }, graceMs);
-        managed.graceTimer.unref?.();
-    }
     // Re-arm every parked session's grace timer with the current grace value.
     // Called after a `PUT /api/config` grace change so it takes effect on shells
     // that are already dormant, not only the next detach: a finite value arms (or
     // resets) their timers, and `null` cancels them so they park indefinitely.
     rearmGrace() {
-        for (const managed of this.sessions.values()) {
-            if (managed.clients.size === 0 && !managed.session.isExited)
-                this.startGrace(managed);
-        }
-    }
-    cancelGrace(managed) {
-        if (managed.graceTimer !== null) {
-            clearTimeout(managed.graceTimer);
-            managed.graceTimer = null;
-        }
-        managed.parkedAt = null;
-    }
-    // The favicon-equivalent state, computed from the same signals the client's
-    // favicon uses (recent output → running; a foreground program but quiet →
-    // alive-quiet; idle → ready). Surfaced on the session list so the row icon
-    // colors match the tab the user is looking at.
-    computeState(managed) {
-        if (Date.now() - managed.lastOutputAt < SESSION_ACTIVITY_WINDOW_MS)
-            return "running";
-        return managed.hasForeground ? "alive-quiet" : "ready";
-    }
-    coordinatorForCwd(cwd) {
-        const key = path.resolve(cwd);
-        let coordinator = this.coordinatorsByCwd.get(key);
-        if (!coordinator) {
-            coordinator = new GitMetadataCoordinator(key, this.sendControl);
-            this.coordinatorsByCwd.set(key, coordinator);
-        }
-        return coordinator;
-    }
-    releaseCoordinator(coordinator) {
-        if (coordinator.isEmpty)
-            this.coordinatorsByCwd.delete(coordinator.cwd);
+        this.lifecyclePolicy.rearmGrace(this.sessions);
     }
-    // Push a freshly-detected PR to every tab in `cwd` after the
-    // /api/git/branches/pr endpoint recomputes it, so a remote state change one
-    // tab observed (a merge on GitHub) reaches siblings sharing the directory.
-    // Non-creating: a cwd with no subscribers has no coordinator, and allocating
-    // one here would orphan it (it never enters the attach/detach release path).
     broadcastGitBranchPr(cwd, pr) {
-        this.coordinatorsByCwd.get(path.resolve(cwd))?.broadcastPr(pr);
+        this.gitEventBridge.broadcastGitBranchPr(cwd, pr);
     }
-    // Whether any tab is currently subscribed to the per-cwd coordinator — i.e.
-    // there is a live audience for a PR lease refresh. Used to gate the
-    // gh-activity refresh so a `gh` invocation in a cwd nobody is viewing never
-    // triggers a pointless GitHub API call (mirrors broadcastGitBranchPr's
-    // non-creating philosophy).
     hasCoordinatorFor(cwd) {
-        return this.coordinatorsByCwd.has(path.resolve(cwd));
+        return this.gitEventBridge.hasCoordinatorFor(cwd);
     }
 }
 //# sourceMappingURL=session-manager.js.map