@zgeoff/atc 2.36.1 → 2.38.0

package/README.md

@@ -151,7 +151,8 @@ installs in detail.
 
 atc creates `~/.config/atc/config.json` on first run. The
 [configuration guide](./docs/guides/configuration.md) covers every field: agent binaries and
-arguments, the leader key, gateways, and hooks.
+arguments, the leader key, gateways, and hooks, and how `atc config migrate` moves an old config to
+the `agents` map.
 
 ## Documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.36.1",
+  "version": "2.38.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",

package/src/agents/agent-adapter.ts

@@ -3,8 +3,9 @@ import type { DaemonError } from '../protocol/daemon-error';
 import type { HookEvent } from '../protocol/hook-event';
 import type { AgentID } from '../shared/agent-id';
 import type { AgentSessionID } from '../shared/agent-session-id';
+import type { GatewayAuth } from '../shared/check-gateway-auth';
 import type { AuthProfile } from '../shared/collect-auth-profiles';
-import type { GatewayAuth, GatewayConfig } from '../shared/collect-gateways';
+import type { GatewayConfig } from '../shared/collect-gateways';
 import type { SessionID } from '../shared/session-id';
 
 export interface SpawnOptions {
@@ -221,6 +222,10 @@ export interface AgentAdapter {
   // registered adapters.
   readonly id: AgentID;
 
+  // The agent value this harness's own hook lines carry, which a hook line
+  // must match for the session to act on it. Absent: the adapter's id.
+  readonly hookAgent?: AgentID;
+
   // Runs one headless turn over a session; null means eject is unsupported
   // for this agent.
   readonly headlessRunner: HeadlessRunner | null;

package/src/agents/build-agent-adapters.ts

@@ -0,0 +1,32 @@
+import type { Config } from '../shared/config';
+import type { AgentAdapter } from './agent-adapter';
+import { ClaudeAdapter } from './claude-adapter';
+import { CodexAdapter } from './codex-adapter';
+import { GatewayAdapter } from './gateway-adapter';
+import { GrokAdapter } from './grok-adapter';
+import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
+
+/**
+ * One adapter per registry entry, in registry order. A Claude entry with a
+ * base URL is a gateway, and one without is stock Claude.
+ */
+export function buildAgentAdapters(
+  config: Config,
+  headlessRun: ClaudeHeadlessRun | null = null,
+): AgentAdapter[] {
+  return config.agents.map((entry): AgentAdapter => {
+    if (entry.kind === 'codex') {
+      return new CodexAdapter(entry);
+    }
+
+    if (entry.kind === 'grok') {
+      return new GrokAdapter(entry);
+    }
+
+    if (entry.baseURL === undefined) {
+      return new ClaudeAdapter(entry, config, headlessRun);
+    }
+
+    return new GatewayAdapter({ ...entry, baseURL: entry.baseURL }, config, headlessRun);
+  });
+}

package/src/agents/build-claude-config-seed.ts

@@ -4,10 +4,12 @@ import { CLAUDE_CONFIG_SEED_FILE } from './claude-config-seed-file';
  * The guest file that seeds a session's own Claude config folder with the
  * state the CLI reads from `.claude.json` to start without its first-run
  * onboarding, and with folder trust for `trustedRoot`, the exact root of a
- * verified clone, when one is given. It holds no account: the placeholder
+ * verified clone, when one is given. Trust also approves every MCP server
+ * the clone's own `.mcp.json` declares, so an unattended session never
+ * waits on the CLI's approval prompt. It holds no account: the placeholder
  * credential is what keeps the CLI from asking for a login. Without a
- * trusted root the CLI asks a person to trust the workspace on its first
- * start.
+ * trusted root the CLI asks a person to trust the workspace, and to approve
+ * the clone's MCP servers, on its first start.
  */
 export function buildClaudeConfigSeed(
   trustedRoot: string | null,
@@ -15,9 +17,10 @@ export function buildClaudeConfigSeed(
   const seed =
     trustedRoot === null
       ? ONBOARDED_CONFIG
-      : { ...ONBOARDED_CONFIG, projects: { [trustedRoot]: { hasTrustDialogAccepted: true } } };
+      : { ...ONBOARDED_CONFIG, projects: { [trustedRoot]: TRUSTED_PROJECT } };
 
   return { [CLAUDE_CONFIG_SEED_FILE]: JSON.stringify(seed, null, 2) };
 }
 
 const ONBOARDED_CONFIG = { hasCompletedOnboarding: true };
+const TRUSTED_PROJECT = { hasTrustDialogAccepted: true, enableAllProjectMcpServers: true };

package/src/agents/build-claude-mcp-config.ts

@@ -0,0 +1,27 @@
+import type { ClaudeMCPServer } from '../shared/collect-claude-auth';
+
+/**
+ * The MCP config file that gives a session each server over HTTP with the
+ * broker's placeholder as a bearer credential in the server's header, so
+ * impd's broker swaps in the credential it holds for the server's host and
+ * the session never holds it.
+ */
+export function buildClaudeMCPConfig(servers: readonly ClaudeMCPServer[]): {
+  readonly mcpServers: Readonly<Record<string, unknown>>;
+} {
+  return {
+    mcpServers: Object.fromEntries(
+      servers.map((server) => [
+        server.name,
+        {
+          type: 'http',
+          url: server.url,
+          headers: { [server.header]: `Bearer ${BROKER_PLACEHOLDER}` },
+        },
+      ]),
+    ),
+  };
+}
+
+// The value impd's broker replaces with the credential on the host's side.
+const BROKER_PLACEHOLDER = 'imp-broker-placeholder';

package/src/agents/claude-adapter.ts

@@ -4,10 +4,13 @@ import { z } from 'zod';
 import type { AdapterEvent } from '../protocol/adapter-event';
 import { DaemonError } from '../protocol/daemon-error';
 import type { HookEvent } from '../protocol/hook-event';
+import type { AgentID } from '../shared/agent-id';
 import type { AgentSessionID } from '../shared/agent-session-id';
 import { buildOptionalString } from '../shared/build-optional-string';
+import type { AgentEntry } from '../shared/collect-agents';
 import type { Config } from '../shared/config';
-import { isBrokerVariable } from '../shared/is-broker-variable';
+import { isSubscriptionOverrideVariable } from '../shared/is-subscription-override-variable';
+import { OUTRANKING_VARIABLES } from '../shared/outranking-variables';
 import { isRecord } from '../shared/report';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
 import { toShellArg } from '../shared/to-shell-arg';
@@ -29,8 +32,11 @@ import { buildArgsWithoutFlags } from './build-args-without-flags';
 import { buildATCBridgeFiles } from './build-atc-bridge-files';
 import { buildClaudeConfigSeed } from './build-claude-config-seed';
 import { buildClaudeGuestLaunch } from './build-claude-guest-launch';
+import { buildClaudeMCPConfig } from './build-claude-mcp-config';
 import { buildClaudeOverrideArgs } from './build-claude-override-args';
 import { buildHookSettings } from './build-hook-settings';
+import type { HookSettingsProfile } from './build-hook-settings';
+import { buildRestoreModeArgs } from './build-restore-mode-args';
 import { CLAUDE_CONFIG_BUNDLE_FOLDER } from './claude-config-bundle-folder';
 import { CLAUDE_EFFORT_LEVELS } from './claude-effort-levels';
 import { findClaudePermissionMode } from './find-claude-permission-mode';
@@ -65,7 +71,11 @@ type ClaudeHookPayload = z.infer<typeof CLAUDE_HOOK_PAYLOAD_SCHEMA>;
  * resume semantics, transcript name-pulling, and statusline chaining.
  */
 export class ClaudeAdapter implements AgentAdapter {
-  readonly id = 'claude';
+  readonly id: AgentID;
+
+  // The agent value the hook lines of a Claude session carry: the settings
+  // file atc writes for this id names it on each hook command.
+  readonly hookAgent: AgentID;
 
   readonly headlessRunner: HeadlessRunner | null;
 
@@ -82,7 +92,9 @@ export class ClaudeAdapter implements AgentAdapter {
 
   readonly takesMessages = true;
 
-  private readonly config: Config;
+  private readonly entry: AgentEntry;
+
+  private readonly authProfiles: Config['authProfiles'];
 
   // Written on first spawn so constructing the adapter touches no state.
   private settingsFile: string | undefined;
@@ -92,44 +104,60 @@ export class ClaudeAdapter implements AgentAdapter {
 
   private readonly bridgeTarget: string | undefined;
 
-  constructor(config: Config, headlessRun: ClaudeHeadlessRun | null = null, bridgeTarget?: string) {
+  constructor(
+    entry: AgentEntry,
+    config: Pick<Config, 'authProfiles'>,
+    headlessRun: ClaudeHeadlessRun | null = null,
+    bridgeTarget?: string,
+  ) {
     this.bridgeTarget = bridgeTarget;
-    this.config = config;
+    this.entry = entry;
+    this.authProfiles = config.authProfiles;
+    this.id = entry.id;
+    this.hookAgent = entry.id;
 
     this.profile = {
-      label: 'Claude',
+      label: entry.label,
       kind: 'claude',
-      bin: config.claudeBin,
+      bin: entry.bin,
       models: null,
-      spawnOptions: buildClaudeSpawnOptions(config.claudeArgs),
+      spawnOptions: buildClaudeSpawnOptions(entry.args),
     };
 
     this.headlessRunner =
       headlessRun === null
         ? null
         : makeClaudeHeadlessRunner(headlessRun, {
-            claudeBin: config.claudeBin,
-            permissionMode: resolveClaudePermissionMode(config.claudeArgs, undefined),
+            claudeBin: entry.bin,
+            permissionMode: resolveClaudePermissionMode(entry.args, entry.settings),
             pluginDir: () => this.writeBridge(),
+            settings: () => this.writeSettings(),
           });
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
-    this.settingsFile ??= writeHookSettings({ id: this.id });
+    const modeArgs =
+      opts.resume === false ? [] : buildRestoreModeArgs(this.entry.args, this.entry.settings);
 
     return {
-      bin: this.config.claudeBin,
-      args: this.buildArgs(this.config.claudeArgs, opts, this.settingsFile, this.writeBridge()),
+      bin: this.entry.bin,
+      args: this.buildArgs(
+        this.entry.args,
+        opts,
+        modeArgs,
+        this.writeSettings(),
+        this.writeBridge(),
+      ),
     };
   }
 
-  // With `claudeAuth` configured, Claude signs in with the subscription
+  // With `auth` configured, Claude signs in with the subscription
   // token impd's broker holds on a target that reaches the broker, and
   // with the sign-in of the host it runs on anywhere else.
   findAuthSelection(): AuthSelection | null {
-    const auth = this.config.claudeAuth;
+    const auth = this.entry.auth;
 
-    if (auth === null) {
+    if (auth === undefined) {
       return null;
     }
 
@@ -139,7 +167,7 @@ export class ClaudeAdapter implements AgentAdapter {
         baseURL: ANTHROPIC_API_URL,
         auth: { profiles: auth.profiles, placeholderEnv: { [OAUTH_VARIABLE]: PLACEHOLDER } },
       },
-      profiles: this.config.authProfiles,
+      profiles: this.authProfiles,
       brokerRequired: false,
     };
   }
@@ -156,6 +184,9 @@ export class ClaudeAdapter implements AgentAdapter {
 
     const argv = [guest.atc];
 
+    const modeArgs =
+      opts.resume === false ? [] : buildRestoreModeArgs(this.entry.args, this.entry.settings);
+
     const bridge = Object.entries(buildATCBridgeFiles(argv)).map(
       ([path, content]): [string, string] => [`atc-bridge/${path}`, content],
     );
@@ -165,15 +196,20 @@ export class ClaudeAdapter implements AgentAdapter {
     }
 
     return {
-      bin: this.config.claudeBin,
+      bin: this.entry.bin,
       args: this.buildArgs(
-        this.config.claudeArgs,
+        this.entry.args,
         opts,
+        modeArgs,
         `${guest.dir}/settings.json`,
         `${guest.dir}/atc-bridge`,
       ),
       files: {
-        'settings.json': JSON.stringify(buildHookSettings({ id: this.id }, 0, argv), null, 2),
+        'settings.json': JSON.stringify(
+          buildHookSettings(this.buildSettingsProfile({}), 0, argv),
+          null,
+          2,
+        ),
         ...Object.fromEntries(bridge),
       },
     };
@@ -183,7 +219,7 @@ export class ClaudeAdapter implements AgentAdapter {
   // broker with trust for the clone; any other remote session reads the
   // config of the host's image, which atc never writes.
   planGuestWorkspaceTrust(root: string): Readonly<Record<string, string>> | null {
-    if (this.config.claudeAuth === null) {
+    if (this.entry.auth === undefined) {
       return null;
     }
 
@@ -197,7 +233,11 @@ export class ClaudeAdapter implements AgentAdapter {
   // config bundle, come from the host's own Claude config folder as it is
   // at this launch, staged under a key of this launch's own. A credential, endpoint, or provider variable in the
   // configured settings, or in the host's environment, would keep the CLI
-  // from sending the placeholder, so either refuses the start.
+  // from sending the placeholder, so either refuses the start. The entry's
+  // MCP servers reach the CLI through an MCP config file of the binding
+  // revision, each with the placeholder in its header. Their flag sits
+  // ahead of the settings flag, so the variadic flag never takes the
+  // prompt as one of its values.
   private planSubscriptionGuestSpawn(
     opts: SpawnOptions,
     dir: string,
@@ -212,15 +252,19 @@ export class ClaudeAdapter implements AgentAdapter {
     }
 
     const settingsPath = `auth-r${auth.revision}/settings.json`;
+    const mcpServers = this.entry.mcpServers ?? [];
+    const mcpPath = `auth-r${auth.revision}/mcp.json`;
+    const mcpArgs = mcpServers.length === 0 ? [] : ['--mcp-config', `${dir}/${mcpPath}`];
     const bundleKey = randomUUID();
 
     const launch = buildClaudeGuestLaunch(
       dir,
       [
-        this.config.claudeBin,
+        this.entry.bin,
         ...this.buildArgs(
-          buildArgsWithoutFlags(this.config.claudeArgs, ['--permission-mode']),
+          buildArgsWithoutFlags(this.entry.args, ['--permission-mode']),
           opts,
+          mcpArgs,
           `${dir}/${settingsPath}`,
           `${dir}/atc-bridge`,
         ),
@@ -238,7 +282,7 @@ export class ClaudeAdapter implements AgentAdapter {
     const padding = typeof userSettings === 'string' ? findStatuslinePadding(userSettings) : 0;
 
     const settings = buildHookSettings(
-      { id: this.id, env: { ...auth.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' } },
+      this.buildSettingsProfile({ ...auth.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' }),
       padding,
       argv,
     );
@@ -248,6 +292,9 @@ export class ClaudeAdapter implements AgentAdapter {
       args: launch.args,
       files: {
         [settingsPath]: JSON.stringify(settings, null, 2),
+        ...(mcpServers.length === 0
+          ? {}
+          : { [mcpPath]: JSON.stringify(buildClaudeMCPConfig(mcpServers), null, 2) }),
         ...buildClaudeConfigSeed(null),
         ...Object.fromEntries(
           Object.entries(bundle).map(([path, content]) => [
@@ -261,50 +308,81 @@ export class ClaudeAdapter implements AgentAdapter {
     };
   }
 
-  // The refusal for configured arguments whose inline `--settings` sets a
-  // variable that overrides the subscription sign-in or routes the CLI
-  // around impd's broker, or null when they set none.
+  // The refusal for an entry whose environment, settings environment, or
+  // inline `--settings` argument sets a variable that overrides the
+  // subscription sign-in or routes the CLI around impd's broker, or null
+  // when it sets none.
   private findCredentialOverride(): DaemonError | null {
-    const inline = findFlagValue(this.config.claudeArgs, ['--settings']);
+    const settingsEnv = this.entry.settings?.['env'];
 
-    if (inline === null) {
-      return null;
+    const sources: readonly (readonly [string, readonly string[]])[] = [
+      ['env', Object.keys(this.entry.env)],
+      ['settings.env', isRecord(settingsEnv) ? Object.keys(settingsEnv) : []],
+      ['args in --settings', this.findInlineSettingsKeys()],
+    ];
+
+    for (const [source, keys] of sources) {
+      const variable = keys.find((key) => isSubscriptionOverrideVariable(key));
+
+      if (variable !== undefined) {
+        return new DaemonError(
+          'auth_target_unsupported',
+          `claude signs in through impd's broker on this target, but agents.${this.id}.${source === 'args in --settings' ? 'args set' : `${source} sets`} ${variable}${source === 'args in --settings' ? ' in --settings' : ''}, which would override or route around that sign-in`,
+          { agent: this.id, problem: 'guest_env_conflict', variable },
+        );
+      }
     }
 
-    let parsed: unknown;
+    return null;
+  }
+
+  // The variables an inline `--settings` argument sets in its env block.
+  private findInlineSettingsKeys(): string[] {
+    const inline = findFlagValue(this.entry.args, ['--settings']);
+
+    if (inline === null) {
+      return [];
+    }
 
     try {
-      parsed = JSON.parse(inline);
+      const parsed: unknown = JSON.parse(inline);
+      const env = isRecord(parsed) ? parsed['env'] : undefined;
+
+      return isRecord(env) ? Object.keys(env) : [];
     } catch {
-      return null;
+      return [];
     }
+  }
 
-    const env = isRecord(parsed) ? parsed['env'] : undefined;
-    const keys = isRecord(env) ? Object.keys(env) : [];
-
-    const variable = keys.find(
-      (key) => OUTRANKING_VARIABLES.has(key) || key === OAUTH_VARIABLE || isBrokerVariable(key),
-    );
+  // What the generated settings file holds for this entry: its hooks and
+  // statusline, its settings, and its environment, with `extraEnv` on top.
+  // The entry's environment outranks the settings' own env block.
+  private buildSettingsProfile(extraEnv: Readonly<Record<string, string>>): HookSettingsProfile {
+    const settingsEnv = this.entry.settings?.['env'];
 
-    if (variable === undefined) {
-      return null;
-    }
+    const env = {
+      ...(isRecord(settingsEnv) ? toStringEntries(settingsEnv) : {}),
+      ...this.entry.env,
+      ...extraEnv,
+    };
 
-    return new DaemonError(
-      'auth_target_unsupported',
-      `claude signs in through impd's broker on this target, but claudeArgs set ${variable} in --settings, which would override or route around that sign-in`,
-      { agent: this.id, problem: 'guest_env_conflict', variable },
-    );
+    return {
+      id: this.id,
+      env,
+      ...(this.entry.settings === undefined ? {} : { settings: this.entry.settings }),
+    };
   }
 
   private buildArgs(
     configured: readonly string[],
     opts: SpawnOptions,
+    leadArgs: readonly string[],
     settings: string,
     pluginDir: string,
   ): string[] {
     return [
       ...buildClaudeOverrideArgs(configured, opts),
+      ...leadArgs,
       '--settings',
       settings,
       '--plugin-dir',
@@ -315,6 +393,12 @@ export class ClaudeAdapter implements AgentAdapter {
     ];
   }
 
+  private writeSettings(): string {
+    this.settingsFile ??= writeHookSettings(this.buildSettingsProfile({}));
+
+    return this.settingsFile;
+  }
+
   private writeBridge(): string {
     this.bridgeDir ??= writeATCBridge(this.bridgeTarget);
 
@@ -453,13 +537,21 @@ export class ClaudeAdapter implements AgentAdapter {
 
   // Shell command that re-opens this session outside atc (or anywhere). A
   // permission mode the configured arguments set travels as an explicit
-  // flag, so it overrides the mode the CLI would restore.
+  // flag, so it overrides the mode the CLI would restore. The generated
+  // settings file travels only for an entry that sets its own settings or
+  // environment, since the file sits on the daemon's machine and an entry
+  // without either needs nothing from it.
   buildResumeCommand(cwd: string, agentSessionID: AgentSessionID | undefined): string | null {
-    const configured = findClaudePermissionMode(this.config.claudeArgs, undefined);
+    const configured = findClaudePermissionMode(this.entry.args, this.entry.settings);
     const mode = configured === null ? '' : ` --permission-mode ${toShellArg(configured)}`;
     const resume = agentSessionID === undefined ? '' : ` ${agentSessionID}`;
 
-    return `cd ${toShellArg(cwd)} && claude${mode} --resume${resume}`;
+    const settings =
+      this.entry.settings === undefined && Object.keys(this.entry.env).length === 0
+        ? ''
+        : ` --settings ${toShellArg(this.writeSettings())}`;
+
+    return `cd ${toShellArg(cwd)} && ${formatShellWord(this.entry.bin)}${mode}${settings} --resume${resume}`;
   }
 }
 
@@ -470,21 +562,14 @@ const ANTHROPIC_API_URL = 'https://api.anthropic.com';
 const OAUTH_VARIABLE = 'CLAUDE_CODE_OAUTH_TOKEN';
 const PLACEHOLDER = 'imp-broker-placeholder';
 
-// The variables that keep Claude Code from sending the subscription token
-// to the Anthropic API: a credential it takes ahead of that token, another
-// endpoint, or a cloud provider it signs in to instead.
-const OUTRANKING_VARIABLES: ReadonlySet<string> = new Set([
-  'ANTHROPIC_AUTH_TOKEN',
-  'ANTHROPIC_API_KEY',
-  'ANTHROPIC_BASE_URL',
-  'CLAUDE_CODE_USE_BEDROCK',
-  'CLAUDE_CODE_USE_VERTEX',
-  'CLAUDE_CODE_USE_FOUNDRY',
-  'CLAUDE_CODE_USE_MANTLE',
-  'CLAUDE_CODE_USE_ANTHROPIC_AWS',
-  'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
-  'CLAUDE_CODE_USE_GATEWAY',
-]);
+// The string values of an object, which is all a session's environment holds.
+function toStringEntries(value: Readonly<Record<string, unknown>>): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  );
+}
 
 // The padding of the statusline the bundle's user settings set, which atc's
 // own statusline mirrors since it renders that one first, or none.
@@ -535,3 +620,9 @@ function buildClaudeSpawnOptions(claudeArgs: readonly string[]): SpawnOptionSpec
     },
   };
 }
+
+// A binary name or path that needs no quoting stays bare, so the default
+// entry resumes with plain `claude`; anything else is quoted as one word.
+function formatShellWord(value: string): string {
+  return /^[\w./-]+$/.test(value) ? value : toShellArg(value);
+}

package/src/agents/codex-adapter.ts

@@ -3,9 +3,10 @@ import { join } from 'node:path';
 import { z } from 'zod';
 import type { AdapterEvent } from '../protocol/adapter-event';
 import type { HookEvent } from '../protocol/hook-event';
+import type { AgentID } from '../shared/agent-id';
 import type { AgentSessionID } from '../shared/agent-session-id';
 import { buildOptionalString } from '../shared/build-optional-string';
-import type { Config } from '../shared/config';
+import type { AgentEntry } from '../shared/collect-agents';
 import { isRecord } from '../shared/report';
 import { toAgentSessionID } from '../shared/to-agent-session-id';
 import { toShellArg } from '../shared/to-shell-arg';
@@ -47,7 +48,11 @@ const CODEX_MODEL_FLAGS = ['-m', '--model'];
  * trusts once in the Codex TUI; atc never writes into the user's Codex config.
  */
 export class CodexAdapter implements AgentAdapter {
-  readonly id = 'codex';
+  readonly id: AgentID;
+
+  // The hook files a user installs print the kind for every entry of it, so
+  // the hook lines of every codex entry carry it.
+  readonly hookAgent = 'codex';
 
   // Codex has no headless handoff.
   readonly headlessRunner = null;
@@ -63,29 +68,30 @@ export class CodexAdapter implements AgentAdapter {
   // line is pasted and then submitted.
   readonly planLineInput = planPastedLineInput;
 
-  private readonly config: Config;
+  private readonly entry: AgentEntry;
 
-  constructor(config: Config) {
-    this.config = config;
+  constructor(entry: AgentEntry) {
+    this.entry = entry;
+    this.id = entry.id;
 
     this.profile = {
-      label: 'Codex',
+      label: entry.label,
       kind: 'codex',
-      bin: config.codexBin,
+      bin: entry.bin,
       models: null,
-      spawnOptions: buildCodexSpawnOptions(config.codexArgs),
+      spawnOptions: buildCodexSpawnOptions(entry.args),
     };
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
     return {
-      bin: this.config.codexBin,
+      bin: this.entry.bin,
       args: [
         // A model override replaces any model flag the configured arguments
         // carry, and travels as its own argument.
         ...(opts.model === undefined
-          ? this.config.codexArgs
-          : [...buildArgsWithoutFlags(this.config.codexArgs, CODEX_MODEL_FLAGS), '-m', opts.model]),
+          ? this.entry.args
+          : [...buildArgsWithoutFlags(this.entry.args, CODEX_MODEL_FLAGS), '-m', opts.model]),
 
         // Bare resume opens Codex's own session picker; an id resumes that
         // session directly. Both accept a prompt afterwards.

package/src/agents/gateway-adapter.ts

@@ -50,6 +50,9 @@ import { writeHookSettings } from './write-hook-settings';
 export class GatewayAdapter implements AgentAdapter {
   readonly id: AgentID;
 
+  // The settings file names the gateway's id on every hook command.
+  readonly hookAgent: AgentID;
+
   // A headless turn carries the same settings file the terminal spawn does,
   // so it reaches this backend rather than the default one. A gateway whose
   // credential comes through impd's broker runs no headless turn.
@@ -103,7 +106,20 @@ export class GatewayAdapter implements AgentAdapter {
       spawnOptions: buildGatewaySpawnOptions(gateway.args, models),
     };
 
-    this.claude = new ClaudeAdapter(config);
+    this.hookAgent = gateway.id;
+
+    this.claude = new ClaudeAdapter(
+      {
+        id: gateway.id,
+        kind: 'claude',
+        label: gateway.label,
+        mark: gateway.mark,
+        bin: gateway.bin,
+        args: gateway.args,
+        env: {},
+      },
+      config,
+    );
 
     this.headlessRunner =
       headlessRun === null || gateway.auth !== undefined