@zgeoff/atc 0.1.8 → 0.1.10

package/README.md

@@ -2,9 +2,9 @@
   <h1>atc</h1>
 
   <p>
-    Control tower for Claude Code sessions: stock <code>claude</code> instances in PTYs behind a
-    keyboard-driven session list with hook-driven attention routing — no panes, no tiling, no
-    mouse.
+    Control tower for Claude Code and Grok Build sessions: stock <code>claude</code> and
+    <code>grok</code> instances in PTYs behind a keyboard-driven session list with hook-driven
+    attention routing — no panes, no tiling, no mouse.
   </p>
 
   <p>
@@ -27,7 +27,10 @@ atc
 ```
 
 Needs [Bun](https://bun.sh) (atc runs from source through it) and the `claude` CLI on your PATH.
-From a checkout, `bun src/cli.ts` runs the same thing.
+Grok sessions also need the `grok` CLI. From a checkout, `bun src/cli.ts` runs the same thing. atc
+is built to pair with [zoxide](https://github.com/ajeetdsouza/zoxide): the spawn directory picker
+feeds on its frecency list, so with zoxide installed every directory you visit is two keystrokes
+from a session. Without it the picker falls back to atc's own spawn history.
 
 The first invocation auto-spawns the daemon (`atc daemon` runs it in the foreground for systemd or
 debugging); the TUI is a thin client, so quitting or crashing it leaves every session running. Runs
@@ -35,47 +38,90 @@ fine nested inside zellij/tmux (give the pane locked mode so Ctrl-Space reaches
 
 ## Keys
 
-| Key             | Where          | Action                                                                                         |
-| --------------- | -------------- | ---------------------------------------------------------------------------------------------- |
-| leader          | anywhere       | toggle session overlay — `Ctrl-Space` by default, configurable (see Config)                    |
-| `n`             | home/overlay   | spawn: pick dir (zoxide + history, fuzzy) → name → optional group → optional first prompt      |
-| `r`             | home/overlay   | adopt: pick dir → name → `claude --resume` (Claude's session picker opens in the new PTY)      |
-| `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, 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        |
-| `P`             | overlay        | revive: a fresh terminal resumes a headless or killed session in place                         |
-| `y`             | overlay        | yank `cd <dir> && claude --resume <id>` to clipboard (OSC 52 + clip.exe/wl-copy/xclip)         |
-| `Y`             | overlay        | eject: yank the resume command, then kill the session here — paste it in any pane to take over |
-| `K`             | overlay        | kill selected (confirm with `y`) — the entry stays revivable with `P`; 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                                          |
-
-The overlay clusters sessions under dim headers when more than one group exists: a session's
-explicit group wins, and sessions without one fall back to the directory they were spawned from.
-Groups also come from outside — the `atc_session_update` MCP tool renames and regroups sessions, so
-an agent can organise the fleet for you.
-
-Revive (`P`) and headless eject (`H`) resume the session from its saved transcript, so both need one
-to exist: a session killed before its first exchange has nothing on disk yet, and the overlay says
-so in its message column instead of resuming.
-
-Everything else is passed through to the focused Claude session, which owns the full screen. Fleet
-state renders inside Claude Code's own status line (injected via the same `--settings` file): your
+| Key             | Where          | Action                                                                                                                                                                  |
+| --------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| leader          | anywhere       | toggle session overlay — `Ctrl-Space` by default, configurable (see Config)                                                                                             |
+| `n`             | home/overlay   | spawn: pick agent → dir (zoxide + history, fuzzy) → name → optional first prompt. Fresh clients default to Claude; last-used is the last deliberate-spawn SessionStart. |
+| `r`             | home/overlay   | adopt: pick agent → dir → name. Claude opens `claude --resume`. Grok opens plain `grok`.                                                                                |
+| `R`             | home           | restore last fleet after a daemon death — each session with its matching CLI                                                                                            |
+| `j`/`k`/`↑`/`↓` | overlay/picker | move                                                                                                                                                                    |
+| `Enter`         | overlay        | attach (auto-acks)                                                                                                                                                      |
+| `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                                                                                                                                      |
+| `p`             | overlay        | pin or unpin the selected session — pinned sessions stay at the top of the list                                                                                         |
+| `g`             | overlay        | toggle the grouped view: sessions cluster under repository headers                                                                                                      |
+| `H`             | overlay        | eject to headless (Claude only). Hidden and ignored on a Grok row.                                                                                                      |
+| `P`             | overlay        | revive: a fresh terminal resumes a headless or killed session in place                                                                                                  |
+| `y`             | overlay        | yank the resume command (`claude --resume <id>` or `grok --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                                                                          |
+| `?`             | 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                                                                                                                   |
+
+The overlay orders sessions by pinned first, then attention state, then most recently attached, so
+the session you want is nearly always near the top. The grouped view (`g`) keeps that order but
+clusters sessions under dim repository headers, with pinned sessions leading in their own cluster; a
+git worktree clusters with its main repository, and a directory outside any repository stands alone.
+A reserved column after the pin mark shows a dim `g` on Grok rows; Claude rows keep a space so names
+stay aligned. The `atc_session_update` MCP tool renames and pins sessions, so an agent can organise
+the fleet for you.
+
+Revive (`P`) resumes the session from its saved transcript, so a session killed before its first
+exchange has nothing on disk yet, and the overlay says so in its message column instead of resuming.
+Headless eject (`H`) is Claude-only and uses the same transcript; Grok has no headless handoff.
+
+Everything else is passed through to the focused session, which owns the full screen. Fleet state
+renders inside Claude Code's own status line (injected via the same `--settings` file): your
 configured statusline runs first, and atc appends `▏● 2 need you: auth-bug`. atc draws its own
 status bar only on the home and overlay screens.
 
 ## How state tracking works
 
