@zgeoff/atc 0.1.9 → 0.1.11

package/src/codex-adapter.ts

@@ -0,0 +1,178 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type {
+  AdapterEvent,
+  AgentAdapter,
+  NameUpdate,
+  ResumeCheck,
+  SpawnOptions,
+  SpawnPlan,
+} from './agent-adapter';
+import type { Config } from './config';
+import type { HookEvent } from './hooks';
+import { isRecord } from './report';
+
+/**
+ * The Codex CLI adapter: spawn arguments, hook payload mapping, resume
+ * semantics, and session_index.jsonl name-pulling. Hooks are a user-installed
+ * entry in the Codex hook config (`atc codex-hooks` prints it) that the user
+ * trusts once in the Codex TUI; atc never writes into the user's Codex config.
+ */
+export class CodexAdapter implements AgentAdapter {
+  readonly kind = 'codex';
+
+  // Codex has no headless handoff.
+  readonly headlessRunner = null;
+
+  // Codex's hooks are authoritative; no screen heuristics needed.
+  readonly screenDetector = null;
+
+  private readonly config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  planSpawn(opts: SpawnOptions): SpawnPlan {
+    return {
+      bin: this.config.codexBin,
+      args: [
+        ...this.config.codexArgs,
+
+        // Bare resume opens Codex's own session picker; an id resumes that
+        // session directly. Both accept a prompt afterwards.
+        ...(opts.resume === true ? ['resume'] : []),
+        ...(typeof opts.resume === 'string' ? ['resume', opts.resume] : []),
+        ...(opts.prompt === '' ? [] : [opts.prompt]),
+      ],
+    };
+  }
+
+  normalizeHook(e: HookEvent): AdapterEvent {
+    const sessionID = e.payload['session_id'];
+    const transcript = e.payload['transcript_path'];
+
+    const base: AdapterEvent = {
+      kind: 'heartbeat',
+      ...(typeof sessionID === 'string' ? { agentSessionID: sessionID } : {}),
+    };
+
+    const named: AdapterEvent = {
+      ...base,
+      ...(typeof sessionID === 'string' ? { nameSource: sessionID } : {}),
+      ...(typeof transcript === 'string' ? { transcriptSource: transcript } : {}),
+    };
+
+    switch (e.event) {
+      case 'SessionStart': {
+        return { ...named, kind: 'started' };
+      }
+      case 'PermissionRequest': {
+        const toolName = e.payload['tool_name'];
+
+        const message =
+          typeof toolName === 'string' && toolName !== ''
+            ? `waiting for approval: ${toolName}`
+            : 'waiting for approval';
+
+        return { ...base, kind: 'needs-input', message, detail: message };
+      }
+      case 'UserPromptSubmit': {
+        const prompt = e.payload['prompt'];
+        const preview = typeof prompt === 'string' ? prompt.slice(0, 80) : '';
+
+        return {
+          ...named,
+          kind: 'prompt-submitted',
+          ...(preview === '' ? {} : { message: preview, detail: truncateDetail(preview) }),
+        };
+      }
+      case 'Stop': {
+        const lastMessage = e.payload['last_assistant_message'];
+
+        return {
+          ...named,
+          kind: 'turn-done',
+          ...(typeof lastMessage === 'string' && lastMessage !== ''
+            ? { detail: truncateDetail(lastMessage) }
+            : {}),
+        };
+      }
+      case 'SessionEnd': {
+        return { ...base, kind: 'ended' };
+      }
+      default: {
+        return base;
+      }
+    }
+  }
+
+  // Codex records session titles in session_index.jsonl; the index does not
+  // say whether a title was set by /rename or auto-generated, so a title
+  // never overrides a user-typed name.
+  loadName(source: string, namedBy: 'user' | 'auto' | 'agent'): Promise<NameUpdate | null> {
+    if (namedBy === 'user') {
+      return Promise.resolve(null);
+    }
+
+    const index = join(resolveCodexHome(), 'session_index.jsonl');
+    let text: string;
+
+    try {
+      text = readFileSync(index, 'utf8');
+    } catch {
+      return Promise.resolve(null);
+    }
+
+    let name: string | undefined;
+
+    for (const line of text.split('\n')) {
+      if (line.trim() === '' || !line.includes(source)) {
+        continue;
+      }
+
+      try {
+        const parsed: unknown = JSON.parse(line);
+
+        if (
+          isRecord(parsed) &&
+          parsed['id'] === source &&
+          typeof parsed['thread_name'] === 'string'
+        ) {
+          name = parsed['thread_name'];
+        }
+      } catch {}
+    }
+
+    const update = name === undefined || name === '' ? null : { name };
+
+    return Promise.resolve(update);
+  }
+
+  canResume(session: ResumeCheck): boolean {
+    if (session.transcriptSource === undefined) {
+      return true;
+    }
+
+    return existsSync(session.transcriptSource);
+  }
+
+  // Shell command that re-opens this session outside atc (or anywhere).
+  buildResumeCommand(cwd: string, agentSessionID: string | undefined): string | null {
+    const resume = agentSessionID === undefined ? 'codex resume' : `codex resume ${agentSessionID}`;
+    const quoted = cwd.replaceAll("'", String.raw`'\''`);
+
+    return `cd '${quoted}' && ${resume}`;
+  }
+}
+
+function resolveCodexHome(): string {
+  const home = process.env['CODEX_HOME'];
+
+  return home !== undefined && home !== '' ? home : join(homedir(), '.codex');
+}
+
+function truncateDetail(text: string): string {
+  return text.length <= 600 ? text : `${text.slice(0, 599)}…`;
+}

