@zgeoff/atc 0.1.11 → 0.1.12

package/README.md

@@ -56,7 +56,7 @@ fine nested inside zellij/tmux (give the pane locked mode so Ctrl-Space reaches
 | `P`             | overlay        | revive: a fresh terminal resumes a headless or killed session in place                                                                                                  |
 | `y`             | overlay        | yank the resume command (`claude --resume <id>`, `grok --resume <id>`, or `codex resume <id>`)                                                                          |
 | `Y`             | overlay        | eject: yank the resume command, then kill the session here                                                                                                              |
-| `K`             | overlay        | kill selected (confirm with `y`) — the entry stays revivable with `P`; a second `K` forgets it                                                                          |
+| `K`             | overlay        | kill selected (confirm with `y`) — the entry stays revivable with `P`, even across daemon restarts; a second `K` forgets it                                             |
 | `?`             | overlay        | full key reference — the hint row only shows actions valid for the selected session                                                                                     |
 | `u`             | overlay        | restart an outdated daemon and restore the fleet — offered only while `⟳ update ready` shows                                                                            |
 | `q`             | home/overlay   | quit the client — sessions keep running in the daemon                                                                                                                   |
@@ -186,8 +186,9 @@ restarts the daemon and restores the fleet at a moment you choose. Only a protoc
 the two could miscommunicate, forces the restart immediately. The daemon continuously writes the
 live fleet (name, cwd, agent, session id) to its SQLite store. If the daemon itself dies — crash,
 SIGKILL, reboot — the child processes die with it, but every session's transcript is already on
-disk. Start atc and press `R`: the whole fleet respawns with the matching CLI. Only deliberate kills
-(`K`, `Y` eject) remove entries from the fleet, so it stays restorable.
+disk. Start atc and press `R`: the whole fleet respawns with the matching CLI. Killed sessions (`K`,
+`Y` eject) stay in the fleet as exited entries — restore lists them as killed without booting a
+terminal, and `P` still revives them. A second `K` forgets an entry for good.
 
 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 resume starts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "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

@@ -615,29 +615,40 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
     getEffectiveDims: (sessionID) =>
       attachments.findEffectiveDims(sessionID) ?? ptyDims.get(sessionID) ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) => {
-      const hasSession = (agentSessionID: string) =>
+      const hasLiveSession = (agentSessionID: string) =>
         mgr.sessions.some(
           (s) =>
             s.agentSessionID === agentSessionID &&
             (s.pty !== null || (s.kind === 'headless' && s.state !== 'exited')),
         );
 
+      const hasAnySession = (agentSessionID: string) =>
+        mgr.sessions.some((s) => s.agentSessionID === agentSessionID);
+
       const recency = store.collectFleetRecency();
 
       // 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.
+      // reported an event keep their stored order at the end. Exited entries
+      // dedupe against every listed session, so repeated restores never
+      // double up the killed archive.
       const entries = store
         .loadFleet()
-        .filter((entry) => !hasSession(entry.agentSessionID))
+        .filter((entry) =>
+          entry.exited === true
+            ? !hasAnySession(entry.agentSessionID)
+            : !hasLiveSession(entry.agentSessionID),
+        )
         .toSorted((a, b) =>
           (recency.get(b.agentSessionID) ?? '').localeCompare(recency.get(a.agentSessionID) ?? ''),
         );
 
       // 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));
+      // them one boot at a time. Exited entries only register — they stay
+      // killed until revived by hand, so no terminal is adopted for them.
+      const registered = entries.map((entry) => mgr.restore(entry));
+      const queued = registered.filter((s) => s.state !== 'exited');
 
       const adoptQueued = (s: Session): boolean => {
         if (mgr.adoptTerminal(s.id, cols, rows) === null) {
@@ -656,7 +667,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       const [first, ...rest] = queued;
 
       if (first === undefined) {
-        return 0;
+        return registered.length;
       }
 
       // The first terminal attaches synchronously so a caller can attach at
@@ -682,7 +693,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
 
       void adoptRest(firstBooted);
 
-      return queued.length;
+      return registered.length;
     },
   };
 

package/src/sessions.ts

@@ -73,6 +73,7 @@ export interface FleetEntry {
   readonly agent: AgentKind;
   readonly pinned?: boolean;
   readonly lastAttachedAt?: number;
+  readonly exited?: boolean;
 }
 
 const fleetFile = join(stateDir, 'fleet.json');
@@ -111,6 +112,7 @@ export function parseFleetEntry(raw: unknown): FleetEntry | undefined {
     agent: toAgentKind(raw['agent']),
     ...(raw['pinned'] === true ? { pinned: true } : {}),
     ...(typeof raw['lastAttachedAt'] === 'number' ? { lastAttachedAt: raw['lastAttachedAt'] } : {}),
+    ...(raw['exited'] === true ? { exited: true } : {}),
   };
 }
 
