@zgeoff/atc 2.10.4 → 2.12.0

package/src/daemon/sessions.ts

@@ -1,24 +1,31 @@
 import { writeFileSync } from 'node:fs';
-import { spawn } from 'bun-pty';
-import type { IPty } from 'bun-pty';
-import type { AdapterEvent, AgentAdapter, AgentID } from '../agents/agent-adapter';
+import type { AdapterEvent, AgentAdapter, AgentID, SpawnOverrides } from '../agents/agent-adapter';
 import { truncateDetail } from '../agents/truncate-detail';
+import { DaemonError } from '../protocol/daemon-error';
+import type { ErrorCode } from '../protocol/protocol';
 import type { AgentSessionID } from '../shared/agent-session-id';
 import { collectCleanEnv } from '../shared/collect-clean-env';
+import type { TargetConfigError } from '../shared/collect-targets';
 import { socketPath, statusFile } from '../shared/config';
+import type { DaemonID } from '../shared/daemon-id';
 import { resolveRepoRoot } from '../shared/resolve-repo-root';
 import type { SessionID } from '../shared/session-id';
 import { truncateToBytes } from '../shared/truncate-to-bytes';
-import type { FleetEntry, FleetStore } from '../store/fleet-entry';
+import type { FleetEntry, FleetEntryUpdate, FleetStore } from '../store/fleet-entry';
+import type { ExecutionTarget } from './build-execution-targets';
+import { buildTargetIdentity } from './build-target-identity';
+import type { ExecutionCapability, ExecutionProvider, HarnessHandle } from './execution-provider';
+import { findExecutionRefusal } from './find-execution-refusal';
 import type { HookEvent } from './hooks';
+import { LocalPTYProvider } from './local-pty-provider';
 import { mintSessionID } from './mint-session-id';
 
 export type SessionState = 'running' | 'needs_you' | 'done' | 'exited';
 
 export type SessionEventKind = 'added' | 'state' | 'renamed' | 'removed';
 