package/src/collect-clean-env.ts

@@ -1,8 +1,8 @@
 /**
- * The process environment with any enclosing Claude Code session scrubbed
- * out. A claude spawned with those variables intact behaves as a child of
- * the enclosing session — its transcript lands inside the parent's instead
- * of its own project directory, which breaks resume and handoff.
+ * The process environment with any enclosing Claude or Grok session
+ * scrubbed out. A child that inherits those variables behaves as part of
+ * the parent session — Claude transcripts nest, and Grok joins the
+ * parent's in-process dashboard — which breaks resume and isolation.
  */
 export function collectCleanEnv(
   extra: Readonly<Record<string, string>> = {},
@@ -10,7 +10,7 @@ export function collectCleanEnv(
   const env: Record<string, string> = {};
 
   for (const [key, value] of Object.entries(process.env)) {
-    if (value === undefined || key === 'CLAUDECODE' || key.startsWith('CLAUDE_CODE_')) {
+    if (value === undefined || isParentSessionKey(key)) {
       continue;
     }
 
@@ -19,3 +19,33 @@ export function collectCleanEnv(
 
   return { ...env, ...extra };
 }
+
+const GROK_PARENT_KEYS = new Set([
+  'GROK_SESSION_ID',
+  'GROK_LEADER_SOCKET',
+  'GROK_LEADER_LOG',
+  'GROK_HOOK_EVENT',
+  'GROK_HOOK_NAME',
+  'GROK_WORKSPACE_ROOT',
+  'GROK_EVENT',
+  'GROK_MESSAGE',
+  'GROK_PLUGIN_ROOT',
+  'GROK_PLUGIN_DATA',
+  'GROK_SESSION_RESTORED',
+  'GROK_AGENT_METADATA',
+  'GROK_INIT_STATE_MARKER__',
+  'GROK_BASH_STATE_START__',
+  'GROK_BASH_STATE_END__',
+  'GROK_ZSH_STATE_START__',
+  'GROK_ZSH_STATE_END__',
+  'GROK_INSIDE_BWRAP',
+]);
+
+function isParentSessionKey(key: string): boolean {
+  return (
+    key === 'CLAUDECODE' ||
+    key.startsWith('CLAUDE_CODE_') ||
+    key.startsWith('CODEX_SANDBOX') ||
+    GROK_PARENT_KEYS.has(key)
+  );
+}

package/src/config.ts

@@ -6,6 +6,10 @@ import { isRecord } from './report';
 export interface Config {
   claudeBin: string;
   claudeArgs: string[];
+  grokBin: string;
+  grokArgs: string[];
+  codexBin: string;
+  codexArgs: string[];
   leader: LeaderKey;
 }
 
@@ -17,6 +21,10 @@ interface LeaderKey {
 const DEFAULTS: Config = {
   claudeBin: 'claude',
   claudeArgs: [],
+  grokBin: 'grok',
+  grokArgs: [],
+  codexBin: 'codex',
+  codexArgs: [],
   leader: { code: 0, label: '^Space' },
 };
 
@@ -57,11 +65,24 @@ export function loadConfig(): Config {
       ? parsed['claudeArgs'].filter((a): a is string => typeof a === 'string')
       : DEFAULTS.claudeArgs;
 
+    const grokBin = typeof parsed['grokBin'] === 'string' ? parsed['grokBin'] : DEFAULTS.grokBin;
+
+    const grokArgs = Array.isArray(parsed['grokArgs'])
+      ? parsed['grokArgs'].filter((a): a is string => typeof a === 'string')
+      : DEFAULTS.grokArgs;
+
+    const codexBin =
+      typeof parsed['codexBin'] === 'string' ? parsed['codexBin'] : DEFAULTS.codexBin;
+
+    const codexArgs = Array.isArray(parsed['codexArgs'])
+      ? parsed['codexArgs'].filter((a): a is string => typeof a === 'string')
+      : DEFAULTS.codexArgs;
+
     const leader =
       (typeof parsed['leader'] === 'string' ? decodeLeader(parsed['leader']) : null) ??
       DEFAULTS.leader;
 
-    return { claudeBin, claudeArgs, leader };
+    return { claudeBin, claudeArgs, grokBin, grokArgs, codexBin, codexArgs, leader };
   } catch {
     return { ...DEFAULTS };
   }

package/src/daemon-connection.ts

@@ -1,4 +1,5 @@
 import { basename } from 'node:path';
+import type { AgentAdapter, AgentKind } from './agent-adapter';
 import type { Dims } from './attach-registry';
 import { OutboundQueue } from './outbound-queue';
 import type { SocketWriter } from './outbound-queue';
@@ -15,6 +16,7 @@ interface SpawnParams {
   readonly rows: number;
   readonly resume: boolean | string;
   readonly namedBy: 'user' | 'auto';
+  readonly agent: AgentKind;
 }
 
 export interface DaemonContext {
@@ -22,6 +24,8 @@ export interface DaemonContext {
   readonly collectSessions: () => SessionDescriptor[];
   readonly collectSpawnDirs: () => string[];
   readonly collectFleet: () => FleetEntry[];
+  readonly loadLastUsedAgent: () => AgentKind;
+  readonly findAdapter: (kind: AgentKind) => AgentAdapter | null;
   readonly spawnSession: (p: SpawnParams) => SessionDescriptor;
   readonly killSession: (id: string) => boolean;
   readonly updateSession: (id: string, name?: string, pinned?: boolean) => boolean;
@@ -269,7 +273,7 @@ export class DaemonConnection {
         if (result === 'ok') {
           this.sendOk(req.id, {});
         } else if (result === 'unsupported') {
-          this.sendErr(req.id, 'unsupported', 'this daemon has no headless runner');
+          this.sendErr(req.id, 'unsupported', "this session's agent has no headless handoff");
         } else if (result === 'no_transcript') {
           this.sendErr(
             req.id,
@@ -369,6 +373,27 @@ export class DaemonConnection {
       resume = rawResume;
     }
 
+    const rawAgent = req.p?.['agent'];
+
+    if (
+      rawAgent !== undefined &&
+      rawAgent !== 'claude' &&
+      rawAgent !== 'grok' &&
+      rawAgent !== 'codex'
+    ) {
+      this.sendErr(req.id, 'bad_args', "session.spawn agent must be 'claude', 'grok', or 'codex'");
+
+      return;
+    }
+
+    const agent: AgentKind = rawAgent === 'grok' || rawAgent === 'codex' ? rawAgent : 'claude';
+
+    if (this.ctx.findAdapter(agent) === null) {
+      this.sendErr(req.id, 'unsupported', `no adapter for agent '${agent}'`);
+
+      return;
+    }
+
     const session = this.ctx.spawnSession({
       cwd,
       name: name === '' ? basename(cwd) : name,
@@ -377,6 +402,7 @@ export class DaemonConnection {
       rows: typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24,
       resume,
       namedBy: name === '' ? 'auto' : 'user',
+      agent,
     });
 
     this.sendOk(req.id, { session });
@@ -517,6 +543,7 @@ export class DaemonConnection {
     this.sendOk(req.id, {
       daemon: this.ctx.build,
       limits: { maxLine: MAX_LINE, maxChunk: MAX_CHUNK },
+      lastUsedAgent: this.ctx.loadLastUsedAgent(),
     });
 
     return true;

package/src/daemon.ts

@@ -1,5 +1,5 @@
-import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
-import type { AgentAdapter } from './agent-adapter';
+import { unlinkSync, writeFileSync } from 'node:fs';
+import type { AgentAdapter, AgentKind } from './agent-adapter';
 import { AttachRegistry } from './attach-registry';
 import type { Dims } from './attach-registry';
 import { DaemonConnection } from './daemon-connection';
@@ -21,6 +21,10 @@ export interface DaemonOptions {
   readonly build: string;
   readonly adapter: AgentAdapter;
 
+  // Optional per-kind adapters. Lookup never falls back across kinds: a
+  // grok session with no grok adapter is unsupported, not a Claude spawn.
+  readonly adapters?: Partial<Readonly<Record<AgentKind, AgentAdapter>>>;
+
   // SQLite path for daemon state; a fleet.json at legacyFleetPath seeds the
   // fleet table once so upgrading keeps the restorable fleet.
   readonly dbPath: string;
@@ -35,11 +39,6 @@ export interface DaemonOptions {
   // Outbound queue capacity per client; small values force desync in tests.
   readonly queueBytes?: number;
 
-  // Runs one headless turn over a session; the real one drives the Agent
-  // SDK, which spawns real claude — a boundary tests never cross. Absent
-  // means eject is unsupported.
-  readonly headlessRunner?: HeadlessRunner;
-
   // How long an eject waits for the dying terminal to report SessionEnd
   // before starting the headless run anyway.
   readonly ejectSettleMs?: number;
@@ -56,24 +55,6 @@ export interface DaemonOptions {
   readonly onQuit?: () => void;
 }
 
-interface HeadlessRunRequest {
-  readonly cwd: string;
-  readonly prompt: string;
-  readonly resume?: string;
-  readonly permissionMode?: string;
-}
-
-interface HeadlessRunEvents {
-  readonly onOutput: (text: string) => void;
-  readonly onDone: (summary: string) => void;
-  readonly onNeedsYou: (msg: string) => void;
-}
-
-export type HeadlessRunner = (
-  opts: HeadlessRunRequest,
-  hooks: HeadlessRunEvents,
-) => { readonly stop: () => void };
-
 export interface DaemonHandle {
   readonly stop: () => void;
 }
@@ -95,12 +76,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   }
 
   const store = new StateStore(opts.dbPath, opts.legacyFleetPath);
-
-  const mgr =
-    opts.statusPath === undefined
-      ? new SessionManager(opts.adapter, store)
-      : new SessionManager(opts.adapter, store, opts.statusPath);
-
+  const mgr = new SessionManager(opts.adapter, store, opts.statusPath, opts.adapters ?? {});
   const clients = new Set<DaemonConnection>();
 
   const emitEvent = (event: EventMsg) => {
@@ -165,10 +141,10 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   };
 
   const startHeadlessTurn = (sessionID: string, prompt: string): boolean => {
-    const runner = opts.headlessRunner;
     const s = mgr.sessions.find((x) => x.id === sessionID);
+    const runner = s === undefined ? null : (mgr.findAdapter(s.agent)?.headlessRunner ?? null);
 
-    if (runner === undefined || s === undefined || headlessRuns.has(sessionID)) {
+    if (s === undefined || runner === null || headlessRuns.has(sessionID)) {
       return false;
     }
 
@@ -178,7 +154,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       {
         cwd: s.cwd,
         prompt,
-        ...(s.claudeId === undefined ? {} : { resume: s.claudeId }),
+        ...(s.agentSessionID === undefined ? {} : { resume: s.agentSessionID }),
         permissionMode: 'auto',
       },
       {
@@ -211,11 +187,13 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   const resizeTimers = new Map<string, ReturnType<typeof setTimeout>>();
   const detectTimers = new Map<string, ReturnType<typeof setTimeout>>();
   const restoreTimers = new Set<ReturnType<typeof setTimeout>>();
+  const pendingLastUsed = new Set<string>();
 
   // The screen tier of the detector stack: once a session's output has
   // quiesced, judge the serialized screen and flip running/needs_you.
   const scheduleDetect = (sessionID: string) => {
-    const detector = opts.adapter.screenDetector;
+    const s = mgr.sessions.find((x) => x.id === sessionID);
+    const detector = s === undefined ? null : (mgr.findAdapter(s.agent)?.screenDetector ?? null);
 
     if (detector === null) {
       return;
@@ -306,7 +284,8 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   };
 
   const applyScreenJudgment = async (sessionID: string) => {
-    const detector = opts.adapter.screenDetector;
+    const s = mgr.sessions.find((x) => x.id === sessionID);
+    const detector = s === undefined ? null : (mgr.findAdapter(s.agent)?.screenDetector ?? null);
     const model = screens.get(sessionID);
 
     if (detector === null || model === undefined) {
@@ -416,8 +395,9 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
         unread: s.unread,
         lastMsg: s.lastMsg,
         kind: s.kind,
-        alive: s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited'),
-        ...(s.claudeId === undefined ? {} : { claudeId: s.claudeId }),
+        alive: s.pty !== null || (s.kind === 'headless' && s.state !== 'exited'),
+        ...(s.agentSessionID === undefined ? {} : { agentSessionID: s.agentSessionID }),
+        agent: s.agent,
         pinned: s.pinned,
         lastAttachedAt: s.lastAttachedAt,
       }),
@@ -439,17 +419,22 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       store.recordEvent(e);
     }
 
-    if (e.event === 'SessionEnd') {
+    const kind = mgr.applyHook(e);
+
+    if (kind === 'ended') {
       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') {
+    if (kind === 'started') {
       bootWaiters.get(e.atcId)?.();
-    }
+      const started = mgr.sessions.find((s) => s.id === e.atcId);
 
-    mgr.applyHook(e);
+      if (started !== undefined && pendingLastUsed.delete(started.id)) {
+        store.writeLastUsedAgent(started.agent);
+      }
+    }
   }, opts.reporterSocketPath);
 
   const ctx: DaemonContext = {
@@ -457,9 +442,12 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
     collectSessions: () => mgr.collectDescriptors(),
     collectSpawnDirs: () => store.collectSpawnDirs(),
     collectFleet: () => store.loadFleet(),
+    loadLastUsedAgent: () => store.loadLastUsedAgent(),
+    findAdapter: (kind) => mgr.findAdapter(kind),
     spawnSession: (p) => {
-      const s = mgr.spawn(p.cwd, p.name, p.prompt, p.cols, p.rows, p.resume, p.namedBy);
+      const s = mgr.spawn(p.cwd, p.name, p.prompt, p.cols, p.rows, p.resume, p.namedBy, p.agent);
 
+      pendingLastUsed.add(s.id);
       ptyDims.set(s.id, { cols: p.cols, rows: p.rows });
       screens.set(s.id, new ScreenModel(p.cols, p.rows));
       store.recordSpawnDir(p.cwd);
@@ -487,7 +475,15 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       return true;
     },
     ejectSession: (id, prompt) => {
-      if (opts.headlessRunner === undefined) {
+      const s = mgr.sessions.find((x) => x.id === id);
+
+      if (s === undefined) {
+        return 'missing';
+      }
+
+      const adapter = mgr.findAdapter(s.agent);
+
+      if (adapter === null || adapter.headlessRunner === null) {
         return 'unsupported';
       }
 
@@ -589,7 +585,7 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
         return 'missing';
       }
 
-      if (s.kind === 'jsonl') {
+      if (s.kind === 'headless') {
         if (headlessRuns.has(sessionID)) {
           return 'busy';
         }
@@ -619,11 +615,11 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
     getEffectiveDims: (sessionID) =>
       attachments.findEffectiveDims(sessionID) ?? ptyDims.get(sessionID) ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) => {
-      const hasSession = (claudeId: string) =>
+      const hasSession = (agentSessionID: string) =>
         mgr.sessions.some(
           (s) =>
-            s.claudeId === claudeId &&
-            (s.pty !== null || (s.kind === 'jsonl' && s.state !== 'exited')),
+            s.agentSessionID === agentSessionID &&
+            (s.pty !== null || (s.kind === 'headless' && s.state !== 'exited')),
         );
 
       const recency = store.collectFleetRecency();
@@ -633,9 +629,9 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
       // reported an event keep their stored order at the end.
       const entries = store
         .loadFleet()
-        .filter((entry) => !hasSession(entry.claudeId))
+        .filter((entry) => !hasSession(entry.agentSessionID))
         .toSorted((a, b) =>
-          (recency.get(b.claudeId) ?? '').localeCompare(recency.get(a.claudeId) ?? ''),
+          (recency.get(b.agentSessionID) ?? '').localeCompare(recency.get(a.agentSessionID) ?? ''),
         );
 
       // The whole fleet registers as terminal-less sessions up front, so the
@@ -749,18 +745,23 @@ export function startDaemon(opts: DaemonOptions): DaemonHandle {
   return { stop: stopDaemon };
 }
 
-// A session reporting a transcript path that does not exist on disk yet has
-// nothing to resume — claude exits immediately on such a resume, which
-// reads as the revive silently failing. A session that never reported a
-// path (foreign adapters) passes; the spawn itself will tell the truth.
 function hasResumableTranscript(mgr: SessionManager, id: string): boolean {
   const s = mgr.sessions.find((x) => x.id === id);
 
-  if (s === undefined || s.transcriptSource === undefined) {
-    return true;
+  if (s === undefined) {
+    return false;
+  }
+
+  const adapter = mgr.findAdapter(s.agent);
+
+  if (adapter === null) {
+    return false;
   }
 
-  return existsSync(s.transcriptSource);
+  return adapter.canResume({
+    ...(s.agentSessionID === undefined ? {} : { agentSessionID: s.agentSessionID }),
+    ...(s.transcriptSource === undefined ? {} : { transcriptSource: s.transcriptSource }),
+  });
 }
 
 function getDescriptor(mgr: SessionManager, id: string): SessionDescriptor {

package/src/format-overlay-agent-mark.ts

@@ -0,0 +1,17 @@
+import type { AgentKind } from './agent-adapter';
+
+/**
+ * The reserved overlay column after unread: a `g` for Grok, a space for
+ * Claude, so session names stay aligned across a mixed fleet.
+ */
+export function formatOverlayAgentMark(agent: AgentKind): string {
+  if (agent === 'grok') {
+    return 'g';
+  }
+
+  if (agent === 'codex') {
+    return 'x';
+  }
+
+  return ' ';
+}