@zgeoff/atc 0.1.4 → 0.1.6

package/README.md

@@ -121,3 +121,9 @@ live fleet (name, cwd, Claude session id) to its SQLite store. If the daemon its
 SIGKILL, reboot — the child claude processes die with it, but every session's transcript is already
 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 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.4",
+  "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/cli.ts

@@ -50,16 +50,26 @@ const main = defineCommand({
           // Test harnesses shrink the outbound queue to force overflow
           // deterministically; unset means the production default.
           const queueBytes = Number(process.env['ATC_QUEUE_BYTES']);
+          const cfg = config.loadConfig();
+
+          // Cap on how long a fleet restore waits for one revived session to
+          // report it has booted before moving to the next. Tests pin it to
+          // keep timing deterministic; unset means the production default.
+          const capOverride = Number(process.env['ATC_RESTORE_BOOT_TIMEOUT_MS']);
+
+          const restoreBootTimeoutMs =
+            Number.isFinite(capOverride) && capOverride >= 0 ? capOverride : 15_000;
 
           const handle = daemon.startDaemon({
             headlessRunner: (runOpts, hooks) => headless.startHeadlessRun(runOpts, hooks),
             socketPath: config.daemonSocketPath,
             reporterSocketPath: config.socketPath,
             build: getBuild(),
-            adapter: new claude.ClaudeAdapter(config.loadConfig()),
+            adapter: new claude.ClaudeAdapter(cfg),
             dbPath: config.dbFile,
             legacyFleetPath: config.legacyFleetFile,
             pidPath: config.daemonPidFile,
+            restoreBootTimeoutMs,
             ...(Number.isFinite(queueBytes) && queueBytes > 0 ? { queueBytes } : {}),
             onQuit: () => process.exit(0),
           });

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 { SessionDescriptor, SessionState } from './sessions';
+import type { Session, SessionDescriptor, SessionState } from './sessions';
 import { StateStore } from './state-store';
 
 export interface DaemonOptions {
@@ -44,6 +44,13 @@ export interface DaemonOptions {
   // before starting the headless run anyway.
   readonly ejectSettleMs?: number;
 
+  // A fleet-wide restore revives one session at a time, waiting for each to
+  // report it has booted before starting the next so the machine is not
+  // buried under a dozen simultaneous agent boots. This caps how long a
+  // single revive waits for that signal before moving on regardless, so a
+  // session that never reports cannot stall the rest. Zero waits forever.
+  readonly restoreBootTimeoutMs?: number;
+
   // Called after a client-requested quit has stopped the daemon; the real
   // entrypoint exits the process, tests leave it unset.
   readonly onQuit?: () => void;
@@ -126,6 +133,37 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   // (or a settle timeout) before the headless run starts.
   const pendingEjects = new Map<string, () => void>();
 
+  // A staggered fleet restore parks a resolver here while it waits for the
+  // session it just revived to report it has booted; the reporter fires it on
+  // SessionStart, and a dying revive fires it too so a failed resume does not
+  // hold up the rest. Resolving a settled promise again is a no-op.
+  const bootWaiters = new Map<string, () => void>();
+
+  // Blocks until the session reports SessionStart, it dies, or the cap
+  // elapses (a positive cap only; zero waits on the signal alone).
+  const waitForBoot = (sessionID: string, capMs: number): Promise<void> => {
+    const settled = Promise.withResolvers<void>();
+    const timer = capMs > 0 ? setTimeout(settled.resolve, capMs) : undefined;
+
+    bootWaiters.set(sessionID, settled.resolve);
+
+    if (timer !== undefined) {
+      restoreTimers.add(timer);
+    }
+
+    return (async () => {
+      await settled.promise;
+
+      bootWaiters.delete(sessionID);
+
+      if (timer !== undefined) {
+        clearTimeout(timer);
+
+        restoreTimers.delete(timer);
+      }
+    })();
+  };
+
   const startHeadlessTurn = (sessionID: string, prompt: string): boolean => {
     const runner = opts.headlessRunner;
     const s = mgr.sessions.find((x) => x.id === sessionID);
@@ -172,6 +210,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   const screens = new Map<string, ScreenModel>();
   const resizeTimers = new Map<string, ReturnType<typeof setTimeout>>();
   const detectTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  const restoreTimers = new Set<ReturnType<typeof setTimeout>>();
 
   // The screen tier of the detector stack: once a session's output has
   // quiesced, judge the serialized screen and flip running/needs_you.
@@ -345,6 +384,12 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   mgr.onEvent = (kind, s) => {
     recordAttention(kind, s);
 
+    // A revive that dies before it ever announces itself must still release
+    // the staggered restore, or a failed resume would hold up the fleet.
+    if (kind === 'removed' || (kind === 'state' && s.pty === null)) {
+      bootWaiters.get(s.id)?.();
+    }
+
     if (kind === 'removed') {
       attachments.removeSession(s.id);
       seqs.delete(s.id);
@@ -397,6 +442,12 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       pendingEjects.get(e.atcId)?.();
     }
 
+    // A revived session announcing itself is the cue a staggered restore
+    // waits on before booting the next one.
+    if (e.event === 'SessionStart') {
+      bootWaiters.get(e.atcId)?.();
+    }
+
     mgr.applyHook(e);
   }, opts.reporterSocketPath);
 
@@ -482,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';
@@ -563,33 +618,74 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
     getEffectiveDims: (sessionID) =>
       attachments.findEffectiveDims(sessionID) ?? ptyDims.get(sessionID) ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) => {
-      let restored = 0;
-
-      for (const entry of store.loadFleet()) {
-        const live = mgr.sessions.some((s) => s.pty !== null && s.claudeId === entry.claudeId);
+      const hasSession = (claudeId: string) =>
+        mgr.sessions.some(
+          (s) =>
+            s.claudeId === claudeId &&
+            (s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited')),
+        );
 
-        if (live) {
-          continue;
-        }
+      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));
 
-        restored++;
+        if (!screens.has(s.id)) {
+          screens.set(s.id, new ScreenModel(cols, rows));
+        }
+
+        return true;
+      };
+
+      const [first, ...rest] = queued;
+
+      if (first === undefined) {
+        return 0;
       }
 
-      return restored;
+      // 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 adoptRest = async (previous: Session | null) => {
+        let prev = previous;
+
+        for (const s of rest) {
+          if (prev !== null) {
+            await waitForBoot(prev.id, cap);
+          }
+
+          prev = adoptQueued(s) ? s : null;
+        }
+      };
+
+      const firstBooted = adoptQueued(first) ? first : null;
+
+      void adoptRest(firstBooted);
+
+      return queued.length;
     },
   };
 
@@ -628,6 +724,10 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       clearTimeout(timer);
     }
 
+    for (const timer of restoreTimers) {
+      clearTimeout(timer);
+    }
+
     server.stop(true);
     reporter.stop(true);
     mgr.killAll();

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');