-Spawned sessions get a `--settings` file injecting `Notification`, `Stop`, `UserPromptSubmit`, and
-`SessionEnd` hooks that report to a unix socket (`$XDG_RUNTIME_DIR/atc.sock`). Your global Claude
-settings are untouched; sessions you start outside atc are unaffected. States: red `●` needs you,
-cyan `◐` running, green `✓` turn done, gray `✗` exited. The overlay sorts needs-you first; the
-status bar turns red and names the most urgent session.
+Spawned Claude sessions get a `--settings` file injecting `Notification`, `Stop`,
+`UserPromptSubmit`, and `SessionEnd` hooks that report to a unix socket
+(`$XDG_RUNTIME_DIR/atc.sock`). Your global Claude settings are untouched; sessions you start outside
+atc are unaffected. Grok attention comes from a dedicated hook file at
+`$GROK_HOME/hooks/atc-reporter.json` (`~/.grok` when `GROK_HOME` is unset). atc never writes that
+path. Install it yourself:
+
+```sh
+mkdir -p ~/.grok/hooks
+atc grok-hooks > ~/.grok/hooks/atc-reporter.json
+```
+
+`atc grok-hooks` prints this file, with the `hook-report` command resolved for this install:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ],
+    "SessionEnd": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ],
+    "UserPromptSubmit": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ],
+    "Stop": [{ "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }],
+    "StopFailure": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ],
+    "StopCancelled": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ],
+    "Notification": [
+      { "hooks": [{ "type": "command", "command": "atc hook-report", "timeout": 5 }] }
+    ]
+  }
+}
+```
+
+A missing file is a Grok PTY without hook-driven attention. States: red `●` needs you, cyan `◐`
+running, green `✓` turn done, gray `✗` exited. The status bar turns red and names the most urgent
+session.
 
 ## Config
 
@@ -85,30 +131,35 @@ status bar turns red and names the most urgent session.
 {
   "claudeBin": "claude",
   "claudeArgs": [],
+  "grokBin": "grok",
+  "grokArgs": [],
   "leader": "ctrl-space"
 }
 ```
 
