@zgeoff/atc 0.1.9 → 0.1.11

package/src/sessions.ts

@@ -2,7 +2,8 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { spawn } from 'bun-pty';
 import type { IPty } from 'bun-pty';
-import type { AgentAdapter } from './agent-adapter';
+import { toAgentKind } from './agent-adapter';
+import type { AdapterEvent, AgentAdapter, AgentKind } from './agent-adapter';
 import { collectCleanEnv } from './collect-clean-env';
 import { socketPath, stateDir, statusFile } from './config';
 import type { HookEvent } from './hooks';
@@ -23,13 +24,14 @@ export interface SessionDescriptor {
   readonly unread: boolean;
   readonly lastMsg: string;
   readonly lastDetail?: string;
-  readonly claudeId?: string;
+  readonly agentSessionID?: string;
+  readonly agent: AgentKind;
   readonly pinned: boolean;
   readonly lastAttachedAt: number;
   readonly repoRoot: string;
   readonly namedBy: 'user' | 'auto' | 'agent';
   readonly createdAt: number;
-  readonly kind: 'pty' | 'jsonl';
+  readonly kind: 'pty' | 'headless';
   readonly alive: boolean;
 }
 
@@ -37,13 +39,14 @@ export interface Session {
   id: string;
   name: string;
   cwd: string;
-  kind: 'pty' | 'jsonl';
+  kind: 'pty' | 'headless';
   pty: IPty | null;
   state: SessionState;
   unread: boolean;
   lastMsg: string;
   lastDetail?: string;
-  claudeId?: string;
+  agentSessionID?: string;
+  agent: AgentKind;
   transcriptSource?: string;
   pinned: boolean;
 
@@ -66,7 +69,8 @@ let counter = 0;
 export interface FleetEntry {
   readonly name: string;
   readonly cwd: string;
-  readonly claudeId: string;
+  readonly agentSessionID: string;
+  readonly agent: AgentKind;
   readonly pinned?: boolean;
   readonly lastAttachedAt?: number;
 }
@@ -87,6 +91,29 @@ const jsonFleetStore: FleetStore = {
   },
 };
 
