@zgeoff/atc 0.1.5 → 0.1.6

package/README.md

@@ -122,7 +122,8 @@ SIGKILL, reboot — the child claude processes die with it, but every session's
 on disk. Start atc and press `R`: the whole fleet respawns via `claude --resume`. Only deliberate
 kills (`K`, `Y` eject) remove entries from the fleet, so it stays restorable.
 
-Restoring revives one session at a time: the next `claude --resume` starts only once the previous
-one has reported it is up (its `SessionStart` hook), so bringing back a dozen sessions no longer
-launches a dozen Claude processes at the same instant and pins the machine. The list fills in live
-as each comes back.
+Restoring shows the whole fleet immediately — every incoming session appears in the list marked
+"waiting to restore" — and revives one at a time, most recently active first: the next
+`claude --resume` starts only once the previous one has reported it is up (its `SessionStart` hook),
+so bringing back a dozen sessions no longer launches a dozen Claude processes at the same instant
+and pins the machine. Each row flips live as its session comes back.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Terminal control tower for Claude Code sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/daemon.ts

@@ -10,7 +10,7 @@ import { MAX_CHUNK, PROTOCOL_V } from './protocol';
 import type { EventMsg } from './protocol';
 import { ScreenModel } from './screen-model';
 import { SessionManager } from './sessions';
-import type { FleetEntry, Session, SessionDescriptor, SessionState } from './sessions';
+import type { Session, SessionDescriptor, SessionState } from './sessions';
 import { StateStore } from './state-store';
 
 export interface DaemonOptions {
@@ -533,6 +533,10 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
 
       ptyDims.set(id, { cols, rows });
 
+      if (!screens.has(id)) {
+        screens.set(id, new ScreenModel(cols, rows));
+      }
+
       scheduleResize(id);
 
       return 'ok';
@@ -614,59 +618,74 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
     getEffectiveDims: (sessionID) =>
       attachments.findEffectiveDims(sessionID) ?? ptyDims.get(sessionID) ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) => {
-      const isLive = (claudeId: string | undefined) =>
-        mgr.sessions.some((s) => s.pty !== null && s.claudeId === claudeId);
+      const hasSession = (claudeId: string) =>
+        mgr.sessions.some(
+          (s) =>
+            s.claudeId === claudeId &&
+            (s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited')),
+        );
 
-      const restoreEntry = (entry: FleetEntry): Session | null => {
-        if (isLive(entry.claudeId)) {
-          return null;
-        }
+      const recency = store.collectFleetRecency();
 
-        const s = mgr.spawn(
-          entry.cwd,
-          entry.name,
-          '',
-          cols,
-          rows,
-          entry.claudeId,
-          'auto',
-          entry.group,
+      // Most recently active sessions revive first, so the ones the user was
+      // just working in come back before long-idle ones; entries that never
+      // reported an event keep their stored order at the end.
+      const entries = store
+        .loadFleet()
+        .filter((entry) => !hasSession(entry.claudeId))
+        .toSorted((a, b) =>
+          (recency.get(b.claudeId) ?? '').localeCompare(recency.get(a.claudeId) ?? ''),
         );
 
+      // The whole fleet registers as terminal-less sessions up front, so the
+      // list shows every incoming session immediately instead of revealing
+      // them one boot at a time.
+      const queued = entries.map((entry) => mgr.restore(entry));
+
+      const adoptQueued = (s: Session): boolean => {
+        if (mgr.adoptTerminal(s.id, cols, rows) === null) {
+          return false;
+        }
+
         ptyDims.set(s.id, { cols, rows });
-        screens.set(s.id, new ScreenModel(cols, rows));
 
-        return s;
+        if (!screens.has(s.id)) {
+          screens.set(s.id, new ScreenModel(cols, rows));
+        }
+
+        return true;
       };
 
-      const [first, ...rest] = store.loadFleet().filter((entry) => !isLive(entry.claudeId));
+      const [first, ...rest] = queued;
 
       if (first === undefined) {
         return 0;
       }
 
-      // The first revive is synchronous so a caller can attach at once; each
-      // later revive waits for the previous session to report it has booted,
-      // so a heavy fleet comes up one process at a time instead of all at
-      // once. A per-session cap keeps a session that never reports from
-      // stalling the rest.
+      // The first terminal attaches synchronously so a caller can attach at
+      // once; each later one waits for the previous session to report it has
+      // booted, so a heavy fleet comes up one process at a time instead of
+      // all at once. A per-session cap keeps a session that never reports
+      // from stalling the rest.
       const cap = opts.restoreBootTimeoutMs ?? 0;
 
-      const restoreRest = async (previous: Session | null) => {
+      const adoptRest = async (previous: Session | null) => {
         let prev = previous;
 
-        for (const entry of rest) {
+        for (const s of rest) {
           if (prev !== null) {
             await waitForBoot(prev.id, cap);
           }
 
-          prev = restoreEntry(entry);
+          prev = adoptQueued(s) ? s : null;
         }
       };
 
-      void restoreRest(restoreEntry(first));
+      const firstBooted = adoptQueued(first) ? first : null;
+
+      void adoptRest(firstBooted);
 
-      return 1 + rest.length;
+      return queued.length;
     },
   };
 

package/src/sessions.ts

@@ -141,6 +141,32 @@ export class SessionManager {
     return s;
   }
 
+  // Registers a fleet entry as a session with no terminal yet, so a
+  // fleet-wide restore can show every incoming session at once; adopting it
+  // later attaches the terminal.
+  restore(entry: FleetEntry): Session {
+    const session: Session = {
+      id: `s${++counter}-${Date.now().toString(36)}`,
+      name: entry.name,
+      cwd: entry.cwd,
+      kind: 'jsonl',
+      pty: null,
+      state: 'running',
+      unread: false,
+      lastMsg: 'waiting to restore',
+      claudeId: entry.claudeId,
+      ...(entry.group === undefined ? {} : { group: entry.group }),
+      namedBy: 'auto',
+      createdAt: Date.now(),
+    };
+
+    this.sessions.push(session);
+    this.writeStatus();
+    this.onEvent('added', session);
+
+    return session;
+  }
+
   // Adopts a headless session back into a terminal: a fresh PTY resumes the
   // same agent session id.
   adoptTerminal(id: string, cols: number, rows: number): Session | null {

package/src/state-store.ts

@@ -77,6 +77,18 @@ export class StateStore {
     return entries;
   }
 
+  // The latest hook-event timestamp per agent session id, from the event
+  // trail. Sessions that never reported an event are absent.
+  collectFleetRecency(): Map<string, string> {
+    const rows = this.db
+      .query<{ session_id: string; ts: string }, []>(
+        'SELECT session_id, MAX(ts) AS ts FROM events WHERE session_id IS NOT NULL GROUP BY session_id',
+      )
+      .all();
+
+    return new Map(rows.map((row) => [row.session_id, row.ts]));
+  }
+
   writeFleet(entries: readonly FleetEntry[]): void {
     const replace = this.db.transaction((all: readonly FleetEntry[]) => {
       this.db.run('DELETE FROM fleet');