@zgeoff/atc 0.1.5 → 0.1.7

package/README.md

@@ -43,7 +43,7 @@ fine nested inside zellij/tmux (give the pane locked mode so Ctrl-Space reaches
 | `R`             | home           | restore last fleet after a daemon death — respawns every session via `claude --resume <id>`    |
 | `j`/`k`/`↑`/`↓` | overlay/picker | move                                                                                           |
 | `Enter`         | overlay        | attach (auto-acks)                                                                             |
-| `Tab`           | overlay        | attach the most urgent needs-you session                                                       |
+| `Tab`           | overlay        | attach the most urgent needs-you session, else the latest turn-done one                        |
 | `/`             | overlay        | fuzzy filter by name/dir (chars in order), `⏎` attach top match, `esc` clear                   |
 | `a`             | overlay        | ack notification without attaching                                                             |
 | `H`             | overlay        | eject to headless: the terminal dies, a headless Agent SDK run resumes the same session        |
@@ -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.7",
   "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/index.ts

@@ -2,6 +2,7 @@ import { basename } from 'node:path';
 import { bootDaemonClient } from './boot-daemon';
 import { loadConfig } from './config';
 import { collectDirs, findFuzzyScore, formatDir, pickMatches } from './dirs';
+import { pickTabTarget } from './pick-tab-target';
 import type { EventMsg } from './protocol';
 import { isRecord } from './report';
 import { countSessionStates, sortGroupedSessionViews, sortSessionViews } from './sessions';
@@ -39,6 +40,12 @@ let confirmKill = false;
 
 // The client's mirror of the daemon's fleet, kept fresh by events.
 let fleet: MirrorSession[] = [];
+
+// When each session last flipped to done, so the Tab jump can prefer the
+// most recently finished turn. Sessions already done before this client
+// connected have no entry and rank last.
+const doneAt = new Map<string, number>();
+
 let focusedID: string | null = null;
 let fleetCount = 0;
 
@@ -471,6 +478,10 @@ function applyDaemonEvent(e: EventMsg) {
       if (s !== undefined) {
         const next = SESSION_STATES.find((x) => x === e['state']);
 
+        if (next === 'done' && s.state !== 'done') {
+          doneAt.set(s.id, Date.now());
+        }
+
         if (next !== undefined) {
           s.state = next;
         }
@@ -524,6 +535,10 @@ function applyDaemonEvent(e: EventMsg) {
     case 'session.removed': {
       fleet = fleet.filter((x) => x.id !== e['s']);
 
+      if (typeof e['s'] === 'string') {
+        doneAt.delete(e['s']);
+      }
+
       if (focusedID === e['s']) {
         focusedID = null;
       }
@@ -695,10 +710,10 @@ function applyOverlayKey(buf: Buffer) {
   const ch = buf.toString();
 
   if (buf[0] === KEY.tab) {
-    const needy = sortSessionViews(fleet).find((s) => s.state === 'needs_you' && s.alive);
+    const target = pickTabTarget(fleet, (id) => doneAt.get(id));
 
-    if (needy !== undefined) {
-      void attach(needy.id);
+    if (target !== undefined) {
+      void attach(target.id);
     }
 
     return;

package/src/pick-tab-target.ts

@@ -0,0 +1,31 @@
+import type { SessionState } from './sessions';
+import { sortSessionViews } from './sessions';
+
+interface TabCandidate {
+  readonly id: string;
+  readonly state: SessionState;
+  readonly createdAt: number;
+  readonly alive: boolean;
+  readonly kind: 'pty' | 'jsonl';
+}
+
+/**
+ * The Tab jump target: the most urgent alive needs-you session, else the
+ * alive terminal session whose turn finished most recently. Headless
+ * sessions never qualify for the fallback — they have no terminal to
+ * attach — and sessions with no recorded finish time rank last.
+ */
+export function pickTabTarget<T extends TabCandidate>(
+  list: readonly T[],
+  findDoneAt: (id: string) => number | undefined,
+): T | undefined {
+  const needy = sortSessionViews(list).find((s) => s.state === 'needs_you' && s.alive);
+
+  if (needy !== undefined) {
+    return needy;
+  }
+
+  return sortSessionViews(list)
+    .filter((s) => s.state === 'done' && s.alive && s.kind === 'pty')
+    .toSorted((a, b) => (findDoneAt(b.id) ?? 0) - (findDoneAt(a.id) ?? 0))[0];
+}

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

package/src/ui.ts

@@ -274,7 +274,7 @@ export function drawHelp() {
 
   const lines = [
     '⏎  attach the selected session',
-    '⇥  attach the most urgent needs-you session',
+    '⇥  attach the most urgent needs-you, else latest done',
     'a  ack its notification without attaching',
     'H  eject to a headless run',
     'P  revive a dead or headless session',