@@ -206,17 +208,20 @@ export class SessionManager {
 
   // 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.
+  // later attaches the terminal. Exited entries come back as killed
+  // sessions: still listed and revivable, never auto-adopted.
   restore(entry: FleetEntry): Session {
+    const exited = entry.exited === true;
+
     const session: Session = {
       id: `s${++counter}-${Date.now().toString(36)}`,
       name: entry.name,
       cwd: entry.cwd,
       kind: 'headless',
       pty: null,
-      state: 'running',
+      state: exited ? 'exited' : 'running',
       unread: false,
-      lastMsg: 'waiting to restore',
+      lastMsg: exited ? 'killed' : 'waiting to restore',
       agentSessionID: entry.agentSessionID,
       agent: entry.agent,
       pinned: entry.pinned ?? false,
@@ -691,23 +696,28 @@ export class SessionManager {
 
   // Persisted continuously so a crash (or quit) leaves a restorable fleet.
   // Deliberate kills rewrite the file; unexpected session/atc deaths do not,
-  // so the last known fleet survives for `R` restore.
+  // so the last known fleet survives for `R` restore. Sessions whose
+  // terminal is gone persist as exited entries, so the killed archive
+  // survives a daemon restart too.
   writeFleet() {
     const fleet: FleetEntry[] = [];
 
     for (const s of this.sessions) {
+      if (s.agentSessionID === undefined) {
+        continue;
+      }
+
       const live = s.pty !== null || (s.kind === 'headless' && s.state !== 'exited');
 
-      if (live && s.agentSessionID !== undefined) {
-        fleet.push({
-          name: s.name,
-          cwd: s.cwd,
-          agentSessionID: s.agentSessionID,
-          agent: s.agent,
-          ...(s.pinned ? { pinned: true } : {}),
-          lastAttachedAt: s.lastAttachedAt,
-        });
-      }
+      fleet.push({
+        name: s.name,
+        cwd: s.cwd,
+        agentSessionID: s.agentSessionID,
+        agent: s.agent,
+        ...(s.pinned ? { pinned: true } : {}),
+        lastAttachedAt: s.lastAttachedAt,
+        ...(live ? {} : { exited: true }),
+      });
     }
 
     this.store.writeFleet(fleet);

package/src/state-store.ts

@@ -28,7 +28,8 @@ export class StateStore {
         cwd TEXT NOT NULL,
         pinned INTEGER NOT NULL DEFAULT 0,
         last_attached INTEGER,
-        agent TEXT NOT NULL DEFAULT 'claude'
+        agent TEXT NOT NULL DEFAULT 'claude',
+        exited INTEGER NOT NULL DEFAULT 0
       );
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -75,6 +76,10 @@ export class StateStore {
       this.db.run("ALTER TABLE fleet ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude'");
     }
 
+    if (!fleetColumns.has('exited')) {
+      this.db.run('ALTER TABLE fleet ADD COLUMN exited INTEGER NOT NULL DEFAULT 0');
+    }
+
     if (legacyFleetPath !== undefined) {
       this.adoptLegacyFleet(legacyFleetPath);
     }
@@ -90,9 +95,10 @@ export class StateStore {
           pinned: number;
           last_attached: number | null;
           agent: string | null;
+          exited: number;
         },
         []
-      >('SELECT agent_session_id, name, cwd, pinned, last_attached, agent FROM fleet')
+      >('SELECT agent_session_id, name, cwd, pinned, last_attached, agent, exited FROM fleet')
       .all();
 
     const entries: FleetEntry[] = [];
@@ -105,6 +111,7 @@ export class StateStore {
         agent: toAgentKind(row.agent),
         ...(row.pinned === 0 ? {} : { pinned: true }),
         ...(row.last_attached === null ? {} : { lastAttachedAt: row.last_attached }),
+        ...(row.exited === 0 ? {} : { exited: true }),
       });
     }
 
@@ -128,11 +135,12 @@ export class StateStore {
       this.db.run('DELETE FROM fleet');
 
       const insert = this.db.query(
-        'INSERT OR REPLACE INTO fleet (agent_session_id, name, cwd, pinned, last_attached, agent) VALUES (?1, ?2, ?3, ?4, ?5, ?6)',
+        'INSERT OR REPLACE INTO fleet (agent_session_id, name, cwd, pinned, last_attached, agent, exited) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)',
       );
 
       for (const entry of all) {
         const pinned = entry.pinned === true ? 1 : 0;
+        const exited = entry.exited === true ? 1 : 0;
 
         insert.run(
           entry.agentSessionID,
@@ -141,6 +149,7 @@ export class StateStore {
           pinned,
           entry.lastAttachedAt ?? null,
           entry.agent,
+          exited,
         );
       }
     });