-| Field        | Default        | Meaning                                                                               |
-| ------------ | -------------- | ------------------------------------------------------------------------------------- |
-| `claudeBin`  | `"claude"`     | The binary spawned for every session.                                                 |
-| `claudeArgs` | `[]`           | Prepended to every spawn, e.g. `["--model", "opus"]`.                                 |
-| `leader`     | `"ctrl-space"` | The overlay toggle: `ctrl-` plus a letter or one of `\` `]` `^` `_`, e.g. `"ctrl-]"`. |
+| Field        | Default        | Meaning                                                                                                     |
+| ------------ | -------------- | ----------------------------------------------------------------------------------------------------------- |
+| `claudeBin`  | `"claude"`     | The binary spawned for Claude sessions.                                                                     |
+| `claudeArgs` | `[]`           | Prepended to every Claude spawn, e.g. `["--model", "opus"]`.                                                |
+| `grokBin`    | `"grok"`       | The binary spawned for Grok sessions.                                                                       |
+| `grokArgs`   | `[]`           | Prepended to every Grok spawn. A user `--leader` in this list is dropped; atc always appends `--no-leader`. |
+| `leader`     | `"ctrl-space"` | The overlay toggle: `ctrl-` plus a letter or one of `\` `]` `^` `_`, e.g. `"ctrl-]"`.                       |
 
 Pick a different leader when `Ctrl-Space` is taken on your machine — Raycast on macOS claims it, and
 `ctrl-]` is a solid replacement that no common terminal, multiplexer, or OS shortcut wants. An
 unknown or reserved value falls back to the default.
 
 `atc mcp` exposes the fleet as MCP tools (list, spawn, drive, organise) to any MCP client, wrangled
-sessions included:
+sessions included. `atc_session_spawn` takes an optional `agent` (`claude` or `grok`) and defaults
+to Claude; it never reads the TUI last-used value.
 
 ```sh
 claude mcp add --scope user atc -- atc mcp
 ```
 
-Daemon state — the restorable fleet, spawn-dir history, and the hook-event trail — lives in
-`~/.local/state/atc/atc.db` (SQLite), next to `status.json` (read by the injected statusline); the
-daemon's pid file sits in `$XDG_RUNTIME_DIR/atc-daemon.pid`, beside its sockets.
+Daemon state — the restorable fleet, spawn-dir history, last-used agent, and the hook-event trail —
+lives in `~/.local/state/atc/atc.db` (SQLite), next to `status.json` (read by the injected
+statusline); the daemon's pid file sits in `$XDG_RUNTIME_DIR/atc-daemon.pid`, beside its sockets.
 
 ## Crash safety
 
@@ -117,13 +168,13 @@ A client crash or closed window costs nothing: the daemon keeps hosting the flee
 would kill every hosted session — and shows `⟳ update ready` in the status bar; `u` in the overlay
 restarts the daemon and restores the fleet at a moment you choose. Only a protocol mismatch, where
 the two could miscommunicate, forces the restart immediately. The daemon continuously writes the
-live fleet (name, cwd, Claude session id) to its SQLite store. If the daemon itself dies — crash,
-SIGKILL, reboot — the child claude processes die with it, but every session's transcript is already
-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.
+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.
 
 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.
+"waiting to restore" — and revives one at a time, most recently active first: the next 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 agent 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.8",
+  "version": "0.1.10",
   "description": "Terminal control tower for Claude Code sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/agent-adapter.ts

@@ -1,5 +1,15 @@
 import type { HookEvent } from './hooks';
 
+export type AgentKind = 'claude' | 'grok';
+
+/**
+ * Missing, empty, and unknown values become Claude so a fleet written
+ * before the agent column still restores as Claude.
+ */
+export function toAgentKind(raw: unknown): AgentKind {
+  return raw === 'grok' ? 'grok' : 'claude';
+}
+
 export interface SpawnOptions {
   readonly prompt: string;
 
@@ -24,6 +34,10 @@ export interface AdapterEvent {
 
   // Opaque handle the adapter can later pull a session name from.
   nameSource?: string;
+
+  // Claude resume-existence path. Distinct from nameSource: a naming
+  // handle is not a resume gate.
+  transcriptSource?: string;
 }
 
 export interface NameUpdate {
@@ -42,12 +56,41 @@ interface ScreenDetector {
   readonly detectAttention: (screen: string) => AttentionJudgment | null;
 }
 
+export interface ResumeCheck {
+  readonly agentSessionID?: string;
+  readonly transcriptSource?: string;
+}
+
+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 };
+
 /**
  * Everything specific to one agent CLI: how to spawn it, how to read its
  * hook payloads, where its session names come from, and how to resume a
  * session outside atc. The session core never sees past this interface.
  */
 export interface AgentAdapter {
+  readonly kind: AgentKind;
+
+  // Runs one headless turn over a session; null means eject is unsupported
+  // for this agent.
+  readonly headlessRunner: HeadlessRunner | null;
+
   // The detector stack's screen tier; null when hooks are authoritative.
   readonly screenDetector: ScreenDetector | null;
   readonly planSpawn: (opts: SpawnOptions) => SpawnPlan;
@@ -56,5 +99,6 @@ export interface AgentAdapter {
     source: string,
     namedBy: 'user' | 'auto' | 'agent',
   ) => Promise<NameUpdate | null>;
+  readonly canResume: (session: ResumeCheck) => boolean;
   readonly buildResumeCommand: (cwd: string, agentSessionID: string | undefined) => string | null;
 }

package/src/boot-daemon.ts

@@ -1,6 +1,7 @@
 import { spawn as spawnChild } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
+import type { AgentKind } from './agent-adapter';
 import { daemonPidFile, daemonSocketPath } from './config';
 import { DaemonClient } from './daemon-client';
 import { getBuild } from './get-build';
@@ -9,6 +10,7 @@ import { isRecord } from './report';
 export interface DaemonBoot {
   readonly client: DaemonClient;
   readonly stale: boolean;
+  readonly lastUsedAgent: AgentKind;
 }
 
 /**
@@ -30,7 +32,11 @@ export async function bootDaemonClient(): Promise<DaemonBoot> {
     try {
       const hello = await client.sendHello(build);
 
-      return { client, stale: hello['daemon'] !== build };
+      return {
+        client,
+        stale: hello['daemon'] !== build,
+        lastUsedAgent: hello['lastUsedAgent'] === 'grok' ? 'grok' : 'claude',
+      };
     } catch (error) {
       client.stop();
 

package/src/build-cli-command.ts

@@ -0,0 +1,16 @@
+import { basename, join } from 'node:path';
+
+/**
+ * Command line that wrangled sessions invoke for atc subcommands: under bun
+ * the CLI entry path is part of the command; a compiled binary is itself
+ * the entry.
+ */
+export function buildCLICommand(subcommand: string): string {
+  const exec = process.execPath;
+
+  if (basename(exec) === 'bun' || basename(exec) === 'bun.exe') {
+    return `"${exec}" "${join(import.meta.dir, 'cli.ts')}" ${subcommand}`;
+  }
+
+  return `"${exec}" ${subcommand}`;
+}

package/src/claude-adapter.ts

@@ -1,13 +1,16 @@
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
+import { join } from 'node:path';
 import type {
   AdapterEvent,
   AgentAdapter,
+  HeadlessRunner,
   NameUpdate,
+  ResumeCheck,
   SpawnOptions,
   SpawnPlan,
 } from './agent-adapter';
+import { buildCLICommand } from './build-cli-command';
 import type { Config } from './config';
 import { stateDir } from './config';
 import type { HookEvent } from './hooks';
@@ -18,19 +21,26 @@ import { isRecord } from './report';
  * resume semantics, transcript name-pulling, and statusline chaining.
  */
 export class ClaudeAdapter implements AgentAdapter {
+  readonly kind = 'claude';
+
+  readonly headlessRunner: HeadlessRunner | null;
+
   // Claude's hooks are authoritative; no screen heuristics needed.
   readonly screenDetector = null;
 
   private readonly config: Config;
 
-  private readonly settingsFile: string;
+  // Written on first spawn so constructing the adapter touches no state.
+  private settingsFile: string | undefined;
 
-  constructor(config: Config) {
+  constructor(config: Config, headlessRunner: HeadlessRunner | null = null) {
     this.config = config;
-    this.settingsFile = writeHookSettings();
+    this.headlessRunner = headlessRunner;
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
+    this.settingsFile ??= writeHookSettings();
+
     return {
       bin: this.config.claudeBin,
       args: [
@@ -55,7 +65,9 @@ export class ClaudeAdapter implements AgentAdapter {
 
     const named: AdapterEvent = {
       ...base,
-      ...(typeof transcript === 'string' ? { nameSource: transcript } : {}),
+      ...(typeof transcript === 'string'
+        ? { nameSource: transcript, transcriptSource: transcript }
+        : {}),
     };
 
     switch (e.event) {
@@ -157,6 +169,14 @@ export class ClaudeAdapter implements AgentAdapter {
     }
   }
 
+  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 =
@@ -221,15 +241,3 @@ function writeHookSettings(): string {
 function truncateDetail(text: string): string {
   return text.length <= 600 ? text : `${text.slice(0, 599)}…`;
 }
-
-// Wrangled sessions invoke atc subcommands: under bun the CLI entry path is
-// part of the command; a compiled binary is itself the entry.
-function buildCLICommand(subcommand: string): string {
-  const exec = process.execPath;
-
-  if (basename(exec) === 'bun' || basename(exec) === 'bun.exe') {
-    return `"${exec}" "${join(import.meta.dir, 'cli.ts')}" ${subcommand}`;
-  }
-
-  return `"${exec}" ${subcommand}`;
-}

package/src/cli.ts

@@ -45,6 +45,7 @@ const main = defineCommand({
           const daemon = await import('./daemon');
           const config = await import('./config');
           const claude = await import('./claude-adapter');
+          const grok = await import('./grok-adapter');
           const headless = await import('./start-headless-run');
 
           // Test harnesses shrink the outbound queue to force overflow
@@ -60,12 +61,18 @@ const main = defineCommand({
           const restoreBootTimeoutMs =
             Number.isFinite(capOverride) && capOverride >= 0 ? capOverride : 15_000;
 
+          const claudeAdapter = new claude.ClaudeAdapter(cfg, (runOpts, hooks) =>
+            headless.startHeadlessRun(runOpts, hooks),
+          );
+
+          const grokAdapter = new grok.GrokAdapter(cfg);
+
           const handle = daemon.startDaemon({
-            headlessRunner: (runOpts, hooks) => headless.startHeadlessRun(runOpts, hooks),
             socketPath: config.daemonSocketPath,
             reporterSocketPath: config.socketPath,
             build: getBuild(),
-            adapter: new claude.ClaudeAdapter(cfg),
+            adapter: claudeAdapter,
+            adapters: { claude: claudeAdapter, grok: grokAdapter },
             dbPath: config.dbFile,
             legacyFleetPath: config.legacyFleetFile,
             pidPath: config.daemonPidFile,
@@ -80,6 +87,18 @@ const main = defineCommand({
           });
         },
       }),
+    'grok-hooks': () =>
+      defineCommand({
+        meta: {
+          name: 'grok-hooks',
+          description: 'Print the Grok hook file to install at $GROK_HOME/hooks/atc-reporter.json',
+        },
+        async run() {
+          const hook = await import('./print-grok-hook-file');
+
+          hook.printGrokHookFile();
+        },
+      }),
     'hook-report': () =>
       defineCommand({
         meta: {

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,28 @@ 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_') || GROK_PARENT_KEYS.has(key);
+}

package/src/config.ts

@@ -6,6 +6,8 @@ import { isRecord } from './report';
 export interface Config {
   claudeBin: string;
   claudeArgs: string[];
+  grokBin: string;
+  grokArgs: string[];
   leader: LeaderKey;
 }
 
@@ -17,6 +19,8 @@ interface LeaderKey {
 const DEFAULTS: Config = {
   claudeBin: 'claude',
   claudeArgs: [],
+  grokBin: 'grok',
+  grokArgs: [],
   leader: { code: 0, label: '^Space' },
 };
 
@@ -57,11 +61,17 @@ 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 leader =
       (typeof parsed['leader'] === 'string' ? decodeLeader(parsed['leader']) : null) ??
       DEFAULTS.leader;
 
-    return { claudeBin, claudeArgs, leader };
+    return { claudeBin, claudeArgs, grokBin, grokArgs, leader };
   } catch {
     return { ...DEFAULTS };
   }