@sandropadin/tend 0.1.0

package/dist/index.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+// tend — status of AI coding agents across your tmux sessions.
+//
+//   tend                 list agents grouped by session (all sessions) once
+//   tend watch           live-updating grouped list
+//   tend pick            interactive picker — select an agent and jump to it
+//   tend jump <pane>     jump straight to a pane id (e.g. jump %3)
+//   tend --json          machine-readable output (once)
+//   tend --current       limit to the current session (default: all sessions)
+//   tend --debug <pane>  dump each region's extracted text, for rule tuning
+//
+// Flags: --interval <ms> (watch/pick refresh, default 800),
+//        --once-delay <ms> (fire-once activity sampling window, default 350).
+import { capturePane, listClients, listPanes, selfClientTty } from "./tmux.js";
+import { identifyAgent } from "./detect.js";
+import { extractRegion } from "./regions.js";
+import { manifestFor } from "./manifests.js";
+import { scan, scanOnce } from "./scan.js";
+import { runPicker } from "./pick.js";
+import { insideTmux, jumpToPane } from "./nav.js";
+import { CLEAR_SCREEN, dim, renderGrouped, renderJson, summaryLine, } from "./render.js";
+function parseArgs(argv) {
+    const opts = {
+        mode: "default",
+        json: false,
+        all: true, // scan every session by default (global view across all sessions)
+        once: false,
+        readonly: false,
+        interval: 800,
+        onceDelay: 350,
+        other: false,
+    };
+    const args = [...argv];
+    while (args.length) {
+        const a = args.shift();
+        switch (a) {
+            case "watch":
+            case "pick": // alias — watch is the selectable dashboard
+            case "select":
+                opts.mode = "watch";
+                break;
+            case "clients":
+                opts.mode = "clients";
+                break;
+            case "--once":
+            case "ls":
+                opts.once = true;
+                break;
+            case "--readonly":
+                opts.readonly = true;
+                break;
+            case "--to":
+                opts.targetClient = args.shift();
+                break;
+            case "--other":
+                opts.other = true;
+                break;
+            case "jump":
+                opts.mode = "jump";
+                opts.target = args.shift();
+                break;
+            case "--debug":
+                opts.mode = "debug";
+                opts.target = args.shift();
+                break;
+            case "--json":
+                opts.json = true;
+                break;
+            case "--current":
+            case "-s":
+                opts.all = false;
+                break;
+            case "--all":
+            case "-a":
+                opts.all = true;
+                break;
+            case "--interval":
+                opts.interval = Number(args.shift()) || opts.interval;
+                break;
+            case "--once-delay":
+                opts.onceDelay = Number(args.shift()) || opts.onceDelay;
+                break;
+            case "-h":
+            case "--help":
+                printHelp();
+                process.exit(0);
+            default:
+                process.stderr.write(`tend: unknown argument "${a}"\n`);
+                process.exit(2);
+        }
+    }
+    return opts;
+}
+function printHelp() {
+    process.stdout.write([
+        "tend — status of AI coding agents across your tmux sessions",
+        "",
+        "Usage:",
+        "  tend                 live, selectable dashboard — ↑/↓ move, enter jumps",
+        "                         (falls back to a one-off snapshot when piped)",
+        "  tend --once          print a grouped snapshot and exit",
+        "  tend jump <pane>     jump to a pane id (e.g. jump %3)",
+        "  tend clients         list attached tmux clients (terminal windows)",
+        "  tend --json          machine-readable snapshot",
+        "  tend --current       limit to the current session",
+        "  tend --readonly      dashboard without selection (display-only pane)",
+        "  tend --debug <pane>  dump extracted regions for a pane (rule tuning)",
+        "",
+        "Open jumps in another window (keep the dashboard put):",
+        "  In the dashboard, press `o` to cycle where Enter opens: this window →",
+        "  each other attached client → back. Or preset it:",
+        "  --to <tty>         open jumps in that client (see `tend clients`)",
+        "  --other            open jumps in the one other attached client",
+        "",
+        "Options:",
+        "  --interval <ms>    dashboard refresh interval (default 800)",
+        "  --once-delay <ms>  activity sampling window for --once (default 350)",
+        "",
+    ].join("\n"));
+}
+const scanOpts = (o) => ({ all: o.all });
+async function runOnce(opts) {
+    const statuses = await scanOnce(scanOpts(opts), opts.onceDelay);
+    if (opts.json) {
+        process.stdout.write(renderJson(statuses) + "\n");
+    }
+    else {
+        process.stdout.write(renderGrouped(statuses) + "\n\n" + summaryLine(statuses) + "\n");
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function runWatch(opts) {
+    let memory = new Map();
+    process.on("SIGINT", () => {
+        process.stdout.write("\x1b[?25h\n");
+        process.exit(0);
+    });
+    process.stdout.write("\x1b[?25l"); // hide cursor
+    let frame = 0;
+    for (;;) {
+        const result = await scan(scanOpts(opts), memory);
+        memory = result.memory;
+        const header = new Date().toLocaleTimeString();
+        process.stdout.write(CLEAR_SCREEN +
+            `tend · ${header}\n\n` +
+            renderGrouped(result.statuses, frame++) +
+            "\n\n" +
+            summaryLine(result.statuses) +
+            "\n" +
+            dim("Ctrl-C to exit") +
+            "\n");
+        await sleep(opts.interval);
+    }
+}
+// Resolve which client (window) a jump should open in, from --to / --other.
+// Returns a client tty, or null to use the current window. Exits with guidance
+// when --other is ambiguous.
+async function resolveTargetClient(opts) {
+    if (opts.targetClient)
+        return opts.targetClient;
+    if (!opts.other)
+        return null;
+    const clients = await listClients();
+    const self = insideTmux() ? await selfClientTty() : null;
+    const others = clients.filter((c) => c.tty !== self);
+    if (others.length === 1)
+        return others[0].tty;
+    if (others.length === 0) {
+        process.stderr.write("tend: --other found no other attached client.\n");
+        process.exit(1);
+    }
+    process.stderr.write("tend: --other is ambiguous — multiple other clients attached:\n" +
+        others.map((c) => `  ${c.tty}  (${c.session})`).join("\n") +
+        "\nPick one with --to <tty>.\n");
+    process.exit(1);
+}
+async function runClients() {
+    const clients = await listClients();
+    const self = insideTmux() ? await selfClientTty() : null;
+    if (clients.length === 0) {
+        process.stdout.write(dim("No tmux clients attached.\n"));
+        return;
+    }
+    for (const c of clients) {
+        const mark = c.tty === self ? dim(" (this window)") : "";
+        process.stdout.write(`${c.tty}  → ${c.session}${mark}\n`);
+    }
+}
+async function runJump(opts) {
+    const target = opts.target;
+    if (!target) {
+        process.stderr.write("tend jump requires a pane id, e.g. jump %3\n");
+        process.exit(2);
+    }
+    const wanted = target.startsWith("%") ? target : `%${target}`;
+    const panes = await listPanes({ all: true });
+    const pane = panes.find((p) => p.id === wanted);
+    if (!pane) {
+        process.stderr.write(`tend: pane "${target}" not found\n`);
+        process.exit(1);
+    }
+    const client = await resolveTargetClient(opts);
+    await jumpToPane(pane, client ? { client } : {});
+    const where = client ? `${client}` : `${pane.sessionName} (${pane.id})`;
+    process.stdout.write(dim(`→ ${where}\n`));
+}
+// Debug: show what each region extractor pulls from a pane so you can see why a
+// rule did or didn't match, then iterate on manifests.ts.
+async function runDebug(opts) {
+    const target = opts.target;
+    if (!target) {
+        process.stderr.write("tend --debug requires a pane id, e.g. --debug %3\n");
+        process.exit(2);
+    }
+    const wanted = target.startsWith("%") ? target : `%${target}`;
+    const panes = await listPanes({ all: true });
+    const pane = panes.find((p) => p.id === wanted);
+    if (!pane) {
+        process.stderr.write(`tend: pane "${target}" not found\n`);
+        process.exit(1);
+    }
+    const lines = await capturePane(pane.id);
+    const agent = identifyAgent(pane, lines.join("\n"));
+    process.stdout.write(`pane ${pane.id}  command=${pane.command}  agent=${agent ?? "(none)"}\n`);
+    const regions = [
+        "full",
+        "after_last_horizontal_rule",
+        "prompt_box_body",
+        { bottom_non_empty_lines: 6 },
+    ];
+    for (const region of regions) {
+        const label = typeof region === "object" ? "bottom_non_empty_lines(6)" : region;
+        process.stdout.write(`\n\x1b[1m── region: ${label} ──\x1b[0m\n`);
+        process.stdout.write(extractRegion(lines, region) + "\n");
+    }
+    if (agent) {
+        const manifest = manifestFor(agent);
+        process.stdout.write(`\n\x1b[1m── manifest rules for ${agent} ──\x1b[0m\n`);
+        for (const rule of manifest?.rules ?? []) {
+            const regionText = extractRegion(lines, rule.region);
+            const matched = ruleWouldMatch(rule, regionText);
+            const mark = matched ? "\x1b[32m✓\x1b[0m" : "\x1b[90m·\x1b[0m";
+            process.stdout.write(`  ${mark} [${rule.priority}] ${rule.id} → ${rule.state}\n`);
+        }
+    }
+}
+// Small duplicate of the engine's predicate, kept here so --debug has no need to
+// export internals. If you change ruleMatches in detect.ts, mirror it here.
+function ruleWouldMatch(rule, regionText) {
+    const hay = regionText.toLowerCase();
+    if (rule.contains && !rule.contains.every((s) => hay.includes(s.toLowerCase())))
+        return false;
+    if (rule.anyContains && !rule.anyContains.some((s) => hay.includes(s.toLowerCase())))
+        return false;
+    if (rule.not && rule.not.some((s) => hay.includes(s.toLowerCase())))
+        return false;
+    if (rule.regex && !new RegExp(rule.regex, "im").test(regionText))
+        return false;
+    return true;
+}
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    switch (opts.mode) {
+        case "default":
+        case "watch": {
+            // A snapshot is forced by --json / --once, and is also the right default
+            // when output is piped (so `tend | grep` and `tend > file` behave).
+            if (opts.json || opts.once) {
+                await runOnce(opts);
+                break;
+            }
+            const interactiveTty = process.stdin.isTTY === true && process.stdout.isTTY === true;
+            if (interactiveTty && !opts.readonly) {
+                // Optional preset target window from --to/--other; `o` cycles it live.
+                const initialTarget = opts.targetClient ?? (opts.other ? await resolveTargetClient(opts) : null);
+                await runPicker(scanOpts(opts), opts.interval, initialTarget ?? undefined);
+            }
+            else if (opts.readonly) {
+                await runWatch(opts); // display-only repaint (explicit)
+            }
+            else if (opts.mode === "watch") {
+                await runWatch(opts); // `tend watch` piped → repaint loop (explicit)
+            }
+            else {
+                await runOnce(opts); // bare `tend` piped → one-off snapshot
+            }
+            break;
+        }
+        case "jump":
+            await runJump(opts);
+            break;
+        case "clients":
+            await runClients();
+            break;
+        case "debug":
+            await runDebug(opts);
+            break;
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`tend: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/manifests.js

@@ -0,0 +1,133 @@
+// Agent manifests — the declarative rule sets. This is the file you tune.
+//
+// Detection philosophy: read what's already on the screen rather than demand
+// agents speak a protocol. Each rule matches a region of the
+// captured terminal; the highest-priority match wins. "blocked" is deliberately
+// strict (only fires on a positive match of a known approval UI) so you don't
+// get false "needs you" alarms; everything else falls back to idle.
+//
+// These patterns are a starting point. Run `tend --debug <pane>` against a
+// live pane to see exactly what text each region extracts, then adjust.
+const claude = {
+    agent: "claude",
+    match: ["claude"],
+    // Claude Code renames its process comm to its version (e.g. "2.1.200"), so the
+    // literal name never appears — this catches it regardless of screen state.
+    commandPattern: "^\\d+\\.\\d+\\.\\d+",
+    // Persistent on-screen chrome, for the rare case comm is generic (`node`).
+    // These are strings Claude keeps visible in SOME state during a live session —
+    // the mode footer, the shortcuts hint, the interrupt hint, the permission
+    // prompt — NOT the welcome banner, which scrolls away mid-conversation.
+    signature: [
+        "shift+tab to cycle", // mode footer (auto/plan mode)
+        "? for shortcuts", // default footer
+        "esc to interrupt", // working footer
+        "for agents", // "← for agents" footer
+        "Do you want to proceed?", // permission prompt
+        "No, and tell Claude", // permission prompt option
+        "Claude Code", // welcome banner (fresh session)
+    ],
+    rules: [
+        // Scrollback / transcript / picker screens don't reflect live state — hold.
+        {
+            id: "transcript_or_picker",
+            state: "unknown",
+            priority: 950,
+            region: "full",
+            anyContains: ["(END)", "Select a model", "Choose a model", "─ Transcript ─"],
+            skipStateUpdate: true,
+        },
+        // Blocked = a *live* permission/approval prompt: the selection cursor (❯)
+        // sits on a numbered choice while Claude waits for you. Keying on the live
+        // cursor (not the question text) is deliberate — the cursor vanishes the
+        // instant you answer, so a prompt lingering in the scroll buffer no longer
+        // counts as blocked. `not` guards against a stale answered prompt whose text
+        // is still on screen but whose cursor has moved on.
+        {
+            id: "selection_prompt",
+            state: "blocked",
+            priority: 900,
+            region: { bottom_non_empty_lines: 15 },
+            regex: "^\\s*❯\\s+\\d+\\.\\s", // e.g. "❯ 1. Yes"
+            not: ["esc to interrupt"], // if it's generating, it isn't waiting on you
+        },
+        // Actively generating — Claude shows an interrupt hint while working.
+        {
+            id: "working_interrupt_hint",
+            state: "working",
+            priority: 700,
+            region: { bottom_non_empty_lines: 8 },
+            anyContains: ["esc to interrupt", "(esc to interrupt)"],
+        },
+        // Empty prompt box with the caret and no menu chrome = idle, awaiting input.
+        {
+            id: "idle_prompt",
+            state: "idle",
+            priority: 100,
+            region: "prompt_box_body",
+            regex: "^\\s*[>❯]",
+            not: ["esc to interrupt", "1. Yes", "Do you want"],
+        },
+    ],
+};
+const codex = {
+    agent: "codex",
+    match: ["codex"],
+    signature: ["OpenAI Codex", "Codex CLI", "codex>"],
+    rules: [
+        // Blocked = a *live* prompt Codex is waiting on — a command-approval dialog
+        // or a selectable question (request_user_input). Both render as a numbered
+        // list with the live selection cursor `›` (U+203A, Codex's analogue of
+        // Claude's `❯`) on one choice. Key on that cursor row, NOT footer text:
+        // Codex keeps "esc to interrupt" in the prompt footer even while blocked
+        // (e.g. "enter to submit answer | esc to interrupt"), so the interrupt hint
+        // can't distinguish blocked from working — only the live cursor can. Like
+        // Claude's ❯ cursor, it vanishes the instant you answer, so a prompt left in
+        // scrollback stops counting as blocked.
+        {
+            id: "selection_prompt",
+            state: "blocked",
+            priority: 900,
+            region: { bottom_non_empty_lines: 20 },
+            regex: "^\\s*›\\s+\\d+\\.\\s", // e.g. "› 1. Yes"
+        },
+        // Belt-and-suspenders: explicit approval/question wording, for a prompt
+        // whose numbered cursor row isn't in the captured window (long command
+        // preview pushing it out of view).
+        {
+            id: "approval_prompt",
+            state: "blocked",
+            priority: 890,
+            region: { bottom_non_empty_lines: 20 },
+            anyContains: [
+                "Allow command",
+                "wants to run",
+                "Do you want to apply",
+                "enter to submit answer", // selectable-question footer
+            ],
+        },
+        {
+            id: "working_interrupt_hint",
+            state: "working",
+            priority: 700,
+            region: { bottom_non_empty_lines: 8 },
+            anyContains: ["Esc to interrupt", "esc to interrupt", "Working", "Thinking"],
+        },
+        {
+            id: "idle_prompt",
+            state: "idle",
+            priority: 100,
+            region: "prompt_box_body",
+            regex: "^\\s*[>›❯▌]", // Codex's input marker is `›` (U+203A)
+            not: ["Esc to interrupt", "Allow command", "enter to submit answer"],
+        },
+    ],
+};
+// Generic fallback for any other terminal agent: no screen rules, so its state
+// comes purely from PTY activity (content changed since last tick = working).
+// Add signatures/rules here as you bring more agents into the fold.
+export const MANIFESTS = [claude, codex];
+// Ordered agent-name → manifest lookup used by the detector.
+export function manifestFor(agent) {
+    return MANIFESTS.find((m) => m.agent === agent);
+}

package/dist/nav.js

@@ -0,0 +1,33 @@
+// Jump the terminal to an agent's pane. Inside tmux we switch the attached
+// client instantly; outside tmux we pre-select the pane on the server and then
+// hand the terminal to `tmux attach`.
+import { spawn } from "node:child_process";
+import { preselectPane, switchClientToPane, switchToPane } from "./tmux.js";
+export { listClients, selfClientTty } from "./tmux.js";
+export function insideTmux() {
+    return Boolean(process.env.TMUX);
+}
+// Jump the terminal to an agent's pane.
+//  - opts.client set  → move that other client to the pane (dashboard stays).
+//  - inside tmux      → switch our own client and resolve immediately.
+//  - outside tmux     → pre-select the pane, then `tmux attach` (blocks until
+//                       the user detaches).
+export async function jumpToPane(pane, opts = {}) {
+    const { sessionName, id: paneId } = pane;
+    if (opts.client) {
+        await switchClientToPane(opts.client, sessionName, paneId);
+        return;
+    }
+    if (insideTmux()) {
+        await switchToPane(sessionName, paneId);
+        return;
+    }
+    await preselectPane(paneId);
+    await new Promise((resolve, reject) => {
+        const child = spawn("tmux", ["attach-session", "-t", sessionName], {
+            stdio: "inherit",
+        });
+        child.on("close", () => resolve());
+        child.on("error", reject);
+    });
+}

package/dist/pick.js

@@ -0,0 +1,214 @@
+// Interactive live dashboard: a grouped list of agents across all tmux sessions
+// that re-scans on an interval AND lets you act on it. Arrow keys (or j/k) move
+// the cursor; Enter jumps to that pane; o cycles where the jump opens; r
+// refreshes; q / Esc / Ctrl-C quits.
+//
+// Jump target: by default Enter opens the agent in *this* window (the one the
+// dashboard runs in), keeping the dashboard alive in its own pane. Press `o` to
+// cycle the target to another attached client (another terminal window), so you
+// can watch here and open blocked agents over there — the dashboard never moves.
+// (When targeting this window from a plain terminal — not inside tmux — jumping
+// means `tmux attach`, which takes over the terminal, so there we exit.)
+import { scan } from "./scan.js";
+import { insideTmux, jumpToPane, listClients, selfClientTty } from "./nav.js";
+import { agentRow, bold, dim, groupBySession, summaryLine } from "./render.js";
+const ALT_ON = "\x1b[?1049h";
+const ALT_OFF = "\x1b[?1049l";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const CURSOR_HOME = "\x1b[H"; // move to top-left without clearing (no flicker)
+const CLEAR_EOL = "\x1b[K"; // erase from cursor to end of *line*
+const CLEAR_BELOW = "\x1b[J"; // erase from cursor to end of screen
+const ANIM_MS = 90; // spinner tick — faster than the scan interval
+const shortTty = (tty) => tty.replace(/^\/dev\//, "");
+export async function runPicker(opts, intervalMs, initialTarget) {
+    let statuses = [];
+    let memory = new Map();
+    let cursorPaneId = null; // track selection by id across rescans
+    let clients = [];
+    let targetTty = initialTarget ?? null; // null = this window
+    let selfTty = null;
+    let done = false;
+    let statusMsg = ""; // transient line (e.g. "sent … to …")
+    let frame = 0; // spinner animation frame
+    let timer;
+    let animTimer;
+    const out = process.stdout;
+    const input = process.stdin;
+    // Flattened, display-ordered list of selectable agent rows (grouped order).
+    const selectable = () => groupBySession(statuses).flatMap((g) => g.agents);
+    const otherClients = () => clients.filter((c) => c.tty !== selfTty);
+    const currentIndex = () => {
+        const list = selectable();
+        if (list.length === 0)
+            return -1;
+        const i = list.findIndex((s) => s.pane.id === cursorPaneId);
+        return i >= 0 ? i : 0;
+    };
+    const moveCursor = (delta) => {
+        const list = selectable();
+        if (list.length === 0)
+            return;
+        const next = Math.min(list.length - 1, Math.max(0, currentIndex() + delta));
+        cursorPaneId = list[next].pane.id;
+        statusMsg = ""; // clear the note once you start moving again
+    };
+    // Cycle the jump target: this window → each other client → back.
+    const cycleTarget = () => {
+        const others = otherClients();
+        if (others.length === 0) {
+            // Nothing to target — tell the user how to get a second window instead of
+            // silently doing nothing.
+            statusMsg =
+                clients.length <= 1
+                    ? "no other tmux client — run `tmux attach` in another terminal window"
+                    : "no other client detected (couldn't tell this window apart)";
+            render();
+            return;
+        }
+        const cycle = [null, ...others.map((c) => c.tty)];
+        let idx = cycle.indexOf(targetTty);
+        if (idx < 0)
+            idx = 0;
+        targetTty = cycle[(idx + 1) % cycle.length] ?? null;
+        statusMsg = "";
+        render();
+    };
+    const targetLabel = () => {
+        if (!targetTty)
+            return "this window";
+        const c = clients.find((x) => x.tty === targetTty);
+        return shortTty(targetTty) + (c ? ` · ${c.session}` : "");
+    };
+    const render = () => {
+        const groups = groupBySession(statuses);
+        const selectedId = selectable()[currentIndex()]?.pane.id ?? null;
+        const others = otherClients().length;
+        const lines = [];
+        lines.push(bold("tend") + dim("  ↑/↓ move · enter jump · o target · r refresh · q quit"));
+        // Show where Enter opens, plus how many other windows are available to target.
+        const windowsNote = others > 0 ? `  (${others} other window${others > 1 ? "s" : ""})` : "";
+        lines.push(dim(`opens in: ${targetLabel()}${windowsNote}`) + (statusMsg ? dim(`   ${statusMsg}`) : ""));
+        if (groups.length === 0) {
+            lines.push(dim("No AI agents detected in any tmux session."));
+        }
+        else {
+            for (const { session, agents } of groups) {
+                const blocked = agents.filter((a) => a.state === "blocked").length;
+                const suffix = blocked ? `  \x1b[31m· ${blocked} blocked\x1b[0m` : "";
+                lines.push(bold(`▸ ${session}`) + dim(`  (${agents.length})`) + suffix);
+                for (const a of agents) {
+                    lines.push(agentRow(a, a.pane.id === selectedId, frame));
+                }
+                lines.push("");
+            }
+        }
+        lines.push(summaryLine(statuses));
+        // Home + overwrite, erasing each line's tail (CLEAR_EOL) so a line that got
+        // shorter doesn't leave ghost text (e.g. a stale "· 1 blocked" suffix), plus
+        // CLEAR_BELOW for when this frame has fewer lines. No full-screen wipe, so
+        // the ~90ms spinner repaints stay flicker-free.
+        out.write(CURSOR_HOME + lines.map((l) => l + CLEAR_EOL).join("\n") + "\n" + CLEAR_BELOW);
+    };
+    const refresh = async () => {
+        const result = await scan(opts, memory);
+        memory = result.memory;
+        statuses = result.statuses;
+        clients = await listClients();
+        // If our chosen target client went away, fall back to this window.
+        if (targetTty && !clients.some((c) => c.tty === targetTty))
+            targetTty = null;
+        if (cursorPaneId === null)
+            cursorPaneId = selectable()[0]?.pane.id ?? null;
+        if (!done)
+            render();
+    };
+    const cleanup = () => {
+        if (timer)
+            clearInterval(timer);
+        if (animTimer)
+            clearInterval(animTimer);
+        input.setRawMode?.(false);
+        input.pause();
+        input.removeListener("data", onKey);
+        out.write(SHOW_CURSOR + ALT_OFF);
+    };
+    const jump = async () => {
+        const target = selectable()[currentIndex()];
+        if (!target)
+            return;
+        // Targeting another client: move that window, keep the dashboard put.
+        if (targetTty) {
+            try {
+                await jumpToPane(target.pane, { client: targetTty });
+                statusMsg = `→ sent ${target.agent} (${target.pane.id}) to ${shortTty(targetTty)}`;
+            }
+            catch {
+                statusMsg = `⚠ ${shortTty(targetTty)} unavailable`;
+            }
+            render();
+            return;
+        }
+        // Targeting this window, inside tmux: switch our client but keep running.
+        if (insideTmux()) {
+            await jumpToPane(target.pane);
+            statusMsg = `→ jumped to ${target.agent} in ${target.pane.sessionName} (${target.pane.id})`;
+            render();
+            return;
+        }
+        // This window, outside tmux: attach takes over the terminal → tear down.
+        done = true;
+        cleanup();
+        await jumpToPane(target.pane);
+        process.exit(0);
+    };
+    function onKey(buf) {
+        const key = buf.toString("utf8");
+        if (key === "\x03" || key === "q" || key === "\x1b") {
+            done = true;
+            cleanup();
+            process.exit(0);
+        }
+        else if (key === "\r" || key === "\n") {
+            void jump();
+        }
+        else if (key === "\x1b[A" || key === "k") {
+            moveCursor(-1);
+            render();
+        }
+        else if (key === "\x1b[B" || key === "j") {
+            moveCursor(1);
+            render();
+        }
+        else if (key === "o" || key === "\t") {
+            cycleTarget();
+        }
+        else if (key === "r") {
+            void refresh();
+        }
+    }
+    // Setup terminal. We only have a "self" client to exclude when we're actually
+    // running inside a tmux client; from a plain terminal every attached client is
+    // a legitimate target (and tmux would otherwise report one of them as "self").
+    selfTty = insideTmux() ? await selfClientTty() : null;
+    out.write(ALT_ON + HIDE_CURSOR);
+    input.setRawMode?.(true);
+    input.resume();
+    input.setEncoding?.("utf8");
+    input.on("data", onKey);
+    process.on("SIGINT", () => {
+        done = true;
+        cleanup();
+        process.exit(0);
+    });
+    await refresh();
+    timer = setInterval(() => void refresh(), intervalMs);
+    // Advance the spinner only while something is working, so an all-idle board
+    // stays quiet (no needless repaints).
+    animTimer = setInterval(() => {
+        if (done || !statuses.some((s) => s.state === "working"))
+            return;
+        frame++;
+        render();
+    }, ANIM_MS);
+}