@zgeoff/atc 0.1.8 → 0.1.10

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,7 +16,7 @@ interface SpawnParams {
   readonly rows: number;
   readonly resume: boolean | string;
   readonly namedBy: 'user' | 'auto';
-  readonly group?: string;
+  readonly agent: AgentKind;
 }
 
 export interface DaemonContext {
@@ -23,9 +24,11 @@ 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, group?: string) => boolean;
+  readonly updateSession: (id: string, name?: string, pinned?: boolean) => boolean;
   readonly quitDaemon: () => void;
   readonly ackSession: (id: string) => boolean;
   readonly buildResumeCommand: (id: string) => string | null;
@@ -225,9 +228,9 @@ export class DaemonConnection {
       case 'session.update': {
         const sessionID = typeof req.p?.['session'] === 'string' ? req.p['session'] : '';
         const name = typeof req.p?.['name'] === 'string' ? req.p['name'] : undefined;
-        const group = typeof req.p?.['group'] === 'string' ? req.p['group'] : undefined;
+        const pinned = typeof req.p?.['pinned'] === 'boolean' ? req.p['pinned'] : undefined;
 
-        if (this.ctx.updateSession(sessionID, name, group)) {
+        if (this.ctx.updateSession(sessionID, name, pinned)) {
           this.sendOk(req.id, {});
         } else {
           this.sendErr(req.id, 'no_such_session', `no session '${sessionID}'`);
@@ -270,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,
@@ -370,7 +373,21 @@ export class DaemonConnection {
       resume = rawResume;
     }
 
-    const group = typeof req.p?.['group'] === 'string' ? req.p['group'] : '';
+    const rawAgent = req.p?.['agent'];
+
+    if (rawAgent !== undefined && rawAgent !== 'claude' && rawAgent !== 'grok') {
+      this.sendErr(req.id, 'bad_args', "session.spawn agent must be 'claude' or 'grok'");
+
+      return;
+    }
+
+    const agent: AgentKind = rawAgent === 'grok' ? 'grok' : 'claude';
+
+    if (this.ctx.findAdapter(agent) === null) {
+      this.sendErr(req.id, 'unsupported', `no adapter for agent '${agent}'`);
+
+      return;
+    }
 
     const session = this.ctx.spawnSession({
       cwd,
@@ -380,7 +397,7 @@ export class DaemonConnection {
       rows: typeof req.p?.['rows'] === 'number' ? req.p['rows'] : 24,
       resume,
       namedBy: name === '' ? 'auto' : 'user',
-      ...(group === '' ? {} : { group }),
+      agent,
     });
 
     this.sendOk(req.id, { session });
@@ -521,6 +538,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,9 +395,11 @@ 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 }),
-        ...(s.group === undefined ? {} : { group: s.group }),
+        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,
       }),
       renamed: () => ({
         v: PROTOCOL_V,
@@ -438,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 = {
@@ -456,16 +442,19 @@ 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, p.group);
+      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);
 
       return getDescriptor(mgr, s.id);
     },
-    updateSession: (id, name, group) => mgr.updateSession(id, name, group),
+    updateSession: (id, name, pinned) => mgr.updateSession(id, name, pinned),
     quitDaemon: () => {
       // The ok response for the quit request must flush before the sockets
       // close under it.
@@ -486,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';
       }
 
@@ -588,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';
         }
@@ -618,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();
@@ -632,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
@@ -748,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,9 @@
+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 {
+  return agent === 'grok' ? 'g' : ' ';
+}

package/src/grok-adapter.ts

