@zgeoff/atc 2.12.0 → 2.14.0

package/README.md

@@ -74,16 +74,16 @@ mark:
 
 Sessions that need you sort to the top, so the one you want is nearly always first.
 
-| Key          | Action                                       |
-| ------------ | -------------------------------------------- |
-| `Ctrl-Space` | open or close the list                       |
-| `Tab`        | attach the session that needs you most       |
-| `Enter`      | attach the selected session                  |
-| `/`          | filter by name or directory                  |
-| `a`          | acknowledge a notification without attaching |
-| `K`          | kill the selected session                    |
-| `q`          | quit the client; sessions keep running       |
-| `?`          | every other key                              |
+| Key          | Action                                                                                                                  |
+| ------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `Ctrl-Space` | open or close the list                                                                                                  |
+| `Tab`        | attach the session that needs you most                                                                                  |
+| `Enter`      | attach the selected session                                                                                             |
+| `/`          | filter by name or directory                                                                                             |
+| `a`          | acknowledge a notification without attaching                                                                            |
+| `K`          | kill the selected session; on a host atc can destroy, a dead session asks once more before forgetting destroys the host |
+| `q`          | quit the client; sessions keep running                                                                                  |
+| `?`          | every other key                                                                                                         |
 
 The directory picker lists the directory you ran `atc` from, atc's own spawn history, every project
 under the roots in `config.json`, and your [zoxide](https://github.com/ajeetdsouza/zoxide) list when
@@ -94,7 +94,8 @@ list.
 If the daemon dies, press `R` on the home screen and every session respawns from its transcript.
 After you upgrade atc, the status bar shows `⟳ update ready`, and `u` restarts the daemon and
 restores the fleet when you are ready. The bar shows `⟳ restarting daemon` until the restart
-finishes.
+finishes. When the running daemon speaks another protocol version, `atc` asks before it restarts the
+daemon, since the restart ends every session the daemon hosts.
 
 atc runs inside zellij or tmux. Give the pane locked mode so the leader key reaches atc.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",
@@ -42,6 +42,7 @@
     "@better-auth/oauth-provider": "1.7.6",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
+    "@zgeoff/imp-client": "0.24.0",
     "better-auth": "1.7.6",
     "bun-pty": "0.4.10",
     "citty": "0.2.2",

package/src/agents/agent-adapter.ts

@@ -46,6 +46,24 @@ export interface SpawnPlan {
   args: string[];
 }
 
+/**
+ * Where a session on a remote host finds atc: the atc binary inside the
+ * host, null when the host has none, and the folder the session's own
+ * files unpack into.
+ */
+export interface GuestPaths {
+  readonly atc: string | null;
+  readonly dir: string;
+}
+
+/**
+ * A spawn on a remote host, with the files the harness reads there, keyed
+ * by their path inside the session's guest folder.
+ */
+export interface GuestSpawnPlan extends SpawnPlan {
+  readonly files: Readonly<Record<string, string>>;
+}
+
 export interface AdapterEvent {
   kind: 'started' | 'needs-input' | 'turn-done' | 'prompt-submitted' | 'ended' | 'heartbeat';
   agentSessionID?: AgentSessionID;
@@ -101,28 +119,24 @@ export interface ResumeCheck {
   readonly transcriptSource?: string;
 }
 
-interface HeadlessRunRequest {
+export interface HeadlessRunRequest {
   readonly cwd: string;
   readonly prompt: string;
   readonly resume?: AgentSessionID;
-  readonly permissionMode?: string;
-
-  // Settings file the run's CLI is started with, so a headless turn reaches
-  // the same backend the session's terminal did.
-  readonly settings?: string;
 
-  // The atc session the run belongs to; the mod reads it to tap the inbox.
+  // The atc session the run belongs to.
   readonly sessionID?: SessionID;
 
-  // Folder of the atc-bridge mod the run's CLI loads, supplied by the adapter.
-  readonly pluginDir?: string;
-
   // The session's own model and effort, so a headless turn keeps them.
   readonly model?: string;
   readonly effort?: string;
+
+  // Environment variable names the run's process goes without, such as the
+  // credential a session's workspace was cloned with.
+  readonly withheldEnv?: readonly string[];
 }
 
-interface HeadlessRunEvents {
+export interface HeadlessRunEvents {
   readonly onOutput: (text: string) => void;
 
   // The turn's whole final message.
@@ -186,6 +200,16 @@ export interface SpawnOptionSpecs {
   readonly effort: SpawnOptionSpec;
 }
 
+/**
+ * The input modes the agent's TUI has switched on, as the session's screen
+ * model last saw them.
+ */
+export interface TerminalInputModes {
+  // Whether the TUI asked for pasted text to arrive between bracketed paste
+  // markers (DEC mode 2004).
+  readonly bracketedPaste: boolean;
+}
+
 /**
  * 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
@@ -210,6 +234,15 @@ export interface AgentAdapter {
   // Absent on a stand-in adapter, which `agents.list` reports as not installed.
   readonly profile?: AgentProfile;
   readonly planSpawn: (opts: SpawnOptions) => SpawnPlan;
+
+  // Plans a spawn on a remote host; null when this agent cannot run there,
+  // such as one whose instrumentation needs atc on a host without it.
+  // Absent: the agent runs there as a local spawn plans it, with no files.
+  readonly planGuestSpawn?: (opts: SpawnOptions, guest: GuestPaths) => GuestSpawnPlan | null;
+
+  // The command that exits 0 inside a remote host when the agent there can
+  // sign in without a person. Absent: atc runs no check.
+  readonly planAuthCheck?: () => readonly string[];
   readonly normalizeHook: (e: HookEvent) => AdapterEvent;
   readonly loadName: (
     source: string,
@@ -225,4 +258,8 @@ export interface AgentAdapter {
   // null for a line that is not one. Absent: atc cannot read this agent's
   // transcript.
   readonly parseTranscriptLine?: (line: string) => TranscriptRow | null;
+
+  // The PTY writes, in order, that type a line into the agent's TUI and
+  // submit it. Absent: the line and a trailing newline go as one write.
+  readonly planLineInput?: (text: string, modes: TerminalInputModes) => readonly string[];
 }

package/src/agents/build-atc-bridge-files.ts

@@ -0,0 +1,13 @@
+import { ATC_BRIDGE_FILES } from './atc-bridge-files';
+
+/**
+ * The files of the atc-bridge mod, keyed by their path inside the mod's
+ * folder, with the atc command the mod runs rendered from `argv`.
+ */
+export function buildATCBridgeFiles(argv: readonly string[]): Readonly<Record<string, string>> {
+  return { ...ATC_BRIDGE_FILES, 'hooks/atc-cli.ts': renderATCCLIModule(argv) };
+}
+
+function renderATCCLIModule(argv: readonly string[]): string {
+  return `export const ATC_CLI: readonly string[] = ${JSON.stringify(argv)};\n`;
+}

package/src/agents/build-claude-query-options.ts

@@ -0,0 +1,72 @@
+import type { Options } from '@anthropic-ai/claude-agent-sdk';
+import { socketPath } from '../shared/config';
+import type { HeadlessRunRequest } from './agent-adapter';
+import { buildHeadlessEnv } from './build-headless-env';
+import { resolveHeadlessExecutable } from './resolve-headless-executable';
+
+/**
+ * One headless turn as the Claude CLI runs it: the neutral turn request plus
+ * the binary, permission mode, mod folder, and settings file the Claude and
+ * gateway adapters supply.
+ */
+export interface ClaudeHeadlessRunRequest extends HeadlessRunRequest {
+  // The Claude Code binary a compiled atc hands the Agent SDK.
+  readonly claudeBin: string;
+
+  // An SDK permission mode; any other value leaves the SDK's default.
+  readonly permissionMode?: string;
+
+  // Settings file the run's CLI is started with, so a headless turn reaches
+  // the same backend the session's terminal did.
+  readonly settings?: string;
+
+  // Folder of the atc-bridge mod the run's CLI loads.
+  readonly pluginDir?: string;
+}
+
+const PERMISSION_MODES = [
+  'default',
+  'acceptEdits',
+  'bypassPermissions',
+  'plan',
+  'auto',
+  'dontAsk',
+] as const;
+
+// The effort levels the Agent SDK accepts.
+const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+/**
+ * The Agent SDK options one headless turn runs with, apart from the abort
+ * controller and stderr sink the live run owns. A permission mode or effort
+ * the SDK does not accept is left out, so the SDK applies its own default.
+ */
+export function buildClaudeQueryOptions(
+  opts: ClaudeHeadlessRunRequest,
+  compiled: boolean,
+): Options {
+  const mode = PERMISSION_MODES.find((m) => m === opts.permissionMode);
+  const effort = EFFORT_LEVELS.find((level) => level === opts.effort);
+
+  return {
+    cwd: opts.cwd,
+    env: buildHeadlessEnv({
+      socketPath,
+      ...(opts.pluginDir === undefined ? {} : { pluginDir: opts.pluginDir }),
+      ...(opts.sessionID === undefined ? {} : { sessionID: opts.sessionID }),
+      ...(opts.withheldEnv === undefined ? {} : { withheldEnv: opts.withheldEnv }),
+    }),
+    ...(opts.resume === undefined ? {} : { resume: opts.resume }),
+    ...(mode === undefined ? {} : { permissionMode: mode }),
+
+    // The session's own model and effort, so the turn runs as its terminal
+    // did.
+    ...(opts.model === undefined ? {} : { model: opts.model }),
+    ...(effort === undefined ? {} : { effort }),
+
+    // The same generated file the terminal spawn passes, so the turn runs
+    // against the session's own backend and instrumentation.
+    ...(opts.settings === undefined ? {} : { extraArgs: { settings: opts.settings } }),
+    ...resolveHeadlessExecutable(opts.claudeBin, compiled),
+  };
+}

package/src/agents/build-cli-command.ts

@@ -3,10 +3,12 @@ import { buildCLIArgv } from './build-cli-argv';
 /**
  * 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.
+ * the entry. A session on a remote host passes the argv of the atc inside
+ * that host.
  */
-export function buildCLICommand(subcommand: string): string {
-  return `${buildCLIArgv()
-    .map((part) => `"${part}"`)
-    .join(' ')} ${subcommand}`;
+export function buildCLICommand(
+  subcommand: string,
+  argv: readonly string[] = buildCLIArgv(),
+): string {
+  return `${argv.map((part) => `"${part}"`).join(' ')} ${subcommand}`;
 }

package/src/{daemon → agents}/build-headless-env.ts

@@ -5,6 +5,9 @@ interface HeadlessEnvParams {
   readonly pluginDir?: string;
   readonly sessionID?: SessionID;
   readonly socketPath: string;
+
+  // Variables the run goes without, such as a workspace credential.
+  readonly withheldEnv?: readonly string[];
 }
 
 /**
@@ -14,10 +17,13 @@ interface HeadlessEnvParams {
  * since the mod stays off outside atc.
  */
 export function buildHeadlessEnv(params: HeadlessEnvParams): Record<string, string> {
-  return collectCleanEnv({
-    ...(params.pluginDir === undefined ? {} : { CLAUDE_CODE_PLUGIN_DIRS: params.pluginDir }),
-    ...(params.sessionID === undefined
-      ? {}
-      : { ATC_SESSION_ID: params.sessionID, ATC_SOCKET: params.socketPath }),
-  });
+  return collectCleanEnv(
+    {
+      ...(params.pluginDir === undefined ? {} : { CLAUDE_CODE_PLUGIN_DIRS: params.pluginDir }),
+      ...(params.sessionID === undefined
+        ? {}
+        : { ATC_SESSION_ID: params.sessionID, ATC_SOCKET: params.socketPath }),
+    },
+    params.withheldEnv,
+  );
 }

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

@@ -26,13 +26,19 @@ export interface HookSettingsProfile {
  * a session's backend is decided here rather than by whatever the terminal
  * happened to carry. The credential is never part of it: the helper command
  * supplies that at run time, so it never reaches a file atc writes.
+ *
+ * A session on a remote host gets the argv of the atc inside that host,
+ * whose statusline renders that session's own state alone.
  */
 export function buildHookSettings(
   profile: HookSettingsProfile,
   statuslinePadding: number,
+  cliArgv?: readonly string[],
 ): Record<string, unknown> {
   const entry = [
-    { hooks: [{ type: 'command', command: buildCLICommand('hook-report'), timeout: 5 }] },
+    {
+      hooks: [{ type: 'command', command: buildCLICommand('hook-report', cliArgv), timeout: 5 }],
+    },
   ];
 
   const own = {
@@ -55,7 +61,7 @@ export function buildHookSettings(
     // padding.
     statusLine: {
       type: 'command',
-      command: buildCLICommand('statusline'),
+      command: buildCLICommand('statusline', cliArgv),
       padding: statuslinePadding,
     },
     ...(profile.env === undefined || Object.keys(profile.env).length === 0

package/src/agents/build-restore-mode-args.ts

@@ -0,0 +1,23 @@
+import { findClaudePermissionMode } from './find-claude-permission-mode';
+import { findFlagValue } from './find-flag-value';
+
+/**
+ * The arguments that restore a Claude CLI session in its configured
+ * permission mode. A resumed session otherwise takes back the mode it was
+ * saved in, and only an explicit `--permission-mode` overrides that, so a
+ * mode the settings alone set travels as the flag. Nothing is added when
+ * the arguments already carry the flag or no mode is configured, so an
+ * unconfigured session restores the mode it was saved in.
+ */
+export function buildRestoreModeArgs(
+  args: readonly string[],
+  settings: Readonly<Record<string, unknown>> | undefined,
+): string[] {
+  if (findFlagValue(args, ['--permission-mode']) !== null) {
+    return [];
+  }
+
+  const mode = findClaudePermissionMode([], settings);
+
+  return mode === null ? [] : ['--permission-mode', mode];
+}

package/src/agents/claude-adapter.ts

@@ -11,6 +11,8 @@ import type {
   AdapterEvent,
   AgentAdapter,
   AgentProfile,
+  GuestPaths,
+  GuestSpawnPlan,
   HeadlessRunner,
   NameUpdate,
   ResumeCheck,
@@ -18,10 +20,17 @@ import type {
   SpawnOptions,
   SpawnPlan,
 } from './agent-adapter';
+import { buildATCBridgeFiles } from './build-atc-bridge-files';
 import { buildClaudeOverrideArgs } from './build-claude-override-args';
+import { buildHookSettings } from './build-hook-settings';
 import { CLAUDE_EFFORT_LEVELS } from './claude-effort-levels';
+import { findClaudePermissionMode } from './find-claude-permission-mode';
 import { findFlagValue } from './find-flag-value';
+import { makeClaudeHeadlessRunner } from './make-claude-headless-runner';
+import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 import { parseClaudeTranscriptLine } from './parse-claude-transcript-line';
+import { planTypedLineInput } from './plan-typed-line-input';
+import { resolveClaudePermissionMode } from './resolve-claude-permission-mode';
 import { truncateDetail } from './truncate-detail';
 import { writeATCBridge } from './write-atc-bridge';
 import { writeHookSettings } from './write-hook-settings';
@@ -53,6 +62,9 @@ export class ClaudeAdapter implements AgentAdapter {
 
   readonly parseTranscriptLine = parseClaudeTranscriptLine;
 
+  // Claude's TUI submits a line typed with its newline in one write.
+  readonly planLineInput = planTypedLineInput;
+
   readonly profile: AgentProfile;
 
   readonly takesMessages = true;
@@ -67,7 +79,7 @@ export class ClaudeAdapter implements AgentAdapter {
 
   private readonly bridgeTarget: string | undefined;
 
-  constructor(config: Config, headlessRunner: HeadlessRunner | null = null, bridgeTarget?: string) {
+  constructor(config: Config, headlessRun: ClaudeHeadlessRun | null = null, bridgeTarget?: string) {
     this.bridgeTarget = bridgeTarget;
     this.config = config;
 
@@ -80,9 +92,13 @@ export class ClaudeAdapter implements AgentAdapter {
     };
 
     this.headlessRunner =
-      headlessRunner === null
+      headlessRun === null
         ? null
-        : (opts, hooks) => headlessRunner({ ...opts, pluginDir: this.writeBridge() }, hooks);
+        : makeClaudeHeadlessRunner(headlessRun, {
+            claudeBin: config.claudeBin,
+            permissionMode: resolveClaudePermissionMode(config.claudeArgs, undefined),
+            pluginDir: () => this.writeBridge(),
+          });
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
@@ -90,19 +106,47 @@ export class ClaudeAdapter implements AgentAdapter {
 
     return {
       bin: this.config.claudeBin,
-      args: [
-        ...buildClaudeOverrideArgs(this.config.claudeArgs, opts),
-        '--settings',
-        this.settingsFile,
-        '--plugin-dir',
-        this.writeBridge(),
-        ...(opts.resume === true ? ['--resume'] : []),
-        ...(typeof opts.resume === 'string' ? ['--resume', opts.resume] : []),
-        ...(opts.prompt === '' ? [] : [opts.prompt]),
-      ],
+      args: this.buildArgs(opts, this.settingsFile, this.writeBridge()),
     };
   }
 
+  // A remote session reports through the atc inside its host, so without
+  // one it has no instrumentation and cannot run there. Its settings and
+  // its copy of the mod travel with it, and it has no statusline.
+  planGuestSpawn(opts: SpawnOptions, guest: GuestPaths): GuestSpawnPlan | null {
+    if (guest.atc === null) {
+      return null;
+    }
+
+    const argv = [guest.atc];
+
+    const bridge = Object.entries(buildATCBridgeFiles(argv)).map(
+      ([path, content]): [string, string] => [`atc-bridge/${path}`, content],
+    );
+
+    return {
+      bin: this.config.claudeBin,
+      args: this.buildArgs(opts, `${guest.dir}/settings.json`, `${guest.dir}/atc-bridge`),
+      files: {
+        'settings.json': JSON.stringify(buildHookSettings({ id: this.id }, 0, argv), null, 2),
+        ...Object.fromEntries(bridge),
+      },
+    };
+  }
+
+  private buildArgs(opts: SpawnOptions, settings: string, pluginDir: string): string[] {
+    return [
+      ...buildClaudeOverrideArgs(this.config.claudeArgs, opts),
+      '--settings',
+      settings,
+      '--plugin-dir',
+      pluginDir,
+      ...(opts.resume === true ? ['--resume'] : []),
+      ...(typeof opts.resume === 'string' ? ['--resume', opts.resume] : []),
+      ...(opts.prompt === '' ? [] : [opts.prompt]),
+    ];
+  }
+
   private writeBridge(): string {
     this.bridgeDir ??= writeATCBridge(this.bridgeTarget);
 
@@ -233,12 +277,15 @@ export class ClaudeAdapter implements AgentAdapter {
     return existsSync(session.transcriptSource);
   }
 
-  // Shell command that re-opens this session outside atc (or anywhere).
+  // 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.
   buildResumeCommand(cwd: string, agentSessionID: AgentSessionID | undefined): string | null {
-    const resume =
-      agentSessionID === undefined ? 'claude --resume' : `claude --resume ${agentSessionID}`;
+    const configured = findClaudePermissionMode(this.config.claudeArgs, undefined);
+    const mode = configured === null ? '' : ` --permission-mode ${toShellArg(configured)}`;
+    const resume = agentSessionID === undefined ? '' : ` ${agentSessionID}`;
 
-    return `cd ${toShellArg(cwd)} && ${resume}`;
+    return `cd ${toShellArg(cwd)} && claude${mode} --resume${resume}`;
   }
 }
 

package/src/agents/codex-adapter.ts

@@ -20,6 +20,7 @@ import type {
 } from './agent-adapter';
 import { buildArgsWithoutFlags } from './build-args-without-flags';
 import { findFlagValue } from './find-flag-value';
+import { planPastedLineInput } from './plan-pasted-line-input';
 import { resolveAgentHome } from './resolve-agent-home';
 import { truncateDetail } from './truncate-detail';
 
@@ -58,6 +59,10 @@ export class CodexAdapter implements AgentAdapter {
 
   readonly takesMessages = false;
 
+  // Codex's TUI keeps a newline that arrives inside a burst of input, so a
+  // line is pasted and then submitted.
+  readonly planLineInput = planPastedLineInput;
+
   private readonly config: Config;
 
   constructor(config: Config) {

package/src/agents/find-claude-permission-mode.ts

@@ -0,0 +1,24 @@
+import { isRecord } from '../shared/report';
+import { findFlagValue } from './find-flag-value';
+
+/**
+ * The permission mode a Claude CLI agent's configuration sets: an explicit
+ * `--permission-mode` in its arguments, else the `permissions.defaultMode`
+ * its settings hold, or null when neither sets one. The argument wins, as it
+ * does for the CLI itself.
+ */
+export function findClaudePermissionMode(
+  args: readonly string[],
+  settings: Readonly<Record<string, unknown>> | undefined,
+): string | null {
+  const flag = findFlagValue(args, ['--permission-mode']);
+
+  if (flag !== null) {
+    return flag;
+  }
+
+  const permissions = settings?.['permissions'];
+  const defaultMode = isRecord(permissions) ? permissions['defaultMode'] : undefined;
+
+  return typeof defaultMode === 'string' && defaultMode !== '' ? defaultMode : null;
+}

package/src/agents/gateway-adapter.ts

@@ -16,10 +16,15 @@ import type {
   SpawnPlan,
 } from './agent-adapter';
 import { buildClaudeOverrideArgs } from './build-claude-override-args';
+import { buildRestoreModeArgs } from './build-restore-mode-args';
 import { ClaudeAdapter } from './claude-adapter';
 import { CLAUDE_EFFORT_LEVELS } from './claude-effort-levels';
 import { findFlagValue } from './find-flag-value';
+import { makeClaudeHeadlessRunner } from './make-claude-headless-runner';
+import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 import { parseClaudeTranscriptLine } from './parse-claude-transcript-line';
+import { planTypedLineInput } from './plan-typed-line-input';
+import { resolveClaudePermissionMode } from './resolve-claude-permission-mode';
 import { writeATCBridge } from './write-atc-bridge';
 import { writeHookSettings } from './write-hook-settings';
 
@@ -43,6 +48,9 @@ export class GatewayAdapter implements AgentAdapter {
   // The gateway runs the Claude CLI, which writes the same transcript.
   readonly parseTranscriptLine = parseClaudeTranscriptLine;
 
+  // The gateway runs the Claude CLI, whose TUI takes a line the same way.
+  readonly planLineInput = planTypedLineInput;
+
   readonly takesMessages = true;
 
   readonly profile: AgentProfile;
@@ -62,7 +70,7 @@ export class GatewayAdapter implements AgentAdapter {
   constructor(
     gateway: GatewayConfig,
     config: Config,
-    headlessRunner: HeadlessRunner | null = null,
+    headlessRun: ClaudeHeadlessRun | null = null,
     bridgeTarget?: string,
   ) {
     this.bridgeTarget = bridgeTarget;
@@ -82,13 +90,14 @@ export class GatewayAdapter implements AgentAdapter {
     this.claude = new ClaudeAdapter(config);
 
     this.headlessRunner =
-      headlessRunner === null
+      headlessRun === null
         ? null
-        : (opts, hooks) =>
-            headlessRunner(
-              { ...opts, settings: this.writeSettings(), pluginDir: this.writeBridge() },
-              hooks,
-            );
+        : makeClaudeHeadlessRunner(headlessRun, {
+            claudeBin: gateway.bin,
+            permissionMode: resolveClaudePermissionMode(gateway.args, gateway.settings),
+            pluginDir: () => this.writeBridge(),
+            settings: () => this.writeSettings(),
+          });
   }
 
   planSpawn(opts: SpawnOptions): SpawnPlan {
@@ -96,6 +105,9 @@ export class GatewayAdapter implements AgentAdapter {
       bin: this.gateway.bin,
       args: [
         ...buildClaudeOverrideArgs(this.gateway.args, opts),
+        ...(opts.resume === false
+          ? []
+          : buildRestoreModeArgs(this.gateway.args, this.gateway.settings)),
         '--settings',
         this.writeSettings(),
         '--plugin-dir',
@@ -107,6 +119,12 @@ export class GatewayAdapter implements AgentAdapter {
     };
   }
 
+  // The credential helper runs on the daemon's machine, so a gateway
+  // session never runs on a remote host.
+  planGuestSpawn(): null {
+    return null;
+  }
+
   normalizeHook(e: HookEvent): AdapterEvent {
     return this.claude.normalizeHook(e);
   }
@@ -119,14 +137,23 @@ export class GatewayAdapter implements AgentAdapter {
     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.
+  // Shell command that re-opens this session outside atc. It carries the
+  // gateway's configured arguments and its configured permission mode as an
+  // explicit flag, so that mode overrides the one the CLI would restore, and
+  // 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 args = [
+      ...this.gateway.args,
+      ...buildRestoreModeArgs(this.gateway.args, this.gateway.settings),
+    ]
+      .map((arg) => ` ${toShellArg(arg)}`)
+      .join('');
+
     const settings = toShellArg(this.writeSettings());
     const resume = agentSessionID === undefined ? '' : ` ${agentSessionID}`;
 
-    return `cd ${toShellArg(cwd)} && ${this.gateway.bin} --settings ${settings} --resume${resume}`;
+    return `cd ${toShellArg(cwd)} && ${this.gateway.bin}${args} --settings ${settings} --resume${resume}`;
   }
 
   private writeSettings(): string {

package/src/agents/grok-adapter.ts

@@ -20,6 +20,7 @@ import type {
   SpawnPlan,
 } from './agent-adapter';
 import { normalizeHookEventName } from './normalize-hook-event';
+import { planPastedLineInput } from './plan-pasted-line-input';
 import { resolveAgentHome } from './resolve-agent-home';
 import { truncateDetail } from './truncate-detail';
 
@@ -76,6 +77,10 @@ export class GrokAdapter implements AgentAdapter {
 
   readonly takesMessages = false;
 
+  // Grok's TUI keeps a newline that arrives inside a burst of input, so a
+  // line is pasted and then submitted.
+  readonly planLineInput = planPastedLineInput;
+
   private readonly config: Config;
 
   private readonly hookState = new Map<SessionID, GrokSessionHookState>();