@zgeoff/atc 2.11.0 → 2.13.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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "2.11.0",
+  "version": "2.13.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

@@ -25,6 +25,20 @@ export interface SpawnOptions {
   // true opens the agent's own session picker; an agent session id resumes
   // that specific session.
   readonly resume: boolean | AgentSessionID;
+
+  // The model and effort the session runs with; an absent one leaves the
+  // agent's configured default in place.
+  readonly model?: string;
+  readonly effort?: string;
+}
+
+/**
+ * The per-session model and effort a spawn asks for, already checked
+ * against what the agent advertises.
+ */
+export interface SpawnOverrides {
+  readonly model?: string;
+  readonly effort?: string;
 }
 
 export interface SpawnPlan {
@@ -32,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;
@@ -87,24 +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.
@@ -133,6 +165,49 @@ export interface AgentProfile {
 
   // Model names the config sets explicitly, keyed by role; null when it sets none.
   readonly models: Readonly<Record<string, string>> | null;
+
+  // The per-session overrides a spawn can pass this agent's CLI.
+  readonly spawnOptions: SpawnOptionSpecs;
+}
+
+/**
+ * A value worth offering for a spawn option, with the provider model it
+ * maps to when the config holds that mapping.
+ */
+interface SpawnOptionExample {
+  readonly value: string;
+  readonly resolvesTo: string | null;
+}
+
+/**
+ * Whether the agent's CLI takes one spawn option, and which values it does.
+ * `values` holds the closed set a value must come from; null takes any
+ * well-formed value. `backendEffect` is `applied` when the CLI applies the
+ * value itself and `unverified` when the backend behind the CLI may ignore
+ * it; null for an option the agent does not take.
+ */
+export interface SpawnOptionSpec {
+  readonly supported: boolean;
+  readonly values: readonly string[] | null;
+  readonly examples: readonly SpawnOptionExample[];
+  readonly default: string | null;
+  readonly backendEffect: 'applied' | 'unverified' | null;
+  readonly note: string | null;
+}
+
+export interface SpawnOptionSpecs {
+  readonly model: SpawnOptionSpec;
+  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;
 }
 
 /**
@@ -159,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,
@@ -174,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-args-without-flags.ts

@@ -0,0 +1,25 @@
+/**
+ * An argument list with every occurrence of the named flags removed, each
+ * with its value: the flag followed by its value, or `--flag=value`. Every
+ * other argument keeps its place.
+ */
+export function buildArgsWithoutFlags(args: readonly string[], names: readonly string[]): string[] {
+  const kept: string[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index] ?? '';
+
+    if (names.includes(arg)) {
+      index += 1;
+      continue;
+    }
+
+    if (names.some((name) => name.startsWith('--') && arg.startsWith(`${name}=`))) {
+      continue;
+    }
+
+    kept.push(arg);
+  }
+
+  return kept;
+}

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-override-args.ts

@@ -0,0 +1,26 @@
+import type { SpawnOverrides } from './agent-adapter';
+import { buildArgsWithoutFlags } from './build-args-without-flags';
+
+/**
+ * The configured leading arguments for a Claude CLI spawn with the session's
+ * model and effort applied. An override replaces any `--model` or `--effort`
+ * the configured arguments carry, value included, so the session never
+ * depends on which occurrence the CLI honours. Without overrides the
+ * configured arguments pass through unchanged. Each value travels as its own
+ * argument, never through a shell.
+ */
+export function buildClaudeOverrideArgs(
+  configured: readonly string[],
+  overrides: SpawnOverrides,
+): string[] {
+  const replaced = [
+    ...(overrides.model === undefined ? [] : ['--model']),
+    ...(overrides.effort === undefined ? [] : ['--effort']),
+  ];
+
+  return [
+    ...buildArgsWithoutFlags(configured, replaced),
+    ...(overrides.model === undefined ? [] : ['--model', overrides.model]),
+    ...(overrides.effort === undefined ? [] : ['--effort', overrides.effort]),
+  ];
+}

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,13 +11,26 @@ import type {
   AdapterEvent,
   AgentAdapter,
   AgentProfile,
+  GuestPaths,
+  GuestSpawnPlan,
   HeadlessRunner,
   NameUpdate,
   ResumeCheck,
+  SpawnOptionSpecs,
   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';
@@ -49,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;
@@ -63,15 +79,26 @@ 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;
-    this.profile = { label: 'Claude', kind: 'claude', bin: config.claudeBin, models: null };
+
+    this.profile = {
+      label: 'Claude',
+      kind: 'claude',
+      bin: config.claudeBin,
+      models: null,
+      spawnOptions: buildClaudeSpawnOptions(config.claudeArgs),
+    };
 
     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 {
@@ -79,19 +106,47 @@ export class ClaudeAdapter implements AgentAdapter {
 
     return {
       bin: this.config.claudeBin,
-      args: [
-        ...this.config.claudeArgs,
-        '--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);
 
@@ -222,11 +277,50 @@ 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}`;
   }
 }
+
+// The aliases Claude Code documents for `--model`, each resolving to a model
+// the account picks. A full model name is accepted as well.
+const CLAUDE_MODEL_ALIASES = [
+  'best',
+  'fable',
+  'opus',
+  'sonnet',
+  'haiku',
+  'opus[1m]',
+  'sonnet[1m]',
+  'opusplan',
+];
+
+// What a Claude spawn can override. Each default is the value the configured
+// arguments pass, or null when the CLI picks its own.
+function buildClaudeSpawnOptions(claudeArgs: readonly string[]): SpawnOptionSpecs {
+  return {
+    model: {
+      supported: true,
+      values: null,
+      examples: CLAUDE_MODEL_ALIASES.map((value) => ({ value, resolvesTo: null })),
+      default: findFlagValue(claudeArgs, ['--model']),
+      backendEffect: 'applied',
+      note: 'An alias or a full model name, passed as --model.',
+    },
+    effort: {
+      supported: true,
+      values: CLAUDE_EFFORT_LEVELS,
+      examples: [],
+      default: findFlagValue(claudeArgs, ['--effort']),
+      backendEffect: 'applied',
+      note: 'Passed as --effort. Which levels a session honours depends on its model.',
+    },
+  };
+}

package/src/agents/claude-effort-levels.ts

@@ -0,0 +1,5 @@
+/**
+ * The effort levels Claude Code's `--effort` flag accepts. Which of them a
+ * session honours depends on its model.
+ */
+export const CLAUDE_EFFORT_LEVELS: readonly string[] = ['low', 'medium', 'high', 'xhigh', 'max'];