@zgeoff/atc 0.1.12 → 1.0.1

package/src/agents/gateway-adapter.ts

@@ -0,0 +1,106 @@
+import type { HookEvent } from '../daemon/hooks';
+import type { AgentSessionID } from '../shared/agent-session-id';
+import type { GatewayConfig } from '../shared/collect-gateways';
+import type { Config } from '../shared/config';
+import { toShellArg } from '../shared/to-shell-arg';
+import type {
+  AdapterEvent,
+  AgentAdapter,
+  AgentID,
+  HeadlessRunner,
+  NameUpdate,
+  ResumeCheck,
+  SpawnOptions,
+  SpawnPlan,
+} from './agent-adapter';
+import { ClaudeAdapter } from './claude-adapter';
+import { writeHookSettings } from './write-hook-settings';
+
+/**
+ * The Claude CLI pointed at a Claude-compatible backend other than the
+ * default one. Hooks, transcripts, and resume semantics are the CLI's, so
+ * they come straight from the Claude adapter; only the spawn plan and the
+ * resume command differ, because both have to name the settings file that
+ * carries the backend.
+ */
+export class GatewayAdapter implements AgentAdapter {
+  readonly id: AgentID;
+
+  // A headless turn carries the same settings file the terminal spawn does,
+  // so it reaches this backend rather than the default one.
+  readonly headlessRunner: HeadlessRunner | null;
+
+  // The CLI's hooks are authoritative; no screen heuristics needed.
+  readonly screenDetector = null;
+
+  private readonly gateway: GatewayConfig;
+
+  private readonly claude: ClaudeAdapter;
+
+  // Written on first spawn so constructing the adapter touches no state.
+  private settingsFile: string | undefined;
+
+  constructor(
+    gateway: GatewayConfig,
+    config: Config,
+    headlessRunner: HeadlessRunner | null = null,
+  ) {
+    this.gateway = gateway;
+    this.id = gateway.id;
+
+    this.claude = new ClaudeAdapter(config);
+
+    this.headlessRunner =
+      headlessRunner === null
+        ? null
+        : (opts, hooks) => headlessRunner({ ...opts, settings: this.writeSettings() }, hooks);
+  }
+
+  planSpawn(opts: SpawnOptions): SpawnPlan {
+    return {
+      bin: this.gateway.bin,
+      args: [
+        ...this.gateway.args,
+        '--settings',
+        this.writeSettings(),
+        ...(opts.resume === true ? ['--resume'] : []),
+        ...(typeof opts.resume === 'string' ? ['--resume', opts.resume] : []),
+        ...(opts.prompt === '' ? [] : [opts.prompt]),
+      ],
+    };
+  }
+
+  normalizeHook(e: HookEvent): AdapterEvent {
+    return this.claude.normalizeHook(e);
+  }
+
+  loadName(source: string, namedBy: 'user' | 'auto' | 'agent'): Promise<NameUpdate | null> {
+    return this.claude.loadName(source, namedBy);
+  }
+
+  canResume(session: ResumeCheck): boolean {
+    return this.claude.canResume(session);
+  }
+
+  // Shell command that re-opens this session outside atc. It names the
+  // generated settings file, because without it the CLI would resume the
+  // session against the default backend.
+  buildResumeCommand(cwd: string, agentSessionID: AgentSessionID | undefined): string | null {
+    const settings = toShellArg(this.writeSettings());
+    const resume = agentSessionID === undefined ? '' : ` ${agentSessionID}`;
+
+    return `cd ${toShellArg(cwd)} && ${this.gateway.bin} --settings ${settings} --resume${resume}`;
+  }
+
+  private writeSettings(): string {
+    this.settingsFile ??= writeHookSettings({
+      id: this.id,
+      env: { ANTHROPIC_BASE_URL: this.gateway.baseURL, ...this.gateway.env },
+      ...(this.gateway.apiKeyHelper === undefined
+        ? {}
+        : { apiKeyHelper: this.gateway.apiKeyHelper }),
+    });
+
+    return this.settingsFile;
+  }
+}