-// The over-the-wire view of a session: everything but the PTY handle, plus
-// the surface kind.
+// The over-the-wire view of a session: everything but the harness handle,
+// plus the surface kind.
 export interface SessionDescriptor {
   readonly id: SessionID;
   readonly name: string;
@@ -44,6 +51,15 @@ export interface SessionDescriptor {
   // The session this one is a sub-session of, when it has one: it lists
   // under that session and takes its pin from it.
   readonly parent?: SessionID;
+
+  // Where the session runs: the daemon hosting it, and the execution target
+  // on that daemon's host.
+  readonly locator: SessionLocator;
+}
+
+interface SessionLocator {
+  readonly daemonID: DaemonID;
+  readonly targetID: string;
 }
 
 export interface Session {
@@ -51,7 +67,10 @@ export interface Session {
   name: string;
   cwd: string;
   kind: 'pty' | 'headless';
-  pty: IPty | null;
+
+  // The running harness its execution provider handed back, or null when
+  // the session has no terminal.
+  pty: HarnessHandle | null;
   state: SessionState;
   unread: boolean;
   lastMsg: string;
@@ -87,6 +106,28 @@ export interface Session {
   // the transcript file the agent's hooks last reported. Kept apart from the
   // resume check so a restored path never changes whether a revive is allowed.
   transcriptPath?: string;
+
+  // the model and effort the session was spawned with; absent leaves the
+  // agent's configured default, and every revive passes them again.
+  model?: string;
+  effort?: string;
+
+  // the execution target the session runs on, and the identity it had
+  // when the session started there; every revive runs there too, and only
+  // while the target keeps that identity.
+  target: string;
+  targetIdentity: string;
+}
+
+// The identity of the implicit `local` target, which a fleet row without a
+// stored identity ran on.
+const LOCAL_TARGET_IDENTITY = buildTargetIdentity('local-pty', {});
+
+// The target a session runs on and the identity it is bound to there; null
+// binds a new session to the target as it stands now.
+interface TargetBinding {
+  readonly target: string;
+  readonly targetIdentity: string | null;
 }
 
 export class SessionManager {
@@ -100,6 +141,12 @@ export class SessionManager {
 
   onEvent: (kind: SessionEventKind, s: Session) => void = () => {};
 
+  // Where a background failure is reported, one line at a time: stderr,
+  // like the daemon's other background failures.
+  log: (line: string) => void = (line) => {
+    console.error(line);
+  };
+
   // Whether any registered adapter has a screen detector, decided once at
   // construction since the registry never changes afterward. Lets a hot path
   // that only cares about this answer skip walking live sessions to find it.
@@ -111,11 +158,25 @@ export class SessionManager {
 
   private readonly statusPath: string;
 
+  private readonly targets: ReadonlyMap<string, ExecutionTarget>;
+
+  private readonly targetErrors: readonly TargetConfigError[];
+
   constructor(
     fallback: AgentAdapter,
     store: FleetStore,
     statusPath: string | undefined = statusFile,
     adapters: readonly AgentAdapter[] = [],
+    targets: readonly ExecutionTarget[] = [
+      {
+        id: 'local',
+        kind: 'local-pty',
+        options: {},
+        identity: LOCAL_TARGET_IDENTITY,
+        provider: new LocalPTYProvider(),
+      },
+    ],
+    targetErrors: readonly TargetConfigError[] = [],
   ) {
     // Each adapter names the id it answers to, so a registry key can never
     // disagree with the adapter behind it. A later one wins the id.
@@ -123,6 +184,51 @@ export class SessionManager {
     this.hasScreenDetector = Object.values(this.adapters).some((a) => a.screenDetector !== null);
     this.store = store;
     this.statusPath = statusPath ?? statusFile;
+
+    this.targets = new Map(targets.map((t) => [t.id, t]));
+
+    this.targetErrors = targetErrors;
+  }
+
+  /**
+   * The provider a binding's work runs on, after every target check: throws
+   * the refusal for a target the config leaves unusable, one that is gone,
+   * one whose identity is not the binding's, one with no provider here, and
+   * a provider that lacks the capability. Returns the identity a new session
+   * binds to as well.
+   */
+  requireExecution(
+    binding: Readonly<TargetBinding>,
+    capability: ExecutionCapability,
+  ): { readonly provider: ExecutionProvider; readonly identity: string } {
+    const refusal = this.findExecutionRefusal(binding, capability);
+    const target = this.targets.get(binding.target);
+
+    if (refusal !== null) {
+      throw refusal;
+    }
+
+    if (target === undefined || target.provider === null) {
+      throw new Error(`execution target '${binding.target}' passed its checks without a provider`);
+    }
+
+    return { provider: target.provider, identity: target.identity };
+  }
+
+  // The refusal for running work of a capability on a binding's target, or
+  // null when the target serves it. A null target is a spawn that names
+  // none when the config gives no default, which is always refused.
+  findExecutionRefusal(
+    binding: Readonly<{ target: string | null; targetIdentity: string | null }>,
+    capability: ExecutionCapability,
+  ): DaemonError | null {
+    return findExecutionRefusal(this.targets, this.targetErrors, binding, capability);
+  }
+
+  // The provider a session's harness runs on, or null when its target is
+  // gone from the config or has no provider here.
+  findProvider(s: Session): ExecutionProvider | null {
+    return this.targets.get(s.target)?.provider ?? null;
   }
 
   /**
@@ -134,6 +240,11 @@ export class SessionManager {
     return this.adapters[id] ?? null;
   }
 
+  // Every registered adapter, one per id, in registration order.
+  collectAdapters(): AgentAdapter[] {
+    return Object.values(this.adapters);
+  }
+
   // Hands a live terminal session off to a headless run: the terminal dies,
   // the record lives on as a headless session and keeps its screen history.
   yankHeadless(id: SessionID): Session | null {
@@ -157,26 +268,42 @@ export class SessionManager {
     return s;
   }
 
-  // Registers a fleet entry as a session with no terminal yet, so a
-  // fleet-wide restore can show every incoming session at once; adopting it
-  // later attaches the terminal. Exited entries come back as killed
-  // sessions: still listed and revivable, never auto-adopted.
+  // Registers a fleet entry as a session with no terminal yet, under the
+  // atc session id its row holds, so a fleet-wide restore can show every
+  // incoming session at once; adopting it later attaches the terminal.
+  // Exited entries come back as killed sessions: still listed and revivable,
+  // never auto-adopted. An entry without an agent session id has nothing to
+  // resume, so it comes back exited too.
   restore(entry: FleetEntry): Session {
-    const exited = entry.exited === true;
+    const target = entry.target ?? 'local';
+    const targetIdentity = entry.targetIdentity ?? LOCAL_TARGET_IDENTITY;
+    const refusal = this.findExecutionRefusal({ target, targetIdentity }, 'spawn');
+    const targetRefusal = refusal === null ? null : formatTargetRefusal(refusal.code, target);
+
+    // A session whose target this daemon cannot use comes back exited, so
+    // nothing runs it anywhere else: neither a terminal nor a headless turn.
+    const exited =
+      entry.exited === true || entry.agentSessionID === undefined || targetRefusal !== null;
 
     // An entry whose agent is no longer registered still gets its row, so a
     // backend dropped from the config shows as itself instead of vanishing or
     // reviving under another agent. Adopting a terminal for it is refused.
     let lastMsg = 'waiting to restore';
 
-    if (exited) {
+    if (entry.exited !== true && entry.agentSessionID === undefined) {
+      lastMsg = 'nothing to resume';
+    } else if (entry.exited !== true && targetRefusal !== null) {
+      lastMsg = targetRefusal;
+    } else if (exited) {
       lastMsg = 'killed';
     } else if (this.findAdapter(entry.agent) === null) {
       lastMsg = `no adapter for '${entry.agent}'`;
     }
 
+    const parent = entry.parent ?? null;
+
     const session: Session = {
-      id: mintSessionID(),
+      id: entry.sessionID,
       name: entry.name,
       cwd: entry.cwd,
       kind: 'headless',
@@ -184,17 +311,21 @@ export class SessionManager {
       state: exited ? 'exited' : 'running',
       unread: false,
       lastMsg,
-      agentSessionID: entry.agentSessionID,
+      ...(entry.agentSessionID === undefined ? {} : { agentSessionID: entry.agentSessionID }),
       agent: entry.agent,
       pinned: entry.pinned ?? false,
       lastAttachedAt: entry.lastAttachedAt ?? Date.now(),
       repoRoot: resolveRepoRoot(entry.cwd),
       namedBy: 'auto',
       createdAt: Date.now(),
-      parent: this.findByAgentSessionID(entry.parent)?.id ?? null,
+      parent: parent !== null && this.sessions.some((s) => s.id === parent) ? parent : null,
       ...(entry.prompt === undefined ? {} : { prompt: entry.prompt }),
       ...(entry.result === undefined ? {} : { result: entry.result }),
       ...(entry.transcriptPath === undefined ? {} : { transcriptPath: entry.transcriptPath }),
+      ...(entry.model === undefined ? {} : { model: entry.model }),
+      ...(entry.effort === undefined ? {} : { effort: entry.effort }),
+      target,
+      targetIdentity,
     };
 
     this.sessions.push(session);
@@ -204,14 +335,6 @@ export class SessionManager {
     return session;
   }
 
-  private findByAgentSessionID(agentSessionID: AgentSessionID | undefined): Session | undefined {
-    if (agentSessionID === undefined) {
-      return undefined;
-    }
-
-    return this.sessions.find((s) => s.agentSessionID === agentSessionID);
-  }
-
   // Adopts a headless session back into a terminal: a fresh PTY resumes the
   // same agent session id.
   adoptTerminal(id: SessionID, cols: number, rows: number): Session | null {
@@ -227,14 +350,22 @@ export class SessionManager {
       return null;
     }
 
-    const plan = adapter.planSpawn({ prompt: '', resume: s.agentSessionID });
+    const provider = this.requireExecution(s, 'spawn').provider;
 
-    const pty = spawn(plan.bin, plan.args, {
-      name: 'xterm-256color',
-      cols,
-      rows,
+    const plan = adapter.planSpawn({
+      prompt: '',
+      resume: s.agentSessionID,
+      ...(s.model === undefined ? {} : { model: s.model }),
+      ...(s.effort === undefined ? {} : { effort: s.effort }),
+    });
+
+    const pty = provider.spawnHarness({
+      bin: plan.bin,
+      args: plan.args,
       cwd: s.cwd,
       env: collectCleanEnv({ ATC_SESSION_ID: s.id, ATC_SOCKET: socketPath }),
+      cols,
+      rows,
     });
 
     s.pty = pty;
@@ -259,7 +390,7 @@ export class SessionManager {
       this.emitChange();
     });
 
-    void this.writeFleet();
+    void this.tryWriteFleet(s.id);
     this.onEvent('state', s);
     this.emitChange();
 
@@ -296,7 +427,7 @@ export class SessionManager {
       this.onEvent('state', s);
     }
 
-    void this.writeFleet();
+    void this.tryWriteFleet(s.id);
     this.writeStatus();
     this.emitChange();
 
@@ -319,10 +450,7 @@ export class SessionManager {
     if (result !== undefined) {
       s.result = truncateToBytes(result, 16_384);
       s.lastDetail = truncateDetail(result);
-
-      if (s.agentSessionID !== undefined) {
-        void this.store.updateFleetEntry(s.agentSessionID, { result: s.result });
-      }
+      void this.tryUpdateFleetEntry(s.id, { result: s.result });
     }
 
     this.onEvent('state', s);
@@ -359,7 +487,11 @@ export class SessionManager {
 
   // resume: true opens the agent's own session picker; an agent session id
   // resumes that specific session (fleet restore). parent makes the new
-  // session a sub-session of that one.
+  // session a sub-session of that one. overrides hold the model and effort
+  // the new process runs with, and the session keeps them for every revive.
+  // id is minted here unless the caller minted it ahead of the spawn. target
+  // is the execution target the harness runs on; one this daemon cannot use
+  // refuses the spawn before anything starts.
   spawn(
     cwd: string,
     name: string,
@@ -370,6 +502,9 @@ export class SessionManager {
     namedBy: 'user' | 'auto' = 'auto',
     agent: AgentID = 'claude',
     parent: SessionID | null = null,
+    overrides: SpawnOverrides = {},
+    id: SessionID = mintSessionID(),
+    target = 'local',
   ): Session {
     const adapter = this.findAdapter(agent);
 
@@ -377,15 +512,21 @@ export class SessionManager {
       throw new Error(`no adapter for agent '${agent}'`);
     }
 
-    const id = mintSessionID();
-    const plan = adapter.planSpawn({ prompt, resume });
+    const execution = this.requireExecution({ target, targetIdentity: null }, 'spawn');
+    const provider = execution.provider;
 
-    const pty = spawn(plan.bin, plan.args, {
-      name: 'xterm-256color',
-      cols,
-      rows,
+    // The repository root resolves before the process starts: resolving it
+    // can throw, and a spawn that throws must leave nothing running.
+    const repoRoot = resolveRepoRoot(cwd);
+    const plan = adapter.planSpawn({ prompt, resume, ...overrides });
+
+    const pty = provider.spawnHarness({
+      bin: plan.bin,
+      args: plan.args,
       cwd,
       env: collectCleanEnv({ ATC_SESSION_ID: id, ATC_SOCKET: socketPath }),
+      cols,
+      rows,
     });
 
     let initialMsg = prompt;
@@ -407,11 +548,15 @@ export class SessionManager {
       agent,
       pinned: false,
       lastAttachedAt: Date.now(),
-      repoRoot: resolveRepoRoot(cwd),
+      repoRoot,
       namedBy,
       createdAt: Date.now(),
       parent,
       ...(prompt === '' ? {} : { prompt }),
+      ...(overrides.model === undefined ? {} : { model: overrides.model }),
+      ...(overrides.effort === undefined ? {} : { effort: overrides.effort }),
+      target,
+      targetIdentity: execution.identity,
     };
 
     pty.onData((d) => {
@@ -434,13 +579,34 @@ export class SessionManager {
     });
 
     this.sessions.push(session);
-    void this.writeFleet();
+    void this.tryWriteFleet(session.id);
     this.writeStatus();
     this.onEvent('added', session);
 
     return session;
   }
 
+  // Takes back a spawn that failed after its process started: the process
+  // dies and the session leaves the list and the fleet, so the spawn leaves
+  // nothing behind. It resolves only once the fleet without the session is
+  // durable, and throws when the kill or that write fails. A session that
+  // never registered is left alone.
+  async removeFailedSpawn(id: SessionID): Promise<void> {
+    const s = this.sessions.find((x) => x.id === id);
+
+    if (s === undefined) {
+      return;
+    }
+
+    s.pty?.kill();
+    s.pty = null;
+
+    this.remove(s);
+    this.emitChange();
+
+    await this.writeFleet();
+  }
+
   collectDescriptors(): SessionDescriptor[] {
     return this.sessions.map((s) => ({
       id: s.id,
@@ -461,6 +627,7 @@ export class SessionManager {
       alive: s.pty !== null || (s.kind === 'headless' && s.state !== 'exited'),
       canEject: (this.findAdapter(s.agent)?.headlessRunner ?? null) !== null,
       ...(s.parent === null ? {} : { parent: s.parent }),
+      locator: { daemonID: this.store.daemonID, targetID: s.target },
     }));
   }
 
@@ -579,12 +746,12 @@ export class SessionManager {
     }
 
     // A fleet rewrite marks every session without a PTY as exited, so only a
-    // new agent session id (which adds or re-keys a row) takes it. Anything
-    // else touches this session's own row.
+    // new agent session id takes it. Anything else touches this session's
+    // own row.
     if (persist) {
-      void this.writeFleet();
-    } else if (s.agentSessionID !== undefined) {
-      void this.store.updateFleetEntry(s.agentSessionID, rowUpdate);
+      void this.tryWriteFleet(s.id);
+    } else {
+      void this.tryUpdateFleetEntry(s.id, rowUpdate);
     }
 
     if (dirty) {
@@ -614,7 +781,7 @@ export class SessionManager {
       s.namedBy = update.namedBy;
     }
 
-    void this.writeFleet();
+    void this.tryWriteFleet(s.id);
     this.onEvent('renamed', s);
     this.emitChange();
   }
@@ -639,7 +806,7 @@ export class SessionManager {
 
     s.unread = false;
     s.lastAttachedAt = Date.now();
-    void this.writeFleet();
+    void this.tryWriteFleet(s.id);
 
     // Attaching answers the attention request: a still-pending prompt
     // re-flags it via the next notification.
@@ -754,42 +921,76 @@ export class SessionManager {
   // Deliberate kills rewrite the file; unexpected session/atc deaths do not,
   // so the last known fleet survives for `R` restore. Sessions whose
   // terminal is gone persist as exited entries, so the killed archive
-  // survives a daemon restart too.
+  // survives a daemon restart too. A session the agent has not yet given
+  // its own session id persists as well, under its atc session id alone.
   async writeFleet(): Promise<void> {
     const fleet: FleetEntry[] = [];
 
     for (const s of this.sessions) {
-      if (s.agentSessionID === undefined) {
-        continue;
-      }
-
       const live = s.pty !== null || (s.kind === 'headless' && s.state !== 'exited');
 
-      // The link persists by the parent's agent session id, since atc ids
-      // are minted afresh on restore.
-      const parent =
-        s.parent === null
-          ? undefined
-          : this.sessions.find((x) => x.id === s.parent)?.agentSessionID;
-
       fleet.push({
+        sessionID: s.id,
         name: s.name,
         cwd: s.cwd,
-        agentSessionID: s.agentSessionID,
+        ...(s.agentSessionID === undefined ? {} : { agentSessionID: s.agentSessionID }),
         agent: s.agent,
         ...(s.pinned ? { pinned: true } : {}),
         lastAttachedAt: s.lastAttachedAt,
         ...(live ? {} : { exited: true }),
-        ...(parent === undefined ? {} : { parent }),
+        ...(s.parent === null ? {} : { parent: s.parent }),
         ...(s.prompt === undefined ? {} : { prompt: s.prompt }),
         ...(s.result === undefined ? {} : { result: s.result }),
         ...(s.transcriptPath === undefined ? {} : { transcriptPath: s.transcriptPath }),
+        ...(s.model === undefined ? {} : { model: s.model }),
+        ...(s.effort === undefined ? {} : { effort: s.effort }),
+        target: s.target,
+        targetIdentity: s.targetIdentity,
       });
     }
 
     await this.store.writeFleet(fleet);
   }
 
+  // A write nobody awaits that fails leaves the stored rows as they were,
+  // and must not take the daemon down unhandled. A stale ownership epoch is
+  // expected and surfaces on the next write a request awaits; any other
+  // failure is logged with the session whose change it was writing.
+  private async tryWriteFleet(sessionID: SessionID): Promise<boolean> {
+    try {
+      await this.writeFleet();
+    } catch (error) {
+      this.logStoreFailure(sessionID, error);
+
+      return false;
+    }
+
+    return true;
+  }
+
+  private async tryUpdateFleetEntry(id: SessionID, fields: FleetEntryUpdate): Promise<boolean> {
+    try {
+      await this.store.updateFleetEntry(id, fields);
+    } catch (error) {
+      this.logStoreFailure(id, error);
+
+      return false;
+    }
+
+    return true;
+  }
+
+  private logStoreFailure(sessionID: SessionID, error: unknown): void {
+    if (error instanceof DaemonError && error.code === 'stale_epoch') {
+      return;
+    }
+
+    const code = error instanceof DaemonError ? error.code : 'internal';
+    const message = error instanceof Error ? error.message : String(error);
+
+    this.log(`atc fleet write for session ${sessionID} failed (${code}): ${message}`);
+  }
+
   countStates() {
     return countSessionStates(this.sessions);
   }
@@ -887,3 +1088,24 @@ export function sortGroupedSessionViews<
 
   return [...buckets.values()].flat();
 }
+
+// A target refusal as a session's last message, short enough for a list row.
+function formatTargetRefusal(code: ErrorCode, target: string): string {
+  if (code === 'target_config_invalid') {
+    return `target '${target}' misconfigured`;
+  }
+
+  if (code === 'unknown_target') {
+    return `no target '${target}'`;
+  }
+
+  if (code === 'target_changed') {
+    return `target '${target}' changed`;
+  }
+
+  if (code === 'target_unavailable') {
+    return `target '${target}' unavailable`;
+  }
+
+  return `target '${target}' cannot start a terminal`;
+}

package/src/daemon/start-headless-run.ts

@@ -16,6 +16,9 @@ const PERMISSION_MODES = [
   'dontAsk',
 ] as const;
 
+// The effort levels the Agent SDK accepts.
+const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'] as const;
+
 interface HeadlessRunOptions {
   readonly claudeBin: string;
   readonly cwd: string;
@@ -25,6 +28,8 @@ interface HeadlessRunOptions {
   readonly settings?: string;
   readonly sessionID?: SessionID;
   readonly pluginDir?: string;
+  readonly model?: string;
+  readonly effort?: string;
 }
 
 interface HeadlessRunHooks {
@@ -52,6 +57,7 @@ export function startHeadlessRun(
   void (async () => {
     try {
       const mode = PERMISSION_MODES.find((m) => m === opts.permissionMode);
+      const effort = EFFORT_LEVELS.find((level) => level === opts.effort);
       let stderrTail = '';
 
       // The SDK is the heaviest module in the daemon's graph, and only a
@@ -75,6 +81,11 @@ export function startHeadlessRun(
           ...(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 } }),

package/src/daemon/start-headless-turn.ts

@@ -10,8 +10,9 @@ import { truncateSummary } from './truncate-summary';
  * runner, wires the run's output and completion into the session manager,
  * passes the turn's start and end to the event trail the way a terminal
  * turn's hooks do, and records the live handle on the session's runtime. Returns false
- * without starting anything when the session is unknown, its agent has no
- * headless runner, or a turn is already running.
+ * without starting anything when the session is unknown or exited, its
+ * agent has no headless runner, its target does not serve headless turns,
+ * or a turn is already running.
  */
 export function startHeadlessTurn(
   mgr: SessionManager,
@@ -28,6 +29,12 @@ export function startHeadlessTurn(
     return false;
   }
 
+  // The runner runs on the daemon's own host, so a session whose target
+  // does not serve headless turns never reaches it.
+  if (s.state === 'exited' || mgr.findExecutionRefusal(s, 'headless') !== null) {
+    return false;
+  }
+
   mgr.updateSurfaceState(sessionID, 'running', 'headless turn running');
 
   recordTurnEvent(sessionID, { kind: 'prompt-submitted', detail: truncateDetail(prompt) });
@@ -39,6 +46,8 @@ export function startHeadlessTurn(
       ...(s.agentSessionID === undefined ? {} : { resume: s.agentSessionID }),
       permissionMode: 'auto',
       sessionID,
+      ...(s.model === undefined ? {} : { model: s.model }),
+      ...(s.effort === undefined ? {} : { effort: s.effort }),
     },
     {
       onOutput: (text) => {