+export function parseFleetEntry(raw: unknown): FleetEntry | undefined {
+  if (!isRecord(raw) || typeof raw['name'] !== 'string' || typeof raw['cwd'] !== 'string') {
+    return undefined;
+  }
+
+  // Fleet files written before the id key was agent-neutral carry it under
+  // its Claude-era name.
+  const agentSessionID = raw['agentSessionID'] ?? raw['claudeId'];
+
+  if (typeof agentSessionID !== 'string') {
+    return undefined;
+  }
+
+  return {
+    name: raw['name'],
+    cwd: raw['cwd'],
+    agentSessionID,
+    agent: toAgentKind(raw['agent']),
+    ...(raw['pinned'] === true ? { pinned: true } : {}),
+    ...(typeof raw['lastAttachedAt'] === 'number' ? { lastAttachedAt: raw['lastAttachedAt'] } : {}),
+  };
+}
+
 function loadFleet(): FleetEntry[] {
   try {
     const parsed: unknown = JSON.parse(readFileSync(fleetFile, 'utf8'));
@@ -95,13 +122,17 @@ function loadFleet(): FleetEntry[] {
       return [];
     }
 
-    return parsed.filter(
-      (entry): entry is FleetEntry =>
-        isRecord(entry) &&
-        typeof entry['name'] === 'string' &&
-        typeof entry['cwd'] === 'string' &&
-        typeof entry['claudeId'] === 'string',
-    );
+    const entries: FleetEntry[] = [];
+
+    for (const entry of parsed) {
+      const parsedEntry = parseFleetEntry(entry);
+
+      if (parsedEntry !== undefined) {
+        entries.push(parsedEntry);
+      }
+    }
+
+    return entries;
   } catch {
     return [];
   }
@@ -118,31 +149,51 @@ export class SessionManager {
 
   onEvent: (kind: SessionEventKind, s: Session) => void = () => {};
 
-  private readonly adapter: AgentAdapter;
+  private readonly fallback: AgentAdapter;
+
+  private readonly adapters: Partial<Readonly<Record<AgentKind, AgentAdapter>>>;
 
   private readonly store: FleetStore;
 
   private readonly statusPath: string;
 
-  constructor(adapter: AgentAdapter, store: FleetStore = jsonFleetStore, statusPath = statusFile) {
-    this.adapter = adapter;
+  constructor(
+    fallback: AgentAdapter,
+    store: FleetStore = jsonFleetStore,
+    statusPath: string | undefined = statusFile,
+    adapters: Partial<Readonly<Record<AgentKind, AgentAdapter>>> = {},
+  ) {
+    this.fallback = fallback;
+    this.adapters = adapters;
     this.store = store;
-    this.statusPath = statusPath;
+    this.statusPath = statusPath ?? statusFile;
+  }
+
+  /**
+   * Adapter for this kind, or null when none is registered. Never returns a
+   * different kind than the one asked for.
+   */
+  findAdapter(kind: AgentKind): AgentAdapter | null {
+    if (kind === 'claude') {
+      return this.adapters.claude ?? this.fallback;
+    }
+
+    return this.adapters[kind] ?? null;
   }
 
   // Hands a live terminal session off to a headless run: the terminal dies,
-  // the record lives on as a jsonl session and keeps its screen history.
+  // the record lives on as a headless session and keeps its screen history.
   yankHeadless(id: string): Session | null {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.pty === null || s.claudeId === undefined) {
+    if (!s || s.pty === null || s.agentSessionID === undefined) {
       return null;
     }
 
     const pty = s.pty;
 
     s.pty = null;
-    s.kind = 'jsonl';
+    s.kind = 'headless';
     s.state = 'running';
     s.lastMsg = 'ejected to headless';
 
@@ -161,12 +212,13 @@ export class SessionManager {
       id: `s${++counter}-${Date.now().toString(36)}`,
       name: entry.name,
       cwd: entry.cwd,
-      kind: 'jsonl',
+      kind: 'headless',
       pty: null,
       state: 'running',
       unread: false,
       lastMsg: 'waiting to restore',
-      claudeId: entry.claudeId,
+      agentSessionID: entry.agentSessionID,
+      agent: entry.agent,
       pinned: entry.pinned ?? false,
       lastAttachedAt: entry.lastAttachedAt ?? Date.now(),
       repoRoot: resolveRepoRoot(entry.cwd),
@@ -186,11 +238,17 @@ export class SessionManager {
   adoptTerminal(id: string, cols: number, rows: number): Session | null {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.pty !== null || s.claudeId === undefined) {
+    if (!s || s.pty !== null || s.agentSessionID === undefined) {
+      return null;
+    }
+
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
       return null;
     }
 
-    const plan = this.adapter.planSpawn({ prompt: '', resume: s.claudeId });
+    const plan = adapter.planSpawn({ prompt: '', resume: s.agentSessionID });
 
     const pty = spawn(plan.bin, plan.args, {
       name: 'xterm-256color',
@@ -264,7 +322,7 @@ export class SessionManager {
   updateSurfaceState(id: string, state: SessionState, msg: string) {
     const s = this.sessions.find((x) => x.id === id);
 
-    if (!s || s.kind !== 'jsonl') {
+    if (!s || s.kind !== 'headless') {
       return;
     }
 
@@ -314,9 +372,16 @@ export class SessionManager {
     rows: number,
     resume: boolean | string = false,
     namedBy: 'user' | 'auto' = 'auto',
+    agent: AgentKind = 'claude',
   ): Session {
+    const adapter = this.findAdapter(agent);
+
+    if (adapter === null) {
+      throw new Error(`no adapter for agent '${agent}'`);
+    }
+
     const id = `s${++counter}-${Date.now().toString(36)}`;
-    const plan = this.adapter.planSpawn({ prompt, resume });
+    const plan = adapter.planSpawn({ prompt, resume });
 
     const pty = spawn(plan.bin, plan.args, {
       name: 'xterm-256color',
@@ -341,7 +406,8 @@ export class SessionManager {
       state: 'running',
       unread: false,
       lastMsg: initialMsg,
-      ...(typeof resume === 'string' ? { claudeId: resume } : {}),
+      ...(typeof resume === 'string' ? { agentSessionID: resume } : {}),
+      agent,
       pinned: false,
       lastAttachedAt: Date.now(),
       repoRoot: resolveRepoRoot(cwd),
@@ -385,32 +451,46 @@ export class SessionManager {
       unread: s.unread,
       lastMsg: s.lastMsg,
       ...(s.lastDetail === undefined ? {} : { lastDetail: s.lastDetail }),
-      ...(s.claudeId === undefined ? {} : { claudeId: s.claudeId }),
+      ...(s.agentSessionID === undefined ? {} : { agentSessionID: s.agentSessionID }),
+      agent: s.agent,
       pinned: s.pinned,
       lastAttachedAt: s.lastAttachedAt,
       repoRoot: s.repoRoot,
       namedBy: s.namedBy,
       createdAt: s.createdAt,
       kind: s.kind,
-      alive: s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited'),
+      alive: s.pty !== null || (s.kind === 'headless' && s.state !== 'exited'),
     }));
   }
 
-  applyHook(e: HookEvent) {
+  // Returns the normalized event kind so the caller can key lifecycle
+  // bookkeeping on it, or null when no session or adapter matches.
+  applyHook(e: HookEvent): AdapterEvent['kind'] | null {
     const s = this.sessions.find((x) => x.id === e.atcId);
 
+    if (!s) {
+      return null;
+    }
+
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
+      return null;
+    }
+
+    const ev = adapter.normalizeHook(e);
+
     // Reporters belong to the terminal process; once a session is headless,
     // late reports from the dying terminal must not clobber its state.
-    if (!s || s.kind === 'jsonl') {
-      return;
+    if (s.kind === 'headless') {
+      return ev.kind;
     }
 
-    const ev = this.adapter.normalizeHook(e);
     const focused = this.focusedId === s.id;
     let dirty = false;
 
-    if (ev.agentSessionID !== undefined && s.claudeId !== ev.agentSessionID) {
-      s.claudeId = ev.agentSessionID;
+    if (ev.agentSessionID !== undefined && s.agentSessionID !== ev.agentSessionID) {
+      s.agentSessionID = ev.agentSessionID;
 
       this.writeFleet();
 
@@ -421,8 +501,11 @@ export class SessionManager {
       s.lastDetail = ev.detail;
     }
 
+    if (ev.transcriptSource !== undefined) {
+      s.transcriptSource = ev.transcriptSource;
+    }
+
     if (ev.nameSource !== undefined) {
-      s.transcriptSource = ev.nameSource;
       void this.refreshName(s, ev.nameSource);
     }
 
@@ -481,10 +564,18 @@ export class SessionManager {
       this.onEvent('state', s);
       this.emitChange();
     }
+
+    return ev.kind;
   }
 
   private async refreshName(s: Session, source: string) {
-    const update = await this.adapter.loadName(source, s.namedBy);
+    const adapter = this.findAdapter(s.agent);
+
+    if (adapter === null) {
+      return;
+    }
+
+    const update = await adapter.loadName(source, s.namedBy);
 
     if (update === null || update.name === '' || update.name === s.name) {
       return;
@@ -509,7 +600,7 @@ export class SessionManager {
       return null;
     }
 
-    return this.adapter.buildResumeCommand(s.cwd, s.claudeId);
+    return this.findAdapter(s.agent)?.buildResumeCommand(s.cwd, s.agentSessionID) ?? null;
   }
 
   attach(id: string) {
@@ -605,13 +696,14 @@ export class SessionManager {
     const fleet: FleetEntry[] = [];
 
     for (const s of this.sessions) {
-      const live = s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited');
+      const live = s.pty !== null || (s.kind === 'headless' && s.state !== 'exited');
 
-      if (live && s.claudeId !== undefined) {
+      if (live && s.agentSessionID !== undefined) {
         fleet.push({
           name: s.name,
           cwd: s.cwd,
-          claudeId: s.claudeId,
+          agentSessionID: s.agentSessionID,
+          agent: s.agent,
           ...(s.pinned ? { pinned: true } : {}),
           lastAttachedAt: s.lastAttachedAt,
         });

package/src/state-store.ts

@@ -1,7 +1,9 @@
 import { Database } from 'bun:sqlite';
 import { existsSync, readFileSync } from 'node:fs';
+import { toAgentKind } from './agent-adapter';
+import type { AgentKind } from './agent-adapter';
 import type { HookEvent } from './hooks';
-import { isRecord } from './report';
+import { parseFleetEntry } from './sessions';
 import type { FleetEntry } from './sessions';
 
 /**
@@ -21,11 +23,12 @@ export class StateStore {
 
     this.db.run(`
       CREATE TABLE IF NOT EXISTS fleet (
-        claude_id TEXT PRIMARY KEY,
+        agent_session_id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         cwd TEXT NOT NULL,
         pinned INTEGER NOT NULL DEFAULT 0,
-        last_attached INTEGER
+        last_attached INTEGER,
+        agent TEXT NOT NULL DEFAULT 'claude'
       );
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -39,10 +42,14 @@ export class StateStore {
         cwd TEXT PRIMARY KEY,
         last_spawn INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS prefs (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
     `);
 
-    // Stores created before pinning and attach recency existed lack the
-    // columns; the create above only applies to fresh databases.
+    // Stores created before pinning, attach recency, or agent kind existed
+    // lack the columns; the create above only applies to fresh databases.
     const fleetColumns = new Set(
       this.db
         .query<{ name: string }, []>('PRAGMA table_info(fleet)')
@@ -50,6 +57,12 @@ export class StateStore {
         .map((c) => c.name),
     );
 
+    // Stores created before the id column was agent-neutral carry it under
+    // its Claude-era name.
+    if (fleetColumns.has('claude_id')) {
+      this.db.run('ALTER TABLE fleet RENAME COLUMN claude_id TO agent_session_id');
+    }
+
     if (!fleetColumns.has('pinned')) {
       this.db.run('ALTER TABLE fleet ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0');
     }
@@ -58,6 +71,10 @@ export class StateStore {
       this.db.run('ALTER TABLE fleet ADD COLUMN last_attached INTEGER');
     }
 
+    if (!fleetColumns.has('agent')) {
+      this.db.run("ALTER TABLE fleet ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude'");
+    }
+
     if (legacyFleetPath !== undefined) {
       this.adoptLegacyFleet(legacyFleetPath);
     }
@@ -67,23 +84,25 @@ export class StateStore {
     const rows = this.db
       .query<
         {
-          claude_id: string;
+          agent_session_id: string;
           name: string;
           cwd: string;
           pinned: number;
           last_attached: number | null;
+          agent: string | null;
         },
         []
-      >('SELECT claude_id, name, cwd, pinned, last_attached FROM fleet')
+      >('SELECT agent_session_id, name, cwd, pinned, last_attached, agent FROM fleet')
       .all();
 
     const entries: FleetEntry[] = [];
 
     for (const row of rows) {
       entries.push({
-        claudeId: row.claude_id,
+        agentSessionID: row.agent_session_id,
         name: row.name,
         cwd: row.cwd,
+        agent: toAgentKind(row.agent),
         ...(row.pinned === 0 ? {} : { pinned: true }),
         ...(row.last_attached === null ? {} : { lastAttachedAt: row.last_attached }),
       });
@@ -109,13 +128,20 @@ export class StateStore {
       this.db.run('DELETE FROM fleet');
 
       const insert = this.db.query(
-        'INSERT OR REPLACE INTO fleet (claude_id, name, cwd, pinned, last_attached) VALUES (?1, ?2, ?3, ?4, ?5)',
+        'INSERT OR REPLACE INTO fleet (agent_session_id, name, cwd, pinned, last_attached, agent) VALUES (?1, ?2, ?3, ?4, ?5, ?6)',
       );
 
       for (const entry of all) {
         const pinned = entry.pinned === true ? 1 : 0;
 
-        insert.run(entry.claudeId, entry.name, entry.cwd, pinned, entry.lastAttachedAt ?? null);
+        insert.run(
+          entry.agentSessionID,
+          entry.name,
+          entry.cwd,
+          pinned,
+          entry.lastAttachedAt ?? null,
+          entry.agent,
+        );
       }
     });
 
@@ -124,7 +150,7 @@ export class StateStore {
 
   recordEvent(e: HookEvent): void {
     const rawMessage = e.payload['message'];
-    const rawSessionID = e.payload['session_id'];
+    const rawSessionID = e.payload['session_id'] ?? e.payload['sessionId'];
     const message = typeof rawMessage === 'string' ? rawMessage : null;
     const sessionID = typeof rawSessionID === 'string' ? rawSessionID : null;
 
@@ -151,6 +177,22 @@ export class StateStore {
     return rows.map((row) => row.cwd);
   }
 
+  loadLastUsedAgent(): AgentKind {
+    const row = this.db
+      .query<{ value: string }, []>("SELECT value FROM prefs WHERE key = 'last_used_agent'")
+      .get();
+
+    return toAgentKind(row?.value);
+  }
+
+  writeLastUsedAgent(agent: AgentKind): void {
+    this.db
+      .query(
+        'INSERT INTO prefs (key, value) VALUES (?1, ?2) ON CONFLICT(key) DO UPDATE SET value = ?2',
+      )
+      .run('last_used_agent', agent);
+  }
+
   stop(): void {
     this.db.close();
   }
@@ -169,13 +211,15 @@ export class StateStore {
         return;
       }
 
-      const entries = parsed.filter(
-        (entry): entry is FleetEntry =>
-          isRecord(entry) &&
-          typeof entry['name'] === 'string' &&
-          typeof entry['cwd'] === 'string' &&
-          typeof entry['claudeId'] === 'string',
-      );
+      const entries: FleetEntry[] = [];
+
+      for (const entry of parsed) {
+        const parsedEntry = parseFleetEntry(entry);
+
+        if (parsedEntry !== undefined) {
+          entries.push(parsedEntry);
+        }
+      }
 
       this.writeFleet(entries);
     } catch {}

package/src/ui.ts

@@ -1,4 +1,6 @@
+import type { AgentKind } from './agent-adapter';
 import { formatDir } from './dirs';
+import { formatOverlayAgentMark } from './format-overlay-agent-mark';
 import { RESET_INPUT_MODES } from './reset-input-modes';
 import { PINNED_GROUP_KEY } from './sessions';
 import type { SessionState } from './sessions';
@@ -159,8 +161,9 @@ function dimRow(width: number, text: string): Row {
 // Selection-dependent hints need the liveness facts of each row.
 export interface OverlaySessionView extends SessionView {
   readonly alive: boolean;
-  readonly kind: 'pty' | 'jsonl';
+  readonly kind: 'pty' | 'headless';
   readonly resumable: boolean;
+  readonly agent: AgentKind;
   readonly pinned: boolean;
   readonly repoRoot: string;
 }
@@ -202,14 +205,18 @@ export function drawOverlay(view: OverlayView) {
     const name = truncate(s.name, 16).padEnd(16);
     const state = STATE_LABEL[s.state].padEnd(9);
     const dir = view.grouped ? '' : ` ${truncate(formatDir(s.cwd), 18).padEnd(18)}`;
-    const msgWidth = Math.max(4, width - 4 - 3 - 17 - 10 - (view.grouped ? 0 : 19));
+    const msgWidth = Math.max(4, width - 4 - 4 - 17 - 10 - (view.grouped ? 0 : 19));
     const msg = truncate(s.lastMsg, msgWidth).padEnd(msgWidth);
     const unread = s.unread ? `${ESC}[1;33m!${ESC}[0m` : ' ';
     const pin = s.pinned ? `${ESC}[93m⋆${ESC}[0m` : ' ';
+    const mark = formatOverlayAgentMark(s.agent);
+    const styledMark = mark === 'g' ? `${ESC}[90m${mark}${ESC}[0m` : mark;
     const body = `${name} ${state}${dir} ${msg}`;
     const styledBody = sel ? `${ESC}[7m${body}${ESC}[0m` : body;
 
-    rowsList.push(boxRow(width, `${GLYPH[s.state]}${unread}${pin}${styledBody}`, 3 + body.length));
+    rowsList.push(
+      boxRow(width, `${GLYPH[s.state]}${unread}${pin}${styledMark}${styledBody}`, 4 + body.length),
+    );
   }
 
   rowsList.push(boxDivider(width));
@@ -245,15 +252,15 @@ export function drawOverlay(view: OverlayView) {
 const GLOBAL_HINT = 'g groups · n new · ? keys';
 
 // Only the actions valid for the selected row appear; the full reference
-// lives behind ?.
-function buildOverlayHint(s: OverlaySessionView | undefined): string {
+// lives behind ?. Grok has no headless handoff, so H is omitted there.
+export function buildOverlayHint(s: OverlaySessionView | undefined): string {
   if (s === undefined) {
     return GLOBAL_HINT;
   }
 
   const actions: string[] = [];
 
-  if (s.kind === 'jsonl' && s.alive) {
+  if (s.kind === 'headless' && s.alive) {
     actions.push('P reattach', 'K kill');
   } else if (s.alive) {
     actions.push('⏎ attach');
@@ -262,7 +269,11 @@ function buildOverlayHint(s: OverlaySessionView | undefined): string {
       actions.push('a ack');
     }
 
-    actions.push('H headless', 'y yank', 'Y eject', 'K kill');
+    if (s.agent === 'claude') {
+      actions.push('H headless');
+    }
+
+    actions.push('y yank', 'Y eject', 'K kill');
   } else {
     if (s.resumable) {
       actions.push('P revive', 'y yank');
@@ -285,13 +296,14 @@ export function drawHelp() {
     '⏎  attach the selected session',
     '⇥  attach the most urgent needs-you, else latest done',
     'a  ack its notification without attaching',
-    'H  eject to a headless run',
+    'H  eject to a headless run (Claude only)',
     'P  revive a dead or headless session',
     'y  yank the resume command to the clipboard',
     'Y  yank the resume command, then kill here',
     'K  kill (K again on a dead session forgets it)',
     'p  pin or unpin — pinned sessions stay on top',
     'g  toggle grouping by repository',
+    '    Grok rows show a dim g after the pin mark',
     'n  new session',
     'r  adopt an external session',
     '/  filter · ↑↓/jk move · q quit',
@@ -359,10 +371,10 @@ export function drawHome(fleetCount = 0, leaderLabel = '^Space') {
   out(ansi.clear + ansi.hideCursor);
 
   const msgs = [
-    'atc — control tower for claude sessions',
+    'atc — control tower for Claude and Grok sessions',
     '',
     'n       spawn a session',
-    'r       adopt an existing session (claude --resume)',
+    'r       adopt an existing session',
     ...(fleetCount > 0 ? [`R       restore last fleet (${fleetCount} sessions)`] : []),
     `${leaderLabel.padEnd(7)} session list`,
     'q       quit',