@zgeoff/atc 0.1.9 → 0.1.11

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,8 @@ 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. atc is built to pair with
+Grok sessions also need the `grok` CLI, and Codex sessions the `codex` 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.
@@ -38,51 +39,101 @@ 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 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                                                             |
-| `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: 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                                          |
+| 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`, Codex `codex 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>`, `grok --resume <id>`, or `codex resume <id>`)                                                                          |
+| `Y`             | overlay        | eject: yank the resume command, then kill the session here                                                                                                              |
+| `K`             | overlay        | kill selected (confirm with `y`) — the entry stays revivable with `P`; a second `K` forgets it                                                                          |
+| `?`             | 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.
-The `atc_session_update` MCP tool renames and pins sessions, so an agent can organise the fleet for
-you.
+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`) 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.
+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 Claude session, which owns the full screen. Fleet
-state renders inside Claude Code's own status line (injected via the same `--settings` file): your
+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 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
+```
+
+Codex attention comes from hook entries in `$CODEX_HOME/hooks.json` (`~/.codex` when `CODEX_HOME` is
+unset). atc never writes that path either — `atc codex-hooks` prints the entries to merge in:
+
+```sh
+atc codex-hooks
+```
+
+Codex parses new hooks but never runs them until you trust them once: open `codex`, review the atc
+hooks in its hooks list, and approve them. Sessions you start outside atc report events too; the
+reporter exits immediately when no atc session id is present.
+
+`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
 
@@ -92,30 +143,39 @@ urgent session.
 {
   "claudeBin": "claude",
   "claudeArgs": [],
+  "grokBin": "grok",
+  "grokArgs": [],
+  "codexBin": "codex",
+  "codexArgs": [],
   "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`. |
+| `codexBin`   | `"codex"`      | The binary spawned for Codex sessions.                                                                      |
+| `codexArgs`  | `[]`           | Prepended to every Codex spawn.                                                                             |
+| `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`, `grok`, or `codex`) 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
 
@@ -124,13 +184,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.9",
+  "version": "0.1.11",
   "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' | 'codex';
+
+/**
+ * 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' || raw === 'codex' ? raw : '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,8 @@ 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 codex = await import('./codex-adapter');
           const headless = await import('./start-headless-run');
 
           // Test harnesses shrink the outbound queue to force overflow
@@ -60,12 +62,19 @@ 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 codexAdapter = new codex.CodexAdapter(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, codex: codexAdapter },
             dbPath: config.dbFile,
             legacyFleetPath: config.legacyFleetFile,
             pidPath: config.daemonPidFile,
@@ -80,6 +89,31 @@ const main = defineCommand({
           });
         },
       }),
+    'codex-hooks': () =>
+      defineCommand({
+        meta: {
+          name: 'codex-hooks',
+          description:
+            'Print the Codex hook entries to merge into $CODEX_HOME/hooks.json (trust them once in the Codex TUI)',
+        },
+        async run() {
+          const hook = await import('./print-codex-hook-file');
+
+          hook.printCodexHookFile();
+        },
+      }),
+    '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: {