nebula-notebook 0.2.0 → 0.2.1

package/node-server/dist/scheduler/allocation-service.d.ts

@@ -29,7 +29,27 @@ declare class AllocationService {
     private allocations;
     private pollTimer;
     private enabled;
+    private lastPollAt;
+    private lostListenerRegistered;
     init(scheduler: Scheduler, ctx: LaunchContext): void;
+    /** Poll immediately (debounced to 2s so error bursts don't hammer squeue). */
+    pollNow(): void;
+    private stateFile;
+    /**
+     * Allocations survive head-server restarts: persisted on every change,
+     * reloaded on init. A reloaded 'active' allocation is demoted to 'running'
+     * with its serverId cleared — the registry is empty after a restart, and
+     * the compute node's client-server re-registers itself (heartbeat -> 404
+     * -> re-register with its allocation token) within ~30s, at which point
+     * poll() re-correlates and promotes it back to 'active'. The SLURM job
+     * itself is re-checked by jobId on the next poll, so jobs that died while
+     * we were down are marked ended/failed instead of lingering.
+     */
+    private persist;
+    private loadPersisted;
+    /** Pick the poll cadence from what we're actually waiting for. */
+    private nextPollDelay;
+    private scheduleNextPoll;
     isEnabled(): boolean;
     getScheduler(): Scheduler | null;
     list(): Allocation[];

package/node-server/dist/scheduler/allocation-service.js

@@ -49,7 +49,13 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const job_template_1 = require("./job-template");
 const server_registry_1 = require("../cluster/server-registry");
-const POLL_INTERVAL_MS = 5_000;
+// Adaptive polling: fast only while a transition is imminent (job climbing
+// the queue / server booting), slow once allocations are correlated and
+// steady (we're only watching for job end), slowest when idle. Each squeue
+// poll is a real scheduler hit on a shared login node — don't burn them.
+const POLL_FAST_MS = 5_000; // pending/running/uncorrelated allocations
+const POLL_STEADY_MS = 30_000; // all tracked allocations active + correlated
+const POLL_IDLE_MS = 60_000; // nothing non-terminal to watch
 const TERMINAL = ['ended', 'failed', 'cancelled'];
 class AllocationService {
     scheduler = null;
@@ -57,16 +63,116 @@ class AllocationService {
     allocations = new Map();
     pollTimer = null;
     enabled = false;
+    lastPollAt = 0;
+    lostListenerRegistered = false;
     init(scheduler, ctx) {
         this.scheduler = scheduler;
         this.ctx = ctx;
         this.enabled = true;
         fs.mkdirSync(ctx.stateDir, { recursive: true });
+        this.loadPersisted();
+        this.scheduleNextPoll(POLL_FAST_MS);
+        // React instantly when the cluster layer loses contact with a server
+        // that belongs to one of our allocations (kernel WS dropped, proxy
+        // request refused, heartbeat timeout) — verify against the scheduler
+        // NOW instead of waiting out the steady 30s cadence.
+        if (!this.lostListenerRegistered) {
+            this.lostListenerRegistered = true;
+            server_registry_1.serverRegistry.onServerLost((server) => {
+                const tracked = [...this.allocations.values()].some((a) => !TERMINAL.includes(a.state) &&
+                    (a.serverId === server.id || (server.allocationToken && a.token === server.allocationToken)));
+                if (tracked) {
+                    console.log(`[Scheduler] Lost contact with ${server.id} — checking its allocation now`);
+                    this.pollNow();
+                }
+            });
+        }
+    }
+    /** Poll immediately (debounced to 2s so error bursts don't hammer squeue). */
+    pollNow() {
+        if (!this.enabled)
+            return;
+        if (Date.now() - this.lastPollAt < 2_000)
+            return;
+        this.scheduleNextPoll(0);
+    }
+    stateFile() {
+        return this.ctx ? path.join(this.ctx.stateDir, 'allocations.json') : null;
+    }
+    /**
+     * Allocations survive head-server restarts: persisted on every change,
+     * reloaded on init. A reloaded 'active' allocation is demoted to 'running'
+     * with its serverId cleared — the registry is empty after a restart, and
+     * the compute node's client-server re-registers itself (heartbeat -> 404
+     * -> re-register with its allocation token) within ~30s, at which point
+     * poll() re-correlates and promotes it back to 'active'. The SLURM job
+     * itself is re-checked by jobId on the next poll, so jobs that died while
+     * we were down are marked ended/failed instead of lingering.
+     */
+    persist() {
+        const file = this.stateFile();
+        if (!file)
+            return;
+        try {
+            const all = [...this.allocations.values()];
+            // Cap history so the file can't grow unboundedly: all live ones,
+            // plus the 20 most recent terminal ones for the UI's history list.
+            const live = all.filter((a) => !TERMINAL.includes(a.state));
+            const done = all.filter((a) => TERMINAL.includes(a.state))
+                .sort((a, b) => b.createdAt - a.createdAt).slice(0, 20);
+            const tmp = `${file}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify([...live, ...done]));
+            fs.renameSync(tmp, file);
+        }
+        catch (err) {
+            console.error('[Scheduler] failed to persist allocations:', err);
+        }
+    }
+    loadPersisted() {
+        const file = this.stateFile();
+        if (!file || !fs.existsSync(file))
+            return;
+        try {
+            const list = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            let revived = 0;
+            for (const alloc of list) {
+                if (!alloc?.id || this.allocations.has(alloc.id))
+                    continue;
+                if (!TERMINAL.includes(alloc.state)) {
+                    if (alloc.state === 'active')
+                        alloc.state = 'running';
+                    alloc.serverId = undefined; // fresh registry — re-correlate via token
+                    revived++;
+                }
+                this.allocations.set(alloc.id, alloc);
+            }
+            if (revived)
+                console.log(`[Scheduler] Recovered ${revived} live allocation(s) from disk`);
+        }
+        catch (err) {
+            console.error('[Scheduler] failed to load persisted allocations:', err);
+        }
+    }
+    /** Pick the poll cadence from what we're actually waiting for. */
+    nextPollDelay() {
+        const live = [...this.allocations.values()].filter((a) => !TERMINAL.includes(a.state));
+        if (live.length === 0)
+            return POLL_IDLE_MS;
+        return live.some((a) => a.state !== 'active' || !a.serverId) ? POLL_FAST_MS : POLL_STEADY_MS;
+    }
+    scheduleNextPoll(delay) {
         if (this.pollTimer)
-            clearInterval(this.pollTimer);
-        this.pollTimer = setInterval(() => {
-            this.poll().catch((err) => console.error('[Scheduler] poll error:', err));
-        }, POLL_INTERVAL_MS);
+            clearTimeout(this.pollTimer);
+        this.pollTimer = setTimeout(async () => {
+            try {
+                await this.poll();
+            }
+            catch (err) {
+                console.error('[Scheduler] poll error:', err);
+            }
+            if (this.enabled)
+                this.scheduleNextPoll(this.nextPollDelay());
+        }, delay);
     }
     isEnabled() {
         return this.enabled;
@@ -92,9 +198,11 @@ class AllocationService {
         const { jobId } = await this.scheduler.submit(scriptPath);
         alloc.jobId = jobId;
         this.allocations.set(id, alloc);
+        this.persist();
         console.log(`[Scheduler] Allocation ${id} submitted as job ${jobId} (${spec.partition}${spec.qos ? '/' + spec.qos : ''})`);
-        // Kick an immediate poll so a fast-starting job doesn't sit at "pending".
-        void this.poll().catch(() => { });
+        // Poll now and drop back to the fast cadence — a create can land while
+        // the poller is in a slow idle/steady wait.
+        this.scheduleNextPoll(0);
         return alloc;
     }
     async cancel(id) {
@@ -112,11 +220,14 @@ class AllocationService {
         if (alloc.serverId)
             server_registry_1.serverRegistry.unregister(alloc.serverId);
         alloc.state = 'cancelled';
+        this.persist();
         return true;
     }
     async poll() {
         if (!this.scheduler)
             return;
+        this.lastPollAt = Date.now();
+        let dirty = false;
         for (const alloc of this.allocations.values()) {
             if (TERMINAL.includes(alloc.state))
                 continue;
@@ -127,6 +238,7 @@ class AllocationService {
                     alloc.serverId = server.id;
                     alloc.state = 'active';
                     alloc.nodes = [server.host];
+                    dirty = true;
                     if (!alloc.walltimeEndsAt) {
                         alloc.walltimeEndsAt = Date.now() + alloc.spec.walltimeMinutes * 60_000;
                     }
@@ -145,6 +257,7 @@ class AllocationService {
             }
             if (status.state === 'running' && alloc.state === 'pending') {
                 alloc.state = 'running';
+                dirty = true;
                 alloc.nodes = status.nodes.length ? status.nodes : alloc.nodes;
                 if (!alloc.walltimeEndsAt) {
                     alloc.walltimeEndsAt = Date.now() + alloc.spec.walltimeMinutes * 60_000;
@@ -153,15 +266,18 @@ class AllocationService {
             else if (['completed', 'cancelled', 'failed'].includes(status.state)) {
                 alloc.state = status.state === 'failed' ? 'failed' : status.state === 'cancelled' ? 'cancelled' : 'ended';
                 alloc.reason = status.reason;
+                dirty = true;
                 if (alloc.serverId)
                     server_registry_1.serverRegistry.unregister(alloc.serverId);
                 console.log(`[Scheduler] Allocation ${alloc.id} ${alloc.state} (job ${alloc.jobId})`);
             }
         }
+        if (dirty)
+            this.persist();
     }
     shutdown() {
         if (this.pollTimer) {
-            clearInterval(this.pollTimer);
+            clearTimeout(this.pollTimer);
             this.pollTimer = null;
         }
     }

package/node-server/dist/scheduler/mock-scheduler.js

@@ -32,10 +32,14 @@ function partitions() {
     return [
         p('cpu', 512, 236, '1-00:00:00', { pending: 5, running: 44 }),
         p('cpu-long', 256, 14, '7-00:00:00', { pending: 71, running: 58 }),
-        p('gpu', 128, 46, '1-00:00:00', { pending: 3, running: 12 }, { type: 'nvidia_l40s', total: 16, idle: 7 }),
-        p('gpu-a100', 96, 22, '1-00:00:00', { pending: 6, running: 9 }, { type: 'nvidia_a100_80gb', total: 8, idle: 3 }),
+        // Heterogeneous GPU queue — two card models, shown as separate rows.
+        p('gpu', 128, 46, '1-00:00:00', { pending: 3, running: 12 }, [
+            { type: 'nvidia_l40s', total: 16, idle: 7 },
+            { type: 'nvidia_rtx_6000', total: 8, idle: 2 },
+        ]),
+        p('gpu-a100', 96, 22, '1-00:00:00', { pending: 6, running: 9 }, [{ type: 'nvidia_a100_80gb', total: 8, idle: 3 }]),
         p('bigmem', 192, 104, '2-00:00:00', { pending: 1, running: 6 }),
-        p('lab', 64, 28, '30-00:00:00', { pending: 0, running: 3 }, { type: 'nvidia_h100_80gb', total: 8, idle: 5 }),
+        p('lab', 64, 28, '30-00:00:00', { pending: 0, running: 3 }, [{ type: 'nvidia_h100_80gb', total: 8, idle: 5 }]),
     ];
 }
 function qoses() {

package/node-server/dist/scheduler/slurm-scheduler.js

@@ -50,6 +50,10 @@ async function expandNodes(nodelist) {
     const nl = (nodelist || '').trim();
     if (!nl || nl === '(null)' || nl === 'None' || nl === 'n/a')
         return [];
+    // Plain single hostname (no ranges/lists) — the common case for 1-node
+    // allocations. Don't shell out to scontrol just to echo it back.
+    if (!/[\[\],]/.test(nl))
+        return [nl];
     try {
         const { stdout } = await run('scontrol', ['show', 'hostnames', nl], 5_000);
         return stdout.split('\n').map((s) => s.trim()).filter(Boolean);
@@ -65,7 +69,9 @@ class SlurmScheduler {
     // Short-TTL caches + in-flight de-duplication so the dashboard's 15s poll, the
     // allocation modal, and manual refresh don't each re-run the (potentially slow)
     // sinfo/scontrol/squeue/sacctmgr queries against the scheduler.
-    static LOAD_TTL_MS = 10_000;
+    // 20s: deliberately ABOVE the clients' 15s poll so steady-state polling
+    // alternates cache hit/miss instead of missing every time (10s never hit).
+    static LOAD_TTL_MS = 20_000;
     static ASSOC_TTL_MS = 60_000;
     loadCache = null;
     loadInflight = null;
@@ -205,6 +211,7 @@ class SlurmScheduler {
         // allocated (AllocTRES) `gres/gpu`, so we can report *idle* (available) GPUs
         // rather than a per-node count. Generic — no site-specific node/gres names.
         if (nodeRes.status === 'fulfilled') {
+            // Aggregate per (partition, GPU model) — heterogeneous queues mix cards.
             const agg = new Map();
             for (const line of nodeRes.value.stdout.split('\n')) {
                 if (!line.trim())
@@ -219,18 +226,24 @@ class SlurmScheduler {
                 const allocGpu = toInt((scontrolField(line, 'AllocTRES')?.match(/gres\/gpu=(\d+)/) || [])[1]);
                 const type = (scontrolField(line, 'Gres')?.match(/gpu:([^:(]+)/) || [])[1] || 'gpu';
                 for (const part of parts.split(',')) {
-                    const e = agg.get(part) || { type, total: 0, used: 0 };
+                    const byType = agg.get(part) ?? new Map();
+                    const e = byType.get(type) || { total: 0, used: 0 };
                     e.total += cfgGpu;
                     e.used += allocGpu;
-                    if (!e.type || e.type === 'gpu')
-                        e.type = type;
-                    agg.set(part, e);
+                    byType.set(type, e);
+                    agg.set(part, byType);
                 }
             }
-            for (const [part, g] of agg) {
+            for (const [part, byType] of agg) {
                 const p = partitions.get(part);
-                if (p && g.total > 0)
-                    p.gpus = { type: g.type, total: g.total, idle: Math.max(0, g.total - g.used) };
+                if (!p)
+                    continue;
+                const list = [...byType.entries()]
+                    .filter(([, g]) => g.total > 0)
+                    .map(([type, g]) => ({ type, total: g.total, idle: Math.max(0, g.total - g.used) }))
+                    .sort((a, b) => b.total - a.total || a.type.localeCompare(b.type));
+                if (list.length)
+                    p.gpus = list;
             }
         }
         // Queue depth from squeue, aggregated per partition AND per QoS.

package/node-server/dist/scheduler/types.d.ts

@@ -52,12 +52,13 @@ export interface PartitionLoad {
         other: number;
         total: number;
     };
-    /** GPU capacity for the partition: total configured vs currently idle (available). */
+    /** GPU capacity for the partition, one entry per GPU model (heterogeneous
+     *  queues carry several): total configured vs currently idle (available). */
     gpus?: {
         type: string;
         total: number;
         idle: number;
-    };
+    }[];
     nodes: {
         idle: number;
         mixed: number;

package/node-server/dist/terminal/agent-registry.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Agent registry — the server-side ledger of agent sessions (Claude Code /
+ * Codex CLIs running inside terminal ptys).
+ *
+ * Agents are project-scoped (keyed by the working directory they were
+ * launched in) and decoupled from notebooks: switching notebooks never kills
+ * or switches an agent; the user does, through the agent manager. Records
+ * persist to disk so agents survive as *resumable* entities even when their
+ * pty dies (browser gone, server restart, user hibernates them): the CLI's
+ * own on-disk trajectory (`claude --resume <id>` / `codex resume`) can
+ * reconstruct the conversation — the registry just remembers what exists,
+ * where, and how to revive it. The client owns launch/revive command
+ * construction (it knows about remote-agent mode); the server owns truth
+ * about what is live.
+ *
+ * States: 'live' (pty exists) → 'hibernated' (pty gone, trajectory on disk).
+ * All records load as 'hibernated' on boot — ptys never survive a restart.
+ */
+export interface AgentRecord {
+    /** Terminal (pty) id the agent runs in — stable, derived from workdir. */
+    terminalId: string;
+    kind: 'claude' | 'codex';
+    /** Directory the agent was launched in — the project scope. */
+    workdir: string;
+    /** Where the CLI process runs: this server, or the user's machine over the reverse channel. */
+    location: 'server' | 'remote';
+    /** Claude --session-id (resume pointer). Codex resumes via its own picker. */
+    sessionId?: string;
+    /** Notebook that launched it (informational only — agents are not bound to notebooks). */
+    launchedFrom?: string;
+    /**
+     * Pinned workspace-mirror dir slug (`p-<hash>-<name>` under ~/.nebula/agent).
+     * Stored at launch so record-driven resumes keep finding the conversation
+     * even if the slug derivation ever changes — paths in records don't drift.
+     */
+    mirrorSlug?: string;
+    state: 'live' | 'hibernated';
+    createdAt: number;
+    lastLaunchAt: number;
+}
+declare class AgentRegistry {
+    private records;
+    private exitUnsubs;
+    private loaded;
+    private ensureLoaded;
+    private persist;
+    /**
+     * Register (or re-register on revive) an agent launched in a terminal.
+     * MERGE semantics: fields the caller didn't supply NEVER overwrite stored
+     * truth — a resume relaunch that doesn't know the sessionId must not erase
+     * the registry's copy (that id is the conversation; losing it downgrades
+     * every later Continue to a picker).
+     */
+    register(rec: Omit<AgentRecord, 'state' | 'createdAt' | 'lastLaunchAt'>): AgentRecord;
+    private static TUI_INIT_RE;
+    private static TUI_TEARDOWN_RE;
+    private dataUnsubs;
+    private graceTimers;
+    private watchLiveness;
+    /** Feed pty output through the liveness machine (public for tests). */
+    observeOutput(terminalId: string, chunk: string): void;
+    /** List all agents, reconciling 'live' against actual pty existence. */
+    list(): AgentRecord[];
+    /**
+     * list() plus process-table facts for every record whose pty exists:
+     * - `busy`: the pty's shell has a live child — SOMETHING is running there.
+     *   Crucially reported on HIBERNATED records too: the TUI-stream liveness
+     *   machine can mis-score (an agent resumed by hand never re-registers), and
+     *   a client that trusts 'hibernated' then types a launch command straight
+     *   into the running TUI's input box (lab report: a live codex politely
+     *   declined to run the pasted ssh line). The process table is authoritative.
+     * - `idleShell` on live records: the inverse — 'live' but nothing running
+     *   (a hung-then-dead ssh hop leaves exactly this; a dead transport emits
+     *   no teardown, so only the process table can see it).
+     * Unknown checks claim nothing.
+     */
+    listEnriched(): Promise<(AgentRecord & {
+        idleShell?: boolean;
+        busy?: boolean;
+    })[]>;
+    /** Hibernate: close the pty; the record (and on-disk trajectory) remain. */
+    hibernate(terminalId: string): boolean;
+    /** Forget the agent entirely (pty closed; registry record removed). */
+    remove(terminalId: string): boolean;
+}
+export declare const agentRegistry: AgentRegistry;
+export {};

package/node-server/dist/terminal/agent-registry.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Agent registry — the server-side ledger of agent sessions (Claude Code /
+ * Codex CLIs running inside terminal ptys).
+ *
+ * Agents are project-scoped (keyed by the working directory they were
+ * launched in) and decoupled from notebooks: switching notebooks never kills
+ * or switches an agent; the user does, through the agent manager. Records
+ * persist to disk so agents survive as *resumable* entities even when their
+ * pty dies (browser gone, server restart, user hibernates them): the CLI's
+ * own on-disk trajectory (`claude --resume <id>` / `codex resume`) can
+ * reconstruct the conversation — the registry just remembers what exists,
+ * where, and how to revive it. The client owns launch/revive command
+ * construction (it knows about remote-agent mode); the server owns truth
+ * about what is live.
+ *
+ * States: 'live' (pty exists) → 'hibernated' (pty gone, trajectory on disk).
+ * All records load as 'hibernated' on boot — ptys never survive a restart.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const pty_manager_1 = require("./pty-manager");
+const STATE_FILE = process.env.NEBULA_AGENTS_FILE || path.join(os.homedir(), '.nebula', 'agents.json');
+const MAX_RECORDS = 50; // oldest hibernated records beyond this are dropped
+class AgentRegistry {
+    records = new Map();
+    exitUnsubs = new Map();
+    loaded = false;
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            if (fs.existsSync(STATE_FILE)) {
+                const list = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+                for (const r of list) {
+                    if (!r?.terminalId)
+                        continue;
+                    // Ptys never survive a server restart — everything reloads hibernated.
+                    r.state = 'hibernated';
+                    this.records.set(r.terminalId, r);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[AgentRegistry] failed to load state:', err);
+        }
+    }
+    persist() {
+        try {
+            const dir = path.dirname(STATE_FILE);
+            fs.mkdirSync(dir, { recursive: true });
+            const all = [...this.records.values()].sort((a, b) => b.lastLaunchAt - a.lastLaunchAt);
+            const live = all.filter((r) => r.state === 'live');
+            const hibernated = all.filter((r) => r.state !== 'live').slice(0, MAX_RECORDS - live.length);
+            const tmp = `${STATE_FILE}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify([...live, ...hibernated], null, 2));
+            fs.renameSync(tmp, STATE_FILE);
+        }
+        catch (err) {
+            console.error('[AgentRegistry] failed to persist state:', err);
+        }
+    }
+    /**
+     * Register (or re-register on revive) an agent launched in a terminal.
+     * MERGE semantics: fields the caller didn't supply NEVER overwrite stored
+     * truth — a resume relaunch that doesn't know the sessionId must not erase
+     * the registry's copy (that id is the conversation; losing it downgrades
+     * every later Continue to a picker).
+     */
+    register(rec) {
+        this.ensureLoaded();
+        const existing = this.records.get(rec.terminalId);
+        const record = {
+            ...existing,
+            ...rec,
+            sessionId: rec.sessionId ?? existing?.sessionId,
+            mirrorSlug: rec.mirrorSlug ?? existing?.mirrorSlug,
+            launchedFrom: rec.launchedFrom ?? existing?.launchedFrom,
+            state: 'live',
+            createdAt: existing?.createdAt ?? Date.now(),
+            lastLaunchAt: Date.now(),
+        };
+        this.records.set(rec.terminalId, record);
+        // When the pty dies for any reason (user exits the CLI and closes the
+        // terminal, hibernate, server-side kill), the agent is not gone — its
+        // trajectory is on disk. Mark it hibernated, ready to revive.
+        this.exitUnsubs.get(rec.terminalId)?.();
+        const unsub = pty_manager_1.ptyManager.addExitListener(rec.terminalId, () => {
+            const r = this.records.get(rec.terminalId);
+            if (r && r.state === 'live') {
+                r.state = 'hibernated';
+                this.persist();
+            }
+            this.exitUnsubs.delete(rec.terminalId);
+        });
+        this.exitUnsubs.set(rec.terminalId, unsub);
+        // SERVER-SIDE liveness: the pty stream passes through this process, so the
+        // agent-alive state machine lives HERE, not in whichever browser happens to
+        // be attached. TUI teardown with no re-init within the grace window means
+        // the agent exited to the shell — the record flips to 'hibernated' even
+        // though the pty lives on (revive types the resume command into it).
+        this.watchLiveness(rec.terminalId);
+        this.persist();
+        return record;
+    }
+    static TUI_INIT_RE = /\x1b\[\?(1049|1004|1000|1002|1003)h/;
+    static TUI_TEARDOWN_RE = /\x1b\[\?(1049|1004|1000|1002|1003)l/;
+    dataUnsubs = new Map();
+    graceTimers = new Map();
+    watchLiveness(terminalId) {
+        this.dataUnsubs.get(terminalId)?.();
+        const unsub = pty_manager_1.ptyManager.addDataListener(terminalId, (chunk) => {
+            this.observeOutput(terminalId, chunk);
+        });
+        if (unsub)
+            this.dataUnsubs.set(terminalId, unsub);
+    }
+    /** Feed pty output through the liveness machine (public for tests). */
+    observeOutput(terminalId, chunk) {
+        const r = this.records.get(terminalId);
+        if (!r)
+            return;
+        if (AgentRegistry.TUI_INIT_RE.test(chunk)) {
+            const t = this.graceTimers.get(terminalId);
+            if (t) {
+                clearTimeout(t);
+                this.graceTimers.delete(terminalId);
+            }
+            if (r.state !== 'live') {
+                r.state = 'live';
+                r.lastLaunchAt = Date.now();
+                this.persist();
+            }
+            return;
+        }
+        if (AgentRegistry.TUI_TEARDOWN_RE.test(chunk) && r.state === 'live' && !this.graceTimers.has(terminalId)) {
+            this.graceTimers.set(terminalId, setTimeout(() => {
+                this.graceTimers.delete(terminalId);
+                const rec = this.records.get(terminalId);
+                if (rec && rec.state === 'live') {
+                    rec.state = 'hibernated'; // agent exited; pty may still be a plain shell
+                    this.persist();
+                }
+            }, 2000));
+        }
+    }
+    /** List all agents, reconciling 'live' against actual pty existence. */
+    list() {
+        this.ensureLoaded();
+        for (const r of this.records.values()) {
+            if (r.state === 'live' && !pty_manager_1.ptyManager.get(r.terminalId)) {
+                r.state = 'hibernated';
+            }
+        }
+        return [...this.records.values()].sort((a, b) => b.lastLaunchAt - a.lastLaunchAt);
+    }
+    /**
+     * list() plus process-table facts for every record whose pty exists:
+     * - `busy`: the pty's shell has a live child — SOMETHING is running there.
+     *   Crucially reported on HIBERNATED records too: the TUI-stream liveness
+     *   machine can mis-score (an agent resumed by hand never re-registers), and
+     *   a client that trusts 'hibernated' then types a launch command straight
+     *   into the running TUI's input box (lab report: a live codex politely
+     *   declined to run the pasted ssh line). The process table is authoritative.
+     * - `idleShell` on live records: the inverse — 'live' but nothing running
+     *   (a hung-then-dead ssh hop leaves exactly this; a dead transport emits
+     *   no teardown, so only the process table can see it).
+     * Unknown checks claim nothing.
+     */
+    async listEnriched() {
+        return Promise.all(this.list().map(async (r) => {
+            if (!pty_manager_1.ptyManager.get(r.terminalId))
+                return r;
+            const hasChild = await pty_manager_1.ptyManager.hasLiveChild(r.terminalId);
+            if (hasChild === null)
+                return r;
+            return r.state === 'live'
+                ? { ...r, idleShell: !hasChild, busy: hasChild }
+                : { ...r, busy: hasChild };
+        }));
+    }
+    /** Hibernate: close the pty; the record (and on-disk trajectory) remain. */
+    hibernate(terminalId) {
+        this.ensureLoaded();
+        const r = this.records.get(terminalId);
+        if (!r)
+            return false;
+        if (pty_manager_1.ptyManager.get(terminalId))
+            pty_manager_1.ptyManager.kill(terminalId); // exit listener marks hibernated
+        r.state = 'hibernated';
+        this.persist();
+        return true;
+    }
+    /** Forget the agent entirely (pty closed; registry record removed). */
+    remove(terminalId) {
+        this.ensureLoaded();
+        const r = this.records.get(terminalId);
+        if (!r)
+            return false;
+        this.exitUnsubs.get(terminalId)?.();
+        this.exitUnsubs.delete(terminalId);
+        if (pty_manager_1.ptyManager.get(terminalId))
+            pty_manager_1.ptyManager.kill(terminalId);
+        this.records.delete(terminalId);
+        this.persist();
+        return true;
+    }
+}
+exports.agentRegistry = new AgentRegistry();