package/src/{grok-adapter.ts → agents/grok-adapter.ts}

@@ -1,6 +1,14 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { z } from 'zod';
+import type { HookEvent } from '../daemon/hooks';
+import type { AgentSessionID } from '../shared/agent-session-id';
+import { buildOptionalString } from '../shared/build-optional-string';
+import type { Config } from '../shared/config';
+import { isRecord } from '../shared/report';
+import type { SessionID } from '../shared/session-id';
+import { toAgentSessionID } from '../shared/to-agent-session-id';
+import { toShellArg } from '../shared/to-shell-arg';
 import type {
   AdapterEvent,
   AgentAdapter,
@@ -9,22 +17,42 @@ import type {
   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';
+import { resolveAgentHome } from './resolve-agent-home';
+import { truncateDetail } from './truncate-detail';
 
 interface GrokSessionHookState {
   latestPromptID?: string;
   lastKind: AdapterEvent['kind'];
 }
 
+// Bounds per-session hook state so a Grok session killed or crashed without
+// a SessionEnd hook cannot grow it for the daemon's whole lifetime.
+const MAX_HOOK_STATE_ENTRIES = 256;
+
+// Grok's hook payload keys, camelCase. An absent or wrong-typed field parses
+// to undefined rather than failing the payload, so a broken reporter never
+// breaks the session it reports on.
+const GROK_HOOK_PAYLOAD_SCHEMA = z.object({
+  sessionId: buildOptionalString(),
+  cwd: buildOptionalString(),
+  promptId: buildOptionalString(),
+  subagentType: buildOptionalString(),
+  prompt: buildOptionalString(),
+  notificationType: buildOptionalString(),
+  message: buildOptionalString(),
+  reason: buildOptionalString(),
+  lastAssistantMessage: buildOptionalString(),
+});
+
+type GrokHookPayload = z.infer<typeof GROK_HOOK_PAYLOAD_SCHEMA>;
+
 /**
  * The Grok Build adapter: spawn arguments, hook payload mapping,
  * resume semantics, and summary.json name-pulling.
  */
 export class GrokAdapter implements AgentAdapter {
-  readonly kind = 'grok';
+  readonly id = 'grok';
 
   // Grok has no headless handoff.
   readonly headlessRunner = null;
@@ -34,7 +62,7 @@ export class GrokAdapter implements AgentAdapter {
 
   private readonly config: Config;
 
-  private readonly hookState = new Map<string, GrokSessionHookState>();
+  private readonly hookState = new Map<SessionID, GrokSessionHookState>();
 
   constructor(config: Config) {
     this.config = config;
@@ -53,32 +81,34 @@ export class GrokAdapter implements AgentAdapter {
   }
 
   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 parsed = GROK_HOOK_PAYLOAD_SCHEMA.safeParse(e.payload);
+    const payload: GrokHookPayload = parsed.success ? parsed.data : {};
+
+    const agentSessionID =
+      payload.sessionId === undefined ? undefined : toAgentSessionID(payload.sessionId);
 
     const base: AdapterEvent = {
       kind: 'heartbeat',
-      ...(typeof sessionID === 'string' ? { agentSessionID: sessionID } : {}),
+      ...(agentSessionID === undefined ? {} : { agentSessionID }),
     };
 
     const named: AdapterEvent = {
       ...base,
-      ...(typeof sessionID === 'string' && typeof cwd === 'string'
-        ? { nameSource: buildGrokNameSource(sessionID, cwd) }
+      ...(agentSessionID !== undefined && payload.cwd !== undefined
+        ? { nameSource: buildGrokNameSource(agentSessionID, payload.cwd) }
         : {}),
     };
 
-    if (typeof subagentType === 'string' && subagentType !== '') {
+    if (payload.subagentType !== undefined && payload.subagentType !== '') {
       return this.emitHook(e.atcId, { ...base, kind: 'heartbeat' });
     }
 
     const event = normalizeHookEventName(e.event);
     const prior = this.hookState.get(e.atcId);
+    const promptID = payload.promptId;
 
     const stale =
-      typeof promptID === 'string' &&
+      promptID !== undefined &&
       prior?.latestPromptID !== undefined &&
       promptID !== prior.latestPromptID;
 
@@ -87,9 +117,7 @@ export class GrokAdapter implements AgentAdapter {
         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;
+        const preview = payload.prompt === undefined ? '' : payload.prompt.slice(0, 80);
 
         return this.emitHook(
           e.atcId,
@@ -98,18 +126,18 @@ export class GrokAdapter implements AgentAdapter {
             kind: 'prompt-submitted',
             ...(preview === '' ? {} : { message: preview, detail: truncateDetail(preview) }),
           },
-          submittedID,
+          promptID,
         );
       }
       case 'Notification': {
-        const notificationType = e.payload['notificationType'];
-        const message = e.payload['message'];
+        const notificationType = payload.notificationType;
+        const message = payload.message;
 
         if (notificationType === 'permission_prompt') {
           return this.emitHook(e.atcId, {
             ...base,
             kind: 'needs-input',
-            ...(typeof message === 'string' && message !== ''
+            ...(message !== undefined && message !== ''
               ? { message, detail: truncateDetail(message) }
               : {}),
           });
@@ -124,11 +152,11 @@ export class GrokAdapter implements AgentAdapter {
         return this.emitHook(e.atcId, base);
       }
       case 'Stop': {
-        if (e.payload['reason'] !== 'end_turn' || stale) {
+        if (payload.reason !== 'end_turn' || stale) {
           return this.emitHook(e.atcId, base);
         }
 
-        return this.emitHook(e.atcId, buildTurnDoneEvent(named, e.payload));
+        return this.emitHook(e.atcId, buildTurnDoneEvent(named, payload));
       }
       case 'StopFailure':
       case 'StopCancelled': {
@@ -136,7 +164,7 @@ export class GrokAdapter implements AgentAdapter {
           return this.emitHook(e.atcId, base);
         }
 
-        return this.emitHook(e.atcId, buildTurnDoneEvent(named, e.payload));
+        return this.emitHook(e.atcId, buildTurnDoneEvent(named, payload));
       }
       case 'SessionEnd': {
         this.hookState.delete(e.atcId);
@@ -181,14 +209,17 @@ export class GrokAdapter implements AgentAdapter {
   }
 
   // Shell command that re-opens this session outside atc (or anywhere).
-  buildResumeCommand(cwd: string, agentSessionID: string | undefined): string | null {
+  buildResumeCommand(cwd: string, agentSessionID: AgentSessionID | undefined): string | null {
     const resume = agentSessionID === undefined ? 'grok' : `grok --resume ${agentSessionID}`;
-    const quoted = cwd.replaceAll("'", String.raw`'\''`);
 
-    return `cd '${quoted}' && ${resume}`;
+    return `cd ${toShellArg(cwd)} && ${resume}`;
   }
 
-  private emitHook(atcID: string, event: Readonly<AdapterEvent>, promptID?: string): AdapterEvent {
+  private emitHook(
+    atcID: SessionID,
+    event: Readonly<AdapterEvent>,
+    promptID?: string,
+  ): AdapterEvent {
     const prior = this.hookState.get(atcID);
     const latestPromptID = promptID ?? prior?.latestPromptID;
 
@@ -199,6 +230,10 @@ export class GrokAdapter implements AgentAdapter {
         ? event.kind
         : (prior?.lastKind ?? event.kind);
 
+    if (prior === undefined && this.hookState.size >= MAX_HOOK_STATE_ENTRIES) {
+      this.removeOldestHookState();
+    }
+
     this.hookState.set(atcID, {
       lastKind: tracked,
       ...(latestPromptID === undefined ? {} : { latestPromptID }),
@@ -206,28 +241,34 @@ export class GrokAdapter implements AgentAdapter {
 
     return event;
   }
-}
 
-function resolveGrokHome(): string {
-  const home = process.env['GROK_HOME'];
+  // A Map preserves insertion order, so the first key is the oldest entry.
+  private removeOldestHookState(): void {
+    const oldest = this.hookState.keys().next().value;
 
-  return home !== undefined && home !== '' ? home : join(homedir(), '.grok');
+    if (oldest !== undefined) {
+      this.hookState.delete(oldest);
+    }
+  }
 }
 
-function buildGrokNameSource(sessionID: string, cwd: string): string {
-  return join(resolveGrokHome(), 'sessions', encodeURIComponent(cwd), sessionID, 'summary.json');
+function buildGrokNameSource(sessionID: AgentSessionID, cwd: string): string {
+  return join(
+    resolveAgentHome('GROK_HOME', '.grok'),
+    'sessions',
+    encodeURIComponent(cwd),
+    sessionID,
+    'summary.json',
+  );
 }
 
-function buildTurnDoneEvent(
-  named: Readonly<AdapterEvent>,
-  payload: Readonly<Record<string, unknown>>,
-): AdapterEvent {
-  const lastMessage = payload['lastAssistantMessage'];
+function buildTurnDoneEvent(named: Readonly<AdapterEvent>, payload: GrokHookPayload): AdapterEvent {
+  const lastMessage = payload.lastAssistantMessage;
 
   return {
     ...named,
     kind: 'turn-done',
-    ...(typeof lastMessage === 'string' && lastMessage !== ''
+    ...(lastMessage !== undefined && lastMessage !== ''
       ? { detail: truncateDetail(lastMessage) }
       : {}),
   };
@@ -254,7 +295,7 @@ function findGrokSummary(source: string): string | null {
     return null;
   }
 
-  const root = join(resolveGrokHome(), 'sessions');
+  const root = join(resolveAgentHome('GROK_HOME', '.grok'), 'sessions');
 
   try {
     for (const group of readdirSync(root)) {
@@ -268,7 +309,3 @@ function findGrokSummary(source: string): string | null {
 
   return null;
 }
-
-function truncateDetail(text: string): string {
-  return text.length <= 600 ? text : `${text.slice(0, 599)}…`;
-}

package/src/agents/resolve-agent-home.ts

@@ -0,0 +1,13 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * An agent CLI's home directory: the named environment variable when it is
+ * set and non-empty, otherwise the given default directory under the user's
+ * home.
+ */
+export function resolveAgentHome(envVar: string, defaultDirName: string): string {
+  const home = process.env[envVar];
+
+  return home !== undefined && home !== '' ? home : join(homedir(), defaultDirName);
+}

package/src/agents/truncate-detail.ts

@@ -0,0 +1,7 @@
+/**
+ * Caps a detail string at 600 characters, ellipsizing anything longer so a
+ * single hook payload cannot blow up the briefing text.
+ */
+export function truncateDetail(text: string): string {
+  return text.length <= 600 ? text : `${text.slice(0, 599)}…`;
+}

package/src/agents/write-hook-settings.ts

@@ -0,0 +1,37 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { stateDir } from '../shared/config';
+import { isRecord } from '../shared/report';
+import { buildHookSettings } from './build-hook-settings';
+import type { HookSettingsProfile } from './build-hook-settings';
+
+/**
+ * Writes the settings file passed to a wrangled session as
+ * `claude --settings`, one per agent id, and returns its path.
+ */
+export function writeHookSettings(profile: HookSettingsProfile): string {
+  const file = join(stateDir, `hook-settings-${profile.id}.json`);
+  const settings = buildHookSettings(profile, readStatuslinePadding());
+
+  writeFileSync(file, JSON.stringify(settings, null, 2));
+
+  return file;
+}
+
+/**
+ * The padding on the user's own statusline, so the chained one lines up with
+ * it. An unreadable or unconfigured setting is no padding.
+ */
+function readStatuslinePadding(): number {
+  try {
+    const raw = readFileSync(join(homedir(), '.claude', 'settings.json'), 'utf8');
+    const user: unknown = JSON.parse(raw);
+    const statusLine = isRecord(user) ? user['statusLine'] : undefined;
+    const padding = isRecord(statusLine) ? statusLine['padding'] : undefined;
+
+    return typeof padding === 'number' ? padding : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/cli.ts

@@ -2,7 +2,7 @@
 // `statusline` are the commands injected into wrangled sessions.
 import { defineCommand, runMain } from 'citty';
 import pkg from '../package.json';
-import { getBuild } from './get-build';
+import { getBuild } from './shared/get-build';
 
 const main = defineCommand({
   meta: {
@@ -20,7 +20,7 @@ const main = defineCommand({
           hidden: true,
         },
         async run() {
-          await import('./index');
+          await import('./client/index');
         },
       }),
     mcp: () =>
@@ -42,12 +42,13 @@ const main = defineCommand({
           description: 'Run the atc daemon in the foreground',
         },
         async run() {
-          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');
+          const daemon = await import('./daemon/daemon');
+          const config = await import('./shared/config');
+          const claude = await import('./agents/claude-adapter');
+          const grok = await import('./agents/grok-adapter');
+          const codex = await import('./agents/codex-adapter');
+          const gateway = await import('./agents/gateway-adapter');
+          const headless = await import('./daemon/start-headless-run');
 
           // Test harnesses shrink the outbound queue to force overflow
           // deterministically; unset means the production default.
@@ -69,12 +70,19 @@ const main = defineCommand({
           const grokAdapter = new grok.GrokAdapter(cfg);
           const codexAdapter = new codex.CodexAdapter(cfg);
 
-          const handle = daemon.startDaemon({
+          const gatewayAdapters = cfg.gateways.map(
+            (entry) =>
+              new gateway.GatewayAdapter(entry, cfg, (runOpts, hooks) =>
+                headless.startHeadlessRun(runOpts, hooks),
+              ),
+          );
+
+          const handle = await daemon.startDaemon({
             socketPath: config.daemonSocketPath,
             reporterSocketPath: config.socketPath,
             build: getBuild(),
             adapter: claudeAdapter,
-            adapters: { claude: claudeAdapter, grok: grokAdapter, codex: codexAdapter },
+            adapters: [claudeAdapter, grokAdapter, codexAdapter, ...gatewayAdapters],
             dbPath: config.dbFile,
             legacyFleetPath: config.legacyFleetFile,
             pidPath: config.daemonPidFile,
@@ -84,8 +92,11 @@ const main = defineCommand({
           });
 
           process.on('SIGTERM', () => {
-            handle.stop();
-            process.exit(0);
+            void (async () => {
+              await handle.stop();
+
+              process.exit(0);
+            })();
           });
         },
       }),
@@ -97,7 +108,7 @@ const main = defineCommand({
             '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');
+          const hook = await import('./agents/print-codex-hook-file');
 
           hook.printCodexHookFile();
         },
@@ -109,7 +120,7 @@ const main = defineCommand({
           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');
+          const hook = await import('./agents/print-grok-hook-file');
 
           hook.printGrokHookFile();
         },

package/src/{boot-daemon.ts → client/boot-daemon.ts}

@@ -1,16 +1,17 @@
 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 { toAgentID } from '../agents/agent-adapter';
+import type { AgentID } from '../agents/agent-adapter';
+import { daemonPidFile, daemonSocketPath } from '../shared/config';
+import { getBuild } from '../shared/get-build';
+import { isRecord } from '../shared/report';
 import { DaemonClient } from './daemon-client';
-import { getBuild } from './get-build';
-import { isRecord } from './report';
 
 export interface DaemonBoot {
   readonly client: DaemonClient;
   readonly stale: boolean;
-  readonly lastUsedAgent: AgentKind;
+  readonly lastUsedAgent: AgentID;
 }
 
 /**
@@ -35,7 +36,7 @@ export async function bootDaemonClient(): Promise<DaemonBoot> {
       return {
         client,
         stale: hello['daemon'] !== build,
-        lastUsedAgent: hello['lastUsedAgent'] === 'grok' ? 'grok' : 'claude',
+        lastUsedAgent: toAgentID(hello['lastUsedAgent']),
       };
     } catch (error) {
       client.stop();
@@ -120,7 +121,7 @@ async function stopStaleDaemon(): Promise<void> {
 function spawnDaemonDetached() {
   const exec = process.execPath;
   const isBun = basename(exec) === 'bun' || basename(exec) === 'bun.exe';
-  const args = isBun ? [join(import.meta.dir, 'cli.ts'), 'daemon'] : ['daemon'];
+  const args = isBun ? [join(import.meta.dir, '..', 'cli.ts'), 'daemon'] : ['daemon'];
 
   spawnChild(exec, args, { detached: true, stdio: 'ignore' }).unref();
 }

package/src/client/build-client-machine.ts

@@ -0,0 +1,119 @@
+import { setup } from 'xstate';
+
+type ClientMachineEvent =
+  | { readonly type: 'ATTACH'; readonly sessionID: string }
+  | { readonly type: 'HOME' }
+  | { readonly type: 'OVERLAY' }
+  | { readonly type: 'HELP' }
+  | { readonly type: 'SPAWN'; readonly resume: boolean }
+  | { readonly type: 'EJECT'; readonly sessionID: string };
+
+// What the machine borrows from the client that owns the screen, the fleet
+// mirror, and the daemon connection. Every prop is a side effect the machine
+// triggers but never performs itself.
+export interface ClientMachineDeps {
+  readonly openHome: () => void;
+  readonly openAttached: (sessionID: string) => void;
+  readonly openOverlay: () => void;
+  readonly openHelp: () => void;
+  readonly openPicker: (resume: boolean) => void;
+  readonly openEject: (sessionID: string) => void;
+}
+
+/**
+ * The client's mode as a statechart: which mode each event moves to, and
+ * what runs on entry. `ATTACH` and `OVERLAY` reach several of the modes
+ * below because several keys and outcomes lead to the same place —
+ * attaching a session, or falling back to the overlay — and each landing
+ * runs the same entry work regardless of where it was sent from.
+ */
+export function buildClientMachine(deps: ClientMachineDeps) {
+  return setup({
+    types: {
+      // oxlint-disable-next-line no-unsafe-type-assertion -- xstate's typed-setup contract: this value is never read, it only carries the event union past the type layer
+      events: {} as ClientMachineEvent,
+    },
+    actions: {
+      openHome: () => {
+        deps.openHome();
+      },
+      openAttached: (args) => {
+        if (args.event.type === 'ATTACH') {
+          deps.openAttached(args.event.sessionID);
+        }
+      },
+      openOverlay: () => {
+        deps.openOverlay();
+      },
+      openHelp: () => {
+        deps.openHelp();
+      },
+    },
+  }).createMachine({
+    id: 'client',
+    initial: 'home',
+    states: {
+      home: {
+        entry: 'openHome',
+        on: {
+          ATTACH: 'attached',
+          HOME: { target: 'home', reenter: true },
+          OVERLAY: 'overlay',
+          SPAWN: {
+            target: 'picker',
+            actions: (args) => {
+              deps.openPicker(args.event.resume);
+            },
+          },
+        },
+      },
+      attached: {
+        entry: 'openAttached',
+        on: {
+          OVERLAY: 'overlay',
+        },
+      },
+      overlay: {
+        entry: 'openOverlay',
+        on: {
+          ATTACH: 'attached',
+          HOME: 'home',
+          OVERLAY: { target: 'overlay', reenter: true },
+          HELP: 'help',
+          SPAWN: {
+            target: 'picker',
+            actions: (args) => {
+              deps.openPicker(args.event.resume);
+            },
+          },
+          EJECT: {
+            target: 'picker-eject',
+            actions: (args) => {
+              deps.openEject(args.event.sessionID);
+            },
+          },
+        },
+      },
+      help: {
+        entry: 'openHelp',
+        on: {
+          OVERLAY: 'overlay',
+        },
+      },
+      picker: {
+        on: {
+          ATTACH: 'attached',
+          HOME: 'home',
+          OVERLAY: 'overlay',
+        },
+      },
+      'picker-eject': {
+        on: {
+          ATTACH: 'attached',
+          HOME: 'home',
+          OVERLAY: 'overlay',
+        },
+      },
+    },
+  });
+}