@@ -0,0 +1,274 @@
+import { existsSync, readFileSync, readdirSync } 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 { normalizeHookEventName } from './normalize-hook-event';
+import { isRecord } from './report';
+
+interface GrokSessionHookState {
+  latestPromptID?: string;
+  lastKind: AdapterEvent['kind'];
+}
+
+/**
+ * The Grok Build adapter: spawn arguments, hook payload mapping,
+ * resume semantics, and summary.json name-pulling.
+ */
+export class GrokAdapter implements AgentAdapter {
+  readonly kind = 'grok';
+
+  // Grok has no headless handoff.
+  readonly headlessRunner = null;
+
+  // Grok's hooks are authoritative; no screen heuristics needed.
+  readonly screenDetector = null;
+
+  private readonly config: Config;
+
+  private readonly hookState = new Map<string, GrokSessionHookState>();
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  planSpawn(opts: SpawnOptions): SpawnPlan {
+    return {
+      bin: this.config.grokBin,
+      args: [
+        ...this.config.grokArgs.filter((arg) => arg !== '--leader' && arg !== '--no-leader'),
+        '--no-leader',
+        ...(typeof opts.resume === 'string' ? ['--resume', opts.resume] : []),
+        ...(opts.prompt === '' ? [] : [opts.prompt]),
+      ],
+    };
+  }
+
+  normalizeHook(e: HookEvent): AdapterEvent {
+    const sessionID = e.payload['sessionId'];
+    const cwd = e.payload['cwd'];
+    const promptID = e.payload['promptId'];
+    const subagentType = e.payload['subagentType'];
+
+    const base: AdapterEvent = {
+      kind: 'heartbeat',
+      ...(typeof sessionID === 'string' ? { agentSessionID: sessionID } : {}),
+    };
+
+    const named: AdapterEvent = {
+      ...base,
+      ...(typeof sessionID === 'string' && typeof cwd === 'string'
+        ? { nameSource: buildGrokNameSource(sessionID, cwd) }
+        : {}),
+    };
+
+    if (typeof subagentType === 'string' && subagentType !== '') {
+      return this.emitHook(e.atcId, { ...base, kind: 'heartbeat' });
+    }
+
+    const event = normalizeHookEventName(e.event);
+    const prior = this.hookState.get(e.atcId);
+
+    const stale =
+      typeof promptID === 'string' &&
+      prior?.latestPromptID !== undefined &&
+      promptID !== prior.latestPromptID;
+
+    switch (event) {
+      case 'SessionStart': {
+        return this.emitHook(e.atcId, { ...named, kind: 'started' });
+      }
+      case 'UserPromptSubmit': {
+        const prompt = e.payload['prompt'];
+        const preview = typeof prompt === 'string' ? prompt.slice(0, 80) : '';
+        const submittedID = typeof promptID === 'string' ? promptID : undefined;
+
+        return this.emitHook(
+          e.atcId,
+          {
+            ...named,
+            kind: 'prompt-submitted',
+            ...(preview === '' ? {} : { message: preview, detail: truncateDetail(preview) }),
+          },
+          submittedID,
+        );
+      }
+      case 'Notification': {
+        const notificationType = e.payload['notificationType'];
+        const message = e.payload['message'];
+
+        if (notificationType === 'permission_prompt') {
+          return this.emitHook(e.atcId, {
+            ...base,
+            kind: 'needs-input',
+            ...(typeof message === 'string' && message !== ''
+              ? { message, detail: truncateDetail(message) }
+              : {}),
+          });
+        }
+
+        if (notificationType === 'idle_prompt') {
+          const kind = prior?.lastKind === 'needs-input' ? 'heartbeat' : 'turn-done';
+
+          return this.emitHook(e.atcId, { ...named, kind });
+        }
+
+        return this.emitHook(e.atcId, base);
+      }
+      case 'Stop': {
+        if (e.payload['reason'] !== 'end_turn' || stale) {
+          return this.emitHook(e.atcId, base);
+        }
+
+        return this.emitHook(e.atcId, buildTurnDoneEvent(named, e.payload));
+      }
+      case 'StopFailure':
+      case 'StopCancelled': {
+        if (stale) {
+          return this.emitHook(e.atcId, base);
+        }
+
+        return this.emitHook(e.atcId, buildTurnDoneEvent(named, e.payload));
+      }
+      case 'SessionEnd': {
+        this.hookState.delete(e.atcId);
+
+        return { ...base, kind: 'ended' };
+      }
+      default: {
+        return this.emitHook(e.atcId, base);
+      }
+    }
+  }
+
+  loadName(source: string, namedBy: 'user' | 'auto' | 'agent'): Promise<NameUpdate | null> {
+    const parsed = readSummary(source) ?? readSummary(findGrokSummary(source));
+
+    if (parsed === null) {
+      return Promise.resolve(null);
+    }
+
+    const generated = parsed['generated_title'];
+    const summary = parsed['session_summary'];
+    const title = typeof generated === 'string' ? generated : '';
+    const sessionSummary = typeof summary === 'string' ? summary : '';
+
+    if (parsed['title_is_manual'] === true && title !== '') {
+      return Promise.resolve({ name: title, namedBy: 'agent' });
+    }
+
+    if (namedBy !== 'user' && title !== '') {
+      return Promise.resolve({ name: title });
+    }
+
+    if (namedBy !== 'user' && sessionSummary !== '') {
+      return Promise.resolve({ name: sessionSummary });
+    }
+
+    return Promise.resolve(null);
+  }
+
+  canResume(session: ResumeCheck): boolean {
+    return session.agentSessionID !== undefined;
+  }
+
+  // Shell command that re-opens this session outside atc (or anywhere).
+  buildResumeCommand(cwd: string, agentSessionID: string | undefined): string | null {
+    const resume = agentSessionID === undefined ? 'grok' : `grok --resume ${agentSessionID}`;
+    const quoted = cwd.replaceAll("'", String.raw`'\''`);
+
+    return `cd '${quoted}' && ${resume}`;
+  }
+
+  private emitHook(atcID: string, event: Readonly<AdapterEvent>, promptID?: string): AdapterEvent {
+    const prior = this.hookState.get(atcID);
+    const latestPromptID = promptID ?? prior?.latestPromptID;
+
+    const tracked =
+      event.kind === 'needs-input' ||
+      event.kind === 'prompt-submitted' ||
+      event.kind === 'turn-done'
+        ? event.kind
+        : (prior?.lastKind ?? event.kind);
+
+    this.hookState.set(atcID, {
+      lastKind: tracked,
+      ...(latestPromptID === undefined ? {} : { latestPromptID }),
+    });
+
+    return event;
+  }
+}
+
+function resolveGrokHome(): string {
+  const home = process.env['GROK_HOME'];
+
+  return home !== undefined && home !== '' ? home : join(homedir(), '.grok');
+}
+
+function buildGrokNameSource(sessionID: string, cwd: string): string {
+  return join(resolveGrokHome(), 'sessions', encodeURIComponent(cwd), sessionID, 'summary.json');
+}
+
+function buildTurnDoneEvent(
+  named: Readonly<AdapterEvent>,
+  payload: Readonly<Record<string, unknown>>,
+): AdapterEvent {
+  const lastMessage = payload['lastAssistantMessage'];
+
+  return {
+    ...named,
+    kind: 'turn-done',
+    ...(typeof lastMessage === 'string' && lastMessage !== ''
+      ? { detail: truncateDetail(lastMessage) }
+      : {}),
+  };
+}
+
+function readSummary(source: string | null): Record<string, unknown> | null {
+  if (source === null) {
+    return null;
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(source, 'utf8'));
+
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function findGrokSummary(source: string): string | null {
+  const sessionID = source.split('/').at(-2);
+
+  if (sessionID === undefined || sessionID === '') {
+    return null;
+  }
+
+  const root = join(resolveGrokHome(), 'sessions');
+
+  try {
+    for (const group of readdirSync(root)) {
+      const candidate = join(root, group, sessionID, 'summary.json');
+
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  } catch {}
+
+  return null;
+}
+
+function truncateDetail(text: string): string {
+  return text.length <= 600 ? text : `${text.slice(0, 599)}…`;
+}

package/src/hook-report.ts

@@ -1,9 +1,11 @@
+import { normalizeHookEventName } from './normalize-hook-event';
 import { isRecord, sendReport } from './report';
 
 /**
- * Runs as a Claude Code hook inside wrangled sessions. Reads the hook event
- * from stdin and forwards it to the atc unix socket. Always exits 0 so it
- * never blocks the session it reports on.
+ * Runs as a hook inside wrangled sessions. Reads the hook event from stdin
+ * (Claude snake_case keys or Grok camelCase keys) and forwards a PascalCase
+ * event name to the atc unix socket. Always exits 0 so it never blocks the
+ * session it reports on.
  */
 export async function runHookReport(): Promise<void> {
   const sock = process.env['ATC_SOCKET'];
@@ -22,7 +24,9 @@ export async function runHookReport(): Promise<void> {
       }
     } catch {}
 
-    const line = `${JSON.stringify({ atcId, event: payload['hook_event_name'], payload })}\n`;
+    const rawName = payload['hook_event_name'] ?? payload['hookEventName'];
+    const event = typeof rawName === 'string' ? normalizeHookEventName(rawName) : rawName;
+    const line = `${JSON.stringify({ atcId, event, payload })}\n`;
 
     await sendReport(sock, line, 2000);
   }