@zgeoff/atc 2.39.0 → 2.41.0

package/README.md

@@ -91,11 +91,12 @@ zoxide is installed. A typed path such as `~/pro` completes like a shell. Inside
 your statusline gains a fleet segment, so `● 2 need you: auth-bug` is visible without opening the
 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. When the running daemon speaks another protocol version, `atc` asks before it restarts the
-daemon, since the restart ends every session the daemon hosts.
+When the daemon restarts, it restores the fleet by itself and every session respawns from its
+transcript; set `restoreFleetOnRestart` to `false` to wait for `R` on the home screen instead. 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. 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.39.0",
+  "version": "2.41.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

@@ -31,7 +31,6 @@ export interface SpawnOverrides {
   readonly trustClonedWorkspace?: boolean;
   readonly model?: string;
   readonly effort?: string;
-  readonly resumeInterruptedTurns?: boolean;
 }
 
 export interface SpawnPlan {
@@ -45,12 +44,17 @@ export interface SpawnPlan {
  * files unpack into. `auth` is given when the harness takes its credential
  * from impd's broker: the revision of the host's runtime auth binding it
  * launches under, which keys any settings the agent writes for it, and the
- * placeholder variables the harness holds in place of a credential.
+ * placeholder variables the harness holds in place of a credential, and
+ * the variables its auth profiles set.
  */
 export interface GuestPaths {
   readonly atc: string | null;
   readonly dir: string;
-  readonly auth?: { readonly revision: number; readonly env: Readonly<Record<string, string>> };
+  readonly auth?: {
+    readonly revision: number;
+    readonly env: Readonly<Record<string, string>>;
+    readonly profileEnv: Readonly<Record<string, string>>;
+  };
 }
 
 /**

package/src/agents/claude-adapter.ts

@@ -290,7 +290,11 @@ export class ClaudeAdapter implements AgentAdapter {
     const padding = typeof userSettings === 'string' ? findStatuslinePadding(userSettings) : 0;
 
     const settings = buildHookSettings(
-      this.buildSettingsProfile({ ...auth.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' }),
+      this.buildSettingsProfile({
+        ...auth.profileEnv,
+        ...auth.env,
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+      }),
       padding,
       argv,
     );
@@ -312,7 +316,7 @@ export class ClaudeAdapter implements AgentAdapter {
         ),
         ...Object.fromEntries(bridge),
       },
-      env: { ...launch.env, ...auth.env },
+      env: { ...launch.env, ...auth.profileEnv, ...auth.env },
     };
   }
 

package/src/agents/gateway-adapter.ts

@@ -224,6 +224,7 @@ export class GatewayAdapter implements AgentAdapter {
         env: {
           ...this.gateway.env,
           ANTHROPIC_BASE_URL: this.gateway.baseURL,
+          ...guest.auth.profileEnv,
           ...guest.auth.env,
           CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
         },
@@ -253,7 +254,7 @@ export class GatewayAdapter implements AgentAdapter {
         ...buildClaudeConfigSeed(null),
         ...Object.fromEntries(bridge),
       },
-      env: { ...launch.env, ...guest.auth.env },
+      env: { ...launch.env, ...guest.auth.profileEnv, ...guest.auth.env },
     };
   }
 
@@ -352,19 +353,31 @@ export class GatewayAdapter implements AgentAdapter {
   }
 
   // The Claude CLI sends ANTHROPIC_AUTH_TOKEN as a bearer authorization
-  // header, the one pairing atc binds, so the placeholders must be that
-  // variable alone, holding the placeholder, for a profile whose rule on
-  // the base URL's host sets that header. Any other variable would put the
-  // placeholder in a header the broker never fills.
+  // header, the one pairing atc binds, so the placeholders must include that
+  // variable, holding the placeholder, for a profile whose rule on the base
+  // URL's host sets that header. Any other variable passes through to the
+  // session for a tool in it, whose own host a selected profile covers,
+  // except a variable the CLI reads as its own credential, which would
+  // compete with the bearer variable and put the placeholder in a header
+  // the broker never fills, and the variable that names the session's
+  // Claude config folder, which atc sets itself.
   private findPlaceholderRefusal(
     env: Readonly<Record<string, string>>,
     profiles: readonly string[],
   ): DaemonError | null {
     const keys = Object.keys(env);
 
-    if (keys.length !== 1 || keys[0] !== BEARER_VARIABLE) {
+    if (!keys.includes(BEARER_VARIABLE)) {
       return this.buildPlaceholderRefusal(
-        `needs ${BEARER_VARIABLE} as its only placeholder variable, which the broker fills as a bearer authorization header; it has ${keys.length === 0 ? 'none' : keys.join(', ')}`,
+        `needs ${BEARER_VARIABLE} among its placeholder variables, which the broker fills as a bearer authorization header; it has ${keys.length === 0 ? 'none' : keys.join(', ')}`,
+      );
+    }
+
+    const competing = keys.find((key) => COMPETING_CREDENTIAL_VARIABLES.has(key));
+
+    if (competing !== undefined) {
+      return this.buildPlaceholderRefusal(
+        `cannot use ${competing} as a placeholder variable, since the Claude CLI reads it as its own credential or config folder beside ${BEARER_VARIABLE}`,
       );
     }
 
@@ -444,6 +457,15 @@ export class GatewayAdapter implements AgentAdapter {
 const BEARER_VARIABLE = 'ANTHROPIC_AUTH_TOKEN';
 const PLACEHOLDER = 'imp-broker-placeholder';
 
+// Variables the Claude CLI reads as its own credential beside the bearer
+// variable, plus the one that points it at the session's config folder,
+// whose launch value a placeholder would overwrite.
+const COMPETING_CREDENTIAL_VARIABLES: ReadonlySet<string> = new Set([
+  'ANTHROPIC_API_KEY',
+  'CLAUDE_CODE_OAUTH_TOKEN',
+  'CLAUDE_CONFIG_DIR',
+]);
+
 // The Claude CLI's mode that asks a person before each action.
 const MANUAL_PERMISSION_MODE = 'default';
 

package/src/build-migrated-config.ts

@@ -3,6 +3,7 @@ import { parseConfig } from './shared/config';
 import { formatJSONKind } from './shared/format-json-kind';
 import { formatMixedAgentKeys } from './shared/format-mixed-agent-keys';
 import { LEGACY_AGENT_KEYS } from './shared/legacy-agent-keys';
+import { REMOVED_CONFIG_KEYS } from './shared/removed-config-keys';
 import { isRecord } from './shared/report';
 
 /**
@@ -17,7 +18,8 @@ type MigratedConfig =
 
 /**
  * Rewrites a config.json that uses the old agent keys so it holds the same
- * agents under `agents`. The old keys are removed and `agents` takes the
+ * agents under `agents`, and drops every key atc no longer reads. A file
+ * that holds `agents` and a removed key is rewritten without the key. The old keys are removed and `agents` takes the
  * place of the first of them, or the end of the file when it sets none. Each
  * entry holds only the fields that differ from a default. Values are copied
  * and never reported, so a note names a key and a reason only.
@@ -31,11 +33,26 @@ export function buildMigratedConfig(raw: unknown): MigratedConfig {
   }
 
   const present = Object.keys(raw).filter((key) => LEGACY_AGENT_KEYS.includes(key));
+  const removed = REMOVED_CONFIG_KEYS.filter((key) => Object.hasOwn(raw, key));
+
+  const removedNotes = removed.map(
+    (key) => `atc config migrate: ${key} is dropped: atc no longer reads it`,
+  );
 
   if (Object.hasOwn(raw, 'agents')) {
-    return present.length === 0
-      ? { kind: 'current' }
-      : { kind: 'unusable', detail: formatMixedAgentKeys(present) };
+    if (present.length > 0) {
+      return { kind: 'unusable', detail: formatMixedAgentKeys(present) };
+    }
+
+    if (removed.length === 0) {
+      return { kind: 'current' };
+    }
+
+    return {
+      kind: 'migrated',
+      text: `${JSON.stringify(Object.fromEntries(Object.entries(raw).filter(([key]) => !removed.includes(key))), null, 2)}\n`,
+      notes: removedNotes,
+    };
   }
 
   const config = parseConfig(raw);
@@ -49,6 +66,10 @@ export function buildMigratedConfig(raw: unknown): MigratedConfig {
   let placed = false;
 
   for (const [key, value] of Object.entries(raw)) {
+    if (removed.includes(key)) {
+      continue;
+    }
+
     if (!LEGACY_AGENT_KEYS.includes(key)) {
       migrated[key] = value;
     } else if (!placed) {
@@ -64,7 +85,10 @@ export function buildMigratedConfig(raw: unknown): MigratedConfig {
   return {
     kind: 'migrated',
     text: `${JSON.stringify(migrated, null, 2)}\n`,
-    notes: collectDroppedGateways(raw['gateways'], config.agents, config.agentErrors),
+    notes: [
+      ...collectDroppedGateways(raw['gateways'], config.agents, config.agentErrors),
+      ...removedNotes,
+    ],
   };
 }
 

package/src/cli.ts

@@ -435,6 +435,12 @@ async function runDaemon(listenArg: string | null, tokenFile: string | null): Pr
     );
   }
 
+  if (cfg.removedKeys.length > 0) {
+    console.error(
+      `atc daemon: config: config.json sets ${cfg.removedKeys.join(', ')}, which atc no longer reads; run 'atc config migrate' to drop it`,
+    );
+  }
+
   const sources = sourceOrder.buildSources(
     builtinSources.collectBuiltinSources({
       roots: cfg.dirs.roots,
@@ -489,7 +495,7 @@ async function runDaemon(listenArg: string | null, tokenFile: string | null): Pr
         ? {}
         : { listen: { host: listen.host, port: listen.port, tokenFile } }),
       restoreBootTimeoutMs,
-      resumeInterruptedTurns: cfg.resumeInterruptedTurns,
+      restoreFleetOnRestart: cfg.restoreFleetOnRestart,
       ...(Number.isFinite(graceOverride) && graceOverride >= 0
         ? { tapGraceMs: graceOverride }
         : {}),

package/src/daemon/build-auth-binding.ts

@@ -11,8 +11,9 @@ import { sortJSONKeys } from '../shared/sort-json-keys';
  * What a session's runtime is bound to through impd's broker: every
  * profile its gateway's selection reaches, the secrets they need impd to
  * hold with exactly these rules, the placeholder variables in place of a
- * credential, and the endpoint. `hash` covers the secrets and their rules
- * alone, so a change to a profile the binding does not reach leaves it as
+ * credential, the variables the profiles set, and the endpoint. `hash`
+ * covers the secrets and their rules, and the profile variables when there
+ * are any, so a change to a profile the binding does not reach leaves it as
  * it was, and a change to one it reaches gives another hash.
  */
 export interface AuthBinding {
@@ -21,6 +22,7 @@ export interface AuthBinding {
   readonly profiles: readonly string[];
   readonly secrets: readonly ResolvedAuthSecret[];
   readonly placeholderEnv: Readonly<Record<string, string>>;
+  readonly profileEnv: Readonly<Record<string, string>>;
   readonly hash: string;
 }
 
@@ -29,7 +31,7 @@ type AuthGateway = Pick<GatewayConfig, 'id' | 'baseURL'> & { readonly auth: Gate
 /**
  * Plans the binding a gateway's auth asks for against the current auth
  * profiles, or the problem that refuses it. The hash is the SHA-256 of the
- * resolved secrets as canonical JSON, with each list sorted, so the order
+ * resolved secrets (and profile variables, when set) as canonical JSON, with each list sorted, so the order
  * of the selection or of the config never changes it.
  */
 export function buildAuthBinding(
@@ -43,6 +45,8 @@ export function buildAuthBinding(
   }
 
   const secrets = resolution.resolved.secrets;
+  const profileEnv = resolution.resolved.env;
+  const hashed = Object.keys(profileEnv).length === 0 ? { secrets } : { secrets, profileEnv };
 
   return {
     binding: {
@@ -51,8 +55,9 @@ export function buildAuthBinding(
       profiles: resolution.resolved.profiles,
       secrets,
       placeholderEnv: gateway.auth.placeholderEnv,
+      profileEnv,
       hash: createHash('sha256')
-        .update(JSON.stringify(sortJSONKeys({ secrets })))
+        .update(JSON.stringify(sortJSONKeys(hashed)))
         .digest('hex'),
     },
   };

package/src/daemon/daemon-connection.ts

@@ -1034,9 +1034,6 @@ export class DaemonConnection {
           ...(data.trustClonedWorkspace === undefined
             ? {}
             : { trustClonedWorkspace: data.trustClonedWorkspace }),
-          ...(data.resumeInterruptedTurns === undefined
-            ? {}
-            : { resumeInterruptedTurns: data.resumeInterruptedTurns }),
         },
         target,
         workspace: data.workspace ?? null,

package/src/daemon/daemon.ts

@@ -162,10 +162,9 @@ export interface DaemonOptions {
   readonly restoreBootTimeoutMs?: number;
   readonly tapGraceMs?: number;
 
-  // Whether a fleet restore sends a session that was mid-turn when the
-  // previous daemon stopped one message to carry on, for a session spawned
-  // without its own choice; off when unset.
-  readonly resumeInterruptedTurns?: boolean;
+  // Whether the daemon restores the stored fleet by itself once it is
+  // listening, when that fleet holds sessions; off when unset.
+  readonly restoreFleetOnRestart?: boolean;
 
   // How long a confirm token from `session.forget` stays usable.
   readonly forgetConfirmMs?: number;
@@ -291,11 +290,6 @@ const LOCK_WAIT_MS = 2000;
  * because transports guarantee byte integrity and such a line means a buggy
  * or hostile peer.
  */
-// The sender and opening of the message a restore sends a session whose
-// turn the previous daemon's stop cut off.
-const RESUME_SENDER = 'atc';
-const RESUME_LEAD = 'atc restarted the daemon';
-
 export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
   let stopDaemon: (() => Promise<void>) | null = null;
 
@@ -1327,37 +1321,6 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     return record;
   };
 
-  const startedAt = new Date().toISOString();
-
-  // Sends a restored session the message that carries on a turn the
-  // previous daemon's stop cut off. A resume message still pending from an
-  // earlier restart covers this one, so a session never holds two.
-  const sendResumeMessage = async (s: Session): Promise<void> => {
-    const pending = await store.collectPendingMessages(buildMessageOwner(s));
-
-    if (
-      pending.some((record) => record.from === RESUME_SENDER && record.text.startsWith(RESUME_LEAD))
-    ) {
-      return;
-    }
-
-    const refusal = findMessageRefusal(s.id);
-
-    if (refusal !== null) {
-      mgr.log(`atc sent session ${s.id} no resume message (${refusal})`);
-
-      return;
-    }
-
-    await writeAcceptedMessage(
-      s.id,
-      RESUME_SENDER,
-      `${RESUME_LEAD} at ${startedAt}; your last turn was interrupted. Check the state of anything you had in flight, then continue.`,
-      mintMessageID(),
-      () => {},
-    );
-  };
-
   // A retried send answers with the message's current status, so a caller
   // that lost the first answer learns where its message stands now.
   const loadMessageReplay = async (
@@ -1396,6 +1359,44 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
 
   const sources = opts.sources ?? [];
 
+  // The restore in flight, from its first call until its staggered terminal
+  // adoption finishes. A restore requested meanwhile joins it, so the fleet
+  // never registers twice at once.
+  let fleetRestore: Promise<number> | null = null;
+
+  const runFleetRestore = (cols: number, rows: number): Promise<number> => {
+    if (fleetRestore !== null) {
+      return fleetRestore;
+    }
+
+    const restored = Promise.withResolvers<number>();
+
+    fleetRestore = restored.promise;
+
+    void (async () => {
+      try {
+        const result = await restoreFleet({
+          mgr,
+          store,
+          findRuntime,
+          cols,
+          rows,
+          capMs: opts.restoreBootTimeoutMs ?? 0,
+        });
+
+        restored.resolve(result.restored);
+
+        await result.settled;
+      } catch (error) {
+        restored.reject(error);
+      } finally {
+        fleetRestore = null;
+      }
+    })();
+
+    return restored.promise;
+  };
+
   const ctx: DaemonContext = {
     build: opts.build,
     daemonID: store.daemonID,
@@ -1825,17 +1826,7 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     getEffectiveDims: (sessionID) =>
       attachments.findEffectiveDims(sessionID) ??
       runtimes.get(sessionID)?.dims ?? { cols: 80, rows: 24 },
-    restoreFleet: (cols, rows) =>
-      restoreFleet({
-        mgr,
-        store,
-        findRuntime,
-        cols,
-        rows,
-        capMs: opts.restoreBootTimeoutMs ?? 0,
-        resumeInterruptedTurns: opts.resumeInterruptedTurns ?? false,
-        sendResumeMessage,
-      }),
+    restoreFleet: runFleetRestore,
     readSessionRecord: async (id, access) => {
       const s = mgr.sessions.find((x) => x.id === id);
 
@@ -2275,6 +2266,27 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
     listenPort: tcpListener?.port ?? null,
   });
 
+  // The stored fleet restores once per start, at the size a restored
+  // terminal takes until its first attach resizes it. A failure is logged
+  // and never stops the daemon.
+  const tryRunFleetRestore = async (): Promise<void> => {
+    try {
+      await runFleetRestore(80, 24);
+    } catch (error) {
+      mgr.log(
+        `atc could not restore the fleet (${error instanceof Error ? error.message : String(error)})`,
+      );
+    }
+  };
+
+  if (opts.restoreFleetOnRestart === true) {
+    const stored = await store.loadFleet();
+
+    if (stored.length > 0) {
+      void tryRunFleetRestore();
+    }
+  }
+
   return {
     stop: stopDaemon,
     countClients: () => clients.size,

package/src/daemon/restore-fleet.ts

@@ -16,12 +16,15 @@ export interface RestoreFleetParams {
   // it has booted before moving on regardless; zero waits on the signal
   // alone.
   readonly capMs: number;
+}
+
+export interface RestoreFleetResult {
+  // How many sessions the restore registered.
+  readonly restored: number;
 
-  // Whether a session spawned without its own choice gets one message to
-  // carry on a turn the previous daemon's stop cut off, and how that
-  // message is sent once the session's terminal is adopted.
-  readonly resumeInterruptedTurns: boolean;
-  readonly sendResumeMessage: (s: Session) => Promise<void>;
+  // Resolves once the staggered terminal adoption behind the restore has
+  // finished, also when it failed, and at once when nothing was queued.
+  readonly settled: Promise<void>;
 }
 
 /**
@@ -29,18 +32,15 @@ export interface RestoreFleetParams {
  * the rest by recency, registers every one as a terminal-less session so
  * the whole fleet lists at once, then adopts terminals one at a time,
  * waiting for each session to report it has booted before starting the
- * next. A session that was mid-turn when the previous daemon stopped, and
- * that resumes interrupted turns, gets one message to carry on once its
- * terminal is adopted.
+ * next.
  */
-export async function restoreFleet(params: RestoreFleetParams): Promise<number> {
+export async function restoreFleet(params: RestoreFleetParams): Promise<RestoreFleetResult> {
   const mgr = params.mgr;
   const store = params.store;
   const findRuntime = params.findRuntime;
   const cols = params.cols;
   const rows = params.rows;
   const capMs = params.capMs;
-  const sendResumeMessage = params.sendResumeMessage;
 
   const hasLiveSession = (entry: FleetEntry) =>
     mgr.sessions.some(
@@ -92,33 +92,11 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
     .filter((r) => r.revive || r.session.state !== 'exited')
     .map((r) => r.session);
 
-  // Only a session this restore registers comes from the previous daemon's
-  // fleet; a listed one this daemon already ran is revived by hand. The
-  // trail is read before any terminal is adopted, since a revived agent's
-  // own events move it on.
-  const interrupted = await collectInterruptedTurns(
-    mgr,
-    store,
-    registered.filter((r) => !r.revive && r.session.state !== 'exited').map((r) => r.session),
-    params.resumeInterruptedTurns,
-  );
-
   // A session whose target refuses to start a terminal stays listed without
-  // one, and the restore moves on to the next. A resume message that fails
-  // to send is logged, and the session runs on without it.
+  // one, and the restore moves on to the next.
   const adoptQueued = async (s: Session): Promise<boolean> => {
     const adopted = await tryAdoptTerminal(mgr, s.id, cols, rows);
 
-    if (adopted !== null && interrupted.has(s.id)) {
-      try {
-        await sendResumeMessage(s);
-      } catch (error) {
-        mgr.log(
-          `atc could not send session ${s.id} its resume message (${error instanceof Error ? error.message : String(error)})`,
-        );
-      }
-    }
-
     return adopted !== null;
   };
 
@@ -159,7 +137,7 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   const [first, ...rest] = queued;
 
   if (first === undefined) {
-    return registered.length;
+    return { restored: registered.length, settled: Promise.resolve() };
   }
 
   // The first terminal attaches before the restore answers so a caller can
@@ -200,42 +178,17 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
 
   const firstBooted = firstAdopted ? first : null;
 
-  void adoptRest(firstBooted);
-
-  return registered.length;
-}
-
-// The sessions whose last turn event in the trail is a submitted prompt:
-// the previous daemon stopped while their turn ran. A session's own choice
-// beats the config, and an agent that takes no atc messages has no path for
-// the resume message. Only a harness on the daemon's own machine ends with
-// the daemon; one on a host with a lifecycle of its own runs on, so its
-// turn was never cut off and a revive attaches to it as it stands.
-async function collectInterruptedTurns(
-  mgr: SessionManager,
-  store: StateStore,
-  sessions: readonly Session[],
-  configured: boolean,
-): Promise<ReadonlySet<SessionID>> {
-  const interrupted = new Set<SessionID>();
-
-  for (const s of sessions) {
-    if (
-      !(s.resumeInterruptedTurns ?? configured) ||
-      s.attachment !== 'local' ||
-      mgr.findAdapter(s.agent)?.takesMessages !== true
-    ) {
-      continue;
-    }
-
-    const kind = await store.findLatestTurnKind(s.id, s.agentSessionID);
-
-    if (kind === 'prompt-submitted') {
-      interrupted.add(s.id);
+  const adoptRestLogged = async (): Promise<void> => {
+    try {
+      await adoptRest(firstBooted);
+    } catch (error) {
+      mgr.log(
+        `atc could not finish restoring the fleet (${error instanceof Error ? error.message : String(error)})`,
+      );
     }
-  }
+  };
 
-  return interrupted;
+  return { restored: registered.length, settled: adoptRestLogged() };
 }
 
 // A stored entry matches a listed session by its atc session id, or by its

package/src/daemon/sessions.ts

@@ -185,10 +185,6 @@ export interface Session {
   // The epoch of the session's latest harness start or attach, which the
   // daemon's bridge to that harness is bound to; 0 before the first.
   bridgeEpoch: number;
-
-  // Whether a fleet restore sends the session one message to carry on a
-  // turn a daemon restart cut off; absent follows the daemon's config.
-  resumeInterruptedTurns?: boolean;
 }
 
 // A session's ready workspace and the variables its harnesses go without.
@@ -606,9 +602,6 @@ export class SessionManager {
       attachment: this.hasHostLifecycle(target) ? 'detached' : 'local',
       hostKey: entry.hostKey ?? entry.sessionID,
       bridgeEpoch: 0,
-      ...(entry.resumeInterruptedTurns === undefined
-        ? {}
-        : { resumeInterruptedTurns: entry.resumeInterruptedTurns }),
     };
 
     this.sessions.push(session);
@@ -1179,9 +1172,6 @@ export class SessionManager {
       suspended: false,
       hostKey,
       bridgeEpoch: binding.epoch,
-      ...(overrides.resumeInterruptedTurns === undefined
-        ? {}
-        : { resumeInterruptedTurns: overrides.resumeInterruptedTurns }),
     };
 
     this.attachHarness(session, pty, this.hasHostLifecycle(target));
@@ -2024,7 +2014,7 @@ export class SessionManager {
         : {
             atc: guest.atc,
             dir,
-            auth: await this.planGuestAuth(hostKey, auth.mode, auth.binding.placeholderEnv),
+            auth: await this.planGuestAuth(hostKey, auth.mode, auth.binding),
           };
 
     const plan =
@@ -2110,11 +2100,15 @@ export class SessionManager {
   private async planGuestAuth(
     hostKey: SessionID,
     mode: HarnessAuthSetup['mode'],
-    placeholderEnv: Readonly<Record<string, string>>,
+    binding: Pick<AuthBinding, 'placeholderEnv' | 'profileEnv'>,
   ): Promise<NonNullable<GuestPaths['auth']>> {
     const held = mode === 'create' ? null : await this.requireAuthBinder().findBinding(hostKey);
 
-    return { revision: held?.revision ?? 1, env: placeholderEnv };
+    return {
+      revision: held?.revision ?? 1,
+      env: binding.placeholderEnv,
+      profileEnv: binding.profileEnv,
+    };
   }
 
   // Creates the binding of a host a spawn provisions, or verifies the one
@@ -3050,9 +3044,6 @@ export class SessionManager {
         targetIdentity: s.targetIdentity,
         ...(s.desired === 'run' ? {} : { desired: s.desired }),
         ...(s.hostKey === s.id ? {} : { hostKey: s.hostKey }),
-        ...(s.resumeInterruptedTurns === undefined
-          ? {}
-          : { resumeInterruptedTurns: s.resumeInterruptedTurns }),
       });
     }
 

package/src/mcp/mcp-tools.ts

@@ -65,9 +65,6 @@ const SPAWN_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
     trustClonedWorkspace: SPAWN_SCHEMA.shape.trustClonedWorkspace.describe(
       "Trust the exact verified clone for this launch. An explicit true or false overrides the configured target trustClonedWorkspace default; omitting both keeps trust off. Requires a workspace source and either stock Claude on the local target, which adds trust for the clone root alone to the user's Claude config, or, on an imp target, a brokered Claude gateway or stock Claude signed in through the broker, each with isolated guest config; other launches are refused. Accepts repository configuration and helpers without changing tool permission mode. Existing guest config is preserved.",
     ),
-    resumeInterruptedTurns: SPAWN_SCHEMA.shape.resumeInterruptedTurns.describe(
-      "Whether atc sends the session one message to carry on when a daemon restart cuts off its turn. The message goes out when the fleet is restored, only to a session whose last recorded event was a submitted prompt, and only to an agent that takes atc messages. Omit it to follow the daemon's resumeInterruptedTurns config, which is off by default.",
-    ),
     detached: z
       .boolean()
       .optional()
@@ -423,7 +420,6 @@ export const MCP_TOOLS: readonly MCPToolDefinition[] = [
         target: 'spawn.target',
         workspace: 'spawn.workspace',
         trustClonedWorkspace: 'spawn.workspace.trust',
-        resumeInterruptedTurns: 'spawn.resumeInterruptedTurns',
       },
     },
   },

package/src/mcp/require-daemon-features.ts

@@ -26,7 +26,6 @@ const FEATURE_USES: Readonly<Record<DaemonFeature, string>> = {
   'transport.tcp': 'a TCP connection to the daemon',
   'idempotency.replayOnly': 'a resend that only replays a held idempotency key',
   'session.auth': 'session.auth.revoke and session.auth.rebind',
-  'spawn.resumeInterruptedTurns': "atc_session_spawn's resumeInterruptedTurns",
 };
 
 /**

package/src/mcp/run-tool.ts

@@ -58,9 +58,6 @@ export function runTool(
         ...(args['trustClonedWorkspace'] === undefined
           ? {}
           : { trustClonedWorkspace: args['trustClonedWorkspace'] }),
-        ...(args['resumeInterruptedTurns'] === undefined
-          ? {}
-          : { resumeInterruptedTurns: args['resumeInterruptedTurns'] }),
         cols: 100,
         rows: 30,
       };
@@ -81,9 +78,6 @@ export function runTool(
       const trustFeatures: readonly DaemonFeature[] =
         args['trustClonedWorkspace'] === undefined ? [] : ['spawn.workspace.trust'];
 
-      const resumeFeatures: readonly DaemonFeature[] =
-        args['resumeInterruptedTurns'] === undefined ? [] : ['spawn.resumeInterruptedTurns'];
-
       // Only a daemon that picks a git workspace's directory takes one
       // without a cwd.
       const autoDirFeatures: readonly DaemonFeature[] =
@@ -97,7 +91,6 @@ export function runTool(
         ...targetFeatures,
         ...workspaceFeatures,
         ...trustFeatures,
-        ...resumeFeatures,
         ...autoDirFeatures,
       ];
 

package/src/protocol/daemon-features.ts

@@ -85,9 +85,6 @@ export const DAEMON_FEATURES = [
   // `session.auth.revoke` and `session.auth.rebind` exist, open to the
   // daemon's owner only.
   'session.auth',
-
-  // `session.spawn` takes `resumeInterruptedTurns`.
-  'spawn.resumeInterruptedTurns',
 ] as const;
 
 export type DaemonFeature = (typeof DAEMON_FEATURES)[number];

package/src/protocol/request-param-schemas.ts

@@ -196,12 +196,6 @@ export const REQUEST_PARAM_SCHEMAS = {
       .boolean({ error: 'session.spawn trustClonedWorkspace must be a boolean' })
       .optional(),
 
-    // Whether a fleet restore after a daemon restart sends the session one
-    // message to carry on an interrupted turn; absent follows the config.
-    resumeInterruptedTurns: z
-      .boolean({ error: 'session.spawn resumeInterruptedTurns must be a boolean' })
-      .optional(),
-
     // The session the new one is a sub-session of; absent or empty spawns a
     // top-level session.
     parent: z.preprocess(

package/src/shared/check-gateway-auth.ts

@@ -1,4 +1,5 @@
 import type { AuthProfile } from './collect-auth-profiles';
+import { collectProfileEnvProblems } from './collect-profile-env-problems';
 import { isBrokerVariable } from './is-broker-variable';
 import { isRecord } from './report';
 import { resolveAuthProfiles } from './resolve-auth-profiles';
@@ -75,6 +76,16 @@ export function checkGatewayAuth(
   if ('problem' in resolution) {
     problems.push(resolution.problem.message);
   } else {
+    problems.push(
+      ...collectProfileEnvProblems(
+        [
+          ['env', Object.keys(entry.env)],
+          ['settings.env', settingsEnv],
+        ],
+        resolution.resolved.envOwners,
+      ),
+    );
+
     const hostProblem = findBaseURLProblem(entry.baseURL ?? '', resolution.resolved.hosts);
 
     if (hostProblem !== null) {

package/src/shared/collect-agents.ts

@@ -4,8 +4,10 @@ import type { GatewayAuth } from './check-gateway-auth';
 import type { AuthProfile } from './collect-auth-profiles';
 import { collectClaudeAuth } from './collect-claude-auth';
 import type { ClaudeMCPServer } from './collect-claude-auth';
+import { collectProfileEnvProblems } from './collect-profile-env-problems';
 import { isSubscriptionOverrideVariable } from './is-subscription-override-variable';
 import { isRecord } from './report';
+import { resolveAuthProfiles } from './resolve-auth-profiles';
 
 /**
  * The agent CLI an entry drives, which decides the adapter behind it.
@@ -305,6 +307,10 @@ function readClaudeAuth(
 
   problems.push(...collectSubscriptionProblems(entry));
 
+  if (collected.auth !== null) {
+    problems.push(...collectEntryProfileEnvProblems(entry, collected.auth.profiles, authProfiles));
+  }
+
   if (collected.auth === null) {
     return { problems: [...collected.errors, ...problems] };
   }
@@ -320,6 +326,32 @@ function readClaudeAuth(
   };
 }
 
+// The variables a stock entry sets that its selected profiles also set.
+function collectEntryProfileEnvProblems(
+  entry: AgentEntry,
+  selected: readonly string[],
+  authProfiles: ReadonlyMap<string, AuthProfile>,
+): string[] {
+  const resolution = resolveAuthProfiles(authProfiles, selected);
+
+  if ('problem' in resolution) {
+    return [];
+  }
+
+  const settingsEnv = entry.settings?.['env'];
+
+  return collectProfileEnvProblems(
+    [
+      ['env', Object.keys(entry.env)],
+      [
+        'settings.env',
+        isRecord(settingsEnv) && !Array.isArray(settingsEnv) ? Object.keys(settingsEnv) : [],
+      ],
+    ],
+    resolution.resolved.envOwners,
+  );
+}
+
 // What a stock entry with `auth` sets that would override the subscription
 // sign-in or route the CLI around impd's broker.
 function collectSubscriptionProblems(entry: AgentEntry): string[] {

package/src/shared/collect-auth-profiles.ts

@@ -1,3 +1,5 @@
+import { isBrokerVariable } from './is-broker-variable';
+import { isSubscriptionOverrideVariable } from './is-subscription-override-variable';
 import { isRecord } from './report';
 
 /**
@@ -16,6 +18,7 @@ interface CustomAuthProfile {
   readonly host: string;
   readonly header: string;
   readonly scheme: 'bearer';
+  readonly env: Readonly<Record<string, string>>;
   readonly dependencies: readonly string[];
 }
 
@@ -23,6 +26,7 @@ interface GitHubAuthProfile {
   readonly name: string;
   readonly secret: string;
   readonly kind: 'github';
+  readonly env: Readonly<Record<string, string>>;
   readonly dependencies: readonly string[];
 }
 
@@ -112,7 +116,11 @@ function parseAuthProfile(name: string, entry: unknown): AuthProfile | string {
       return `${extra} cannot be set on a github profile, whose hosts and headers impd's github kind fixes`;
     }
 
-    return { name, secret, kind, dependencies: dependencies ?? [] };
+    if (entry['env'] !== undefined) {
+      return "env cannot be set on a github profile, whose placeholders impd's github kind sets";
+    }
+
+    return { name, secret, kind, env: {}, dependencies: dependencies ?? [] };
   }
 
   if (typeof host !== 'string' || host.length > BROKER_HOST_MAX || !BROKER_HOST.test(host)) {
@@ -131,6 +139,12 @@ function parseAuthProfile(name: string, entry: unknown): AuthProfile | string {
     return 'user pairs only with the basic scheme, which atc does not bind';
   }
 
+  const env = parseProfileEnv(entry['env'], host);
+
+  if (typeof env === 'string') {
+    return env;
+  }
+
   return {
     name,
     secret,
@@ -138,6 +152,55 @@ function parseAuthProfile(name: string, entry: unknown): AuthProfile | string {
     host,
     header,
     scheme,
+    env,
     dependencies: dependencies ?? [],
   };
 }
+
+// The value a profile's variable may hold: the placeholder the broker swaps
+// a credential in for, or the profile's own host as an https origin. No
+// other value, so a credential is never written into a profile.
+const ENV_PLACEHOLDER = 'imp-broker-placeholder';
+const ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
+const RESERVED_ENV_PREFIXES = ['ANTHROPIC_', 'CLAUDE_', 'ATC_'];
+
+const RESERVED_ENV_NAMES: ReadonlySet<string> = new Set(['PATH', 'HOME']);
+
+function parseProfileEnv(raw: unknown, host: string): Record<string, string> | string {
+  if (raw === undefined) {
+    return {};
+  }
+
+  if (!isRecord(raw) || Array.isArray(raw)) {
+    return 'env must be an object of variable names';
+  }
+
+  const env: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(raw)) {
+    if (!ENV_NAME.test(key)) {
+      return `env.${key} is not a variable name: use capital letters, digits and underscores`;
+    }
+
+    if (isReservedEnvName(key)) {
+      return `env.${key} cannot be set: atc or impd sets or reserves it`;
+    }
+
+    if (value !== ENV_PLACEHOLDER && value !== `https://${host}`) {
+      return `env.${key} must be ${ENV_PLACEHOLDER} or https://${host}`;
+    }
+
+    env[key] = value;
+  }
+
+  return env;
+}
+
+function isReservedEnvName(key: string): boolean {
+  return (
+    isBrokerVariable(key) ||
+    isSubscriptionOverrideVariable(key) ||
+    RESERVED_ENV_NAMES.has(key) ||
+    RESERVED_ENV_PREFIXES.some((prefix) => key.startsWith(prefix))
+  );
+}

package/src/shared/collect-profile-env-problems.ts

@@ -0,0 +1,16 @@
+/**
+ * Every variable an entry's `env` or `settings.env` sets that one of its
+ * selected auth profiles also sets, which would win over or lose to the
+ * profile's value by order. `owners` maps each profile variable to the
+ * profile that sets it.
+ */
+export function collectProfileEnvProblems(
+  sources: readonly (readonly [string, readonly string[]])[],
+  owners: Readonly<Record<string, string>>,
+): string[] {
+  return sources.flatMap(([source, keys]) =>
+    keys
+      .filter((key) => owners[key] !== undefined)
+      .map((key) => `${source} sets ${key}, which auth profile ${owners[key]} sets`),
+  );
+}

package/src/shared/config.ts

@@ -23,6 +23,7 @@ import { formatJSONKind } from './format-json-kind';
 import { formatMixedAgentKeys } from './format-mixed-agent-keys';
 import { LEGACY_AGENT_KEYS } from './legacy-agent-keys';
 import { pickDefaultAgent } from './pick-default-agent';
+import { REMOVED_CONFIG_KEYS } from './removed-config-keys';
 import { isRecord } from './report';
 import { resolveHomeDir } from './resolve-home-dir';
 
@@ -65,10 +66,12 @@ export interface Config {
   // The workspace config problems, one line each.
   workspaceErrors: readonly string[];
 
-  // Whether a fleet restore after a daemon restart sends a session that
-  // was mid-turn one message to carry on; a spawn can override it per
-  // session.
-  resumeInterruptedTurns: boolean;
+  // Whether the daemon restores the stored fleet by itself after a restart.
+  restoreFleetOnRestart: boolean;
+
+  // The keys the file sets that atc no longer reads, in the order the file
+  // holds them. Values are never recorded.
+  removedKeys: readonly string[];
 }
 
 /**
@@ -117,7 +120,8 @@ const DEFAULTS: Config = {
   principals: null,
   principalErrors: [],
   workspaceErrors: [],
-  resumeInterruptedTurns: false,
+  restoreFleetOnRestart: true,
+  removedKeys: [],
 };
 
 const configDir = join(resolveHomeDir(), '.config', 'atc');
@@ -158,7 +162,7 @@ const CONFIG_SCHEMA = z.object({
   targets: z.unknown().optional(),
   defaultTarget: z.unknown().optional(),
   principals: z.unknown().optional(),
-  resumeInterruptedTurns: buildOptionalBoolean(),
+  restoreFleetOnRestart: buildOptionalBoolean(),
 });
 
 /**
@@ -259,6 +263,7 @@ export function renderDefaultConfig(): string {
     principals: _principals,
     principalErrors: _principalErrors,
     workspaceErrors: _workspaceErrors,
+    removedKeys: _removedKeys,
     workspaces,
     ...written
   } = DEFAULTS;
@@ -354,7 +359,8 @@ export function parseConfig(raw: unknown, file: string = configFile): Config {
     principals: principals.principals,
     principalErrors: principals.errors,
     workspaceErrors: workspaces.errors,
-    resumeInterruptedTurns: parsed.data.resumeInterruptedTurns ?? DEFAULTS.resumeInterruptedTurns,
+    restoreFleetOnRestart: parsed.data.restoreFleetOnRestart ?? DEFAULTS.restoreFleetOnRestart,
+    removedKeys: REMOVED_CONFIG_KEYS.filter((key) => Object.hasOwn(raw, key)),
   };
 }
 

package/src/shared/removed-config-keys.ts

@@ -0,0 +1,5 @@
+/**
+ * The config.json keys atc once read and no longer does. A file that still
+ * sets one loads with a warning, and `atc config migrate` drops it.
+ */
+export const REMOVED_CONFIG_KEYS: readonly string[] = ['resumeInterruptedTurns'];

package/src/shared/resolve-auth-profiles.ts

@@ -23,7 +23,8 @@ export interface ResolvedAuthSecret {
 
 /**
  * A selection with its dependencies expanded: every profile it reaches,
- * every host those profiles send a credential to, and the rules grouped by
+ * every host those profiles send a credential to, the variables they set
+ * in the guest with the profile each came from, and the rules grouped by
  * secret, each list sorted so two selections of the same profiles resolve
  * the same.
  */
@@ -31,6 +32,8 @@ interface ResolvedAuthProfiles {
   readonly profiles: readonly string[];
   readonly hosts: readonly string[];
   readonly secrets: readonly ResolvedAuthSecret[];
+  readonly env: Readonly<Record<string, string>>;
+  readonly envOwners: Readonly<Record<string, string>>;
 }
 
 /**
@@ -40,7 +43,8 @@ interface ResolvedAuthProfiles {
  *   the config refused.
  * - `auth_dependency_cycle`: the dependencies loop back on themselves.
  * - `auth_collision`: two profiles send different credentials or rules to
- *   one host, which impd could not tell apart.
+ *   one host, which impd could not tell apart, or set one variable to
+ *   different values.
  */
 export interface AuthProfileProblem {
   readonly code: 'auth_profile_unknown' | 'auth_dependency_cycle' | 'auth_collision';
@@ -85,6 +89,9 @@ export function resolveAuthProfiles(
   const byHost = new Map<string, ProfileRule>();
   const kinds = new Map<string, AuthProfile>();
 
+  const env: Record<string, string> = {};
+  const envOwners: Record<string, string> = {};
+
   for (const profile of ordered) {
     const kindOwner = kinds.get(profile.secret);
 
@@ -99,6 +106,22 @@ export function resolveAuthProfiles(
       };
     }
 
+    for (const [key, value] of Object.entries(profile.env)) {
+      const owner = envOwners[key];
+
+      if (owner === undefined) {
+        env[key] = value;
+        envOwners[key] = profile.name;
+      } else if (env[key] !== value) {
+        return {
+          problem: {
+            code: 'auth_collision',
+            message: `profiles ${owner} and ${profile.name} set ${key} to different values`,
+          },
+        };
+      }
+    }
+
     for (const rule of getProfileRules(profile)) {
       const other = byHost.get(rule.host);
 
@@ -120,6 +143,8 @@ export function resolveAuthProfiles(
       profiles: ordered.map((profile) => profile.name),
       hosts: [...byHost.keys()].toSorted(),
       secrets: buildSecrets([...byHost.values()]),
+      env,
+      envOwners,
     },
   };
 }

package/src/store/fleet-entry.ts

@@ -67,11 +67,6 @@ export interface FleetEntry {
   // parent's when the two share one host. A row without one runs on a host
   // of its own.
   readonly hostKey?: SessionID;
-
-  // Whether a fleet restore after a daemon restart sends the session one
-  // message to carry on a turn the restart cut off; a row without one
-  // follows the daemon's config.
-  readonly resumeInterruptedTurns?: boolean;
 }
 
 export interface FleetStore {

package/src/store/run-migrations.ts

@@ -34,10 +34,6 @@ interface FleetTable {
   // its parent's when the two share one host. Null for a row from before
   // hosts were recorded, which runs on its own.
   host_key: string | null;
-
-  // Whether a restore sends the session one message to carry on an
-  // interrupted turn: 1 or 0 as the spawn chose, null to follow the config.
-  resume_interrupted_turns: number | null;
 }
 
 interface EventsTable {

package/src/store/state-store.ts

@@ -38,7 +38,6 @@ import type {
 
 // Spelled as the partial index's predicate so SQLite can match them.
 const TRAIL_FILTER = sql<boolean>`kind IS NOT NULL AND kind != 'heartbeat'`;
-const TURN_KINDS = ['prompt-submitted', 'turn-done', 'needs-input', 'ended'];
 
 /**
  * Some sessions' slice of the event trail: rows under their atc ids, plus
@@ -211,7 +210,6 @@ export class StateStore {
         'workspace.withheld_env',
         'fleet.desired',
         'fleet.host_key',
-        'fleet.resume_interrupted_turns',
       ])
       .execute();
 
@@ -241,9 +239,6 @@ export class StateStore {
         ...buildWithheldEnvField(row.withheld_env),
         ...(row.desired === 'sleep' || row.desired === 'stop' ? { desired: row.desired } : {}),
         ...(row.host_key === null ? {} : { hostKey: toSessionID(row.host_key) }),
-        ...(row.resume_interrupted_turns === null
-          ? {}
-          : { resumeInterruptedTurns: row.resume_interrupted_turns !== 0 }),
       });
     }
 
@@ -351,10 +346,6 @@ export class StateStore {
             target_identity: entry.targetIdentity ?? null,
             desired: entry.desired ?? null,
             host_key: entry.hostKey ?? null,
-            resume_interrupted_turns:
-              entry.resumeInterruptedTurns === undefined
-                ? null
-                : Number(entry.resumeInterruptedTurns),
           })
           .execute();
 
@@ -548,31 +539,6 @@ export class StateStore {
     return row?.ts === null || row?.ts === undefined ? null : Date.parse(row.ts);
   }
 
-  // The kind of the session's latest event that moves a turn: a prompt
-  // submitted, a turn done, a request for input, or the session's end.
-  // Null when the trail holds none. Matches the session by either id, as
-  // the activity read does.
-  async findLatestTurnKind(
-    atcID: SessionID,
-    agentSessionID: AgentSessionID | undefined,
-  ): Promise<string | null> {
-    const row = await this.db
-      .selectFrom('events')
-      .select('kind')
-      .where('kind', 'in', TURN_KINDS)
-      .where((eb) =>
-        eb.or([
-          eb('atc_id', '=', atcID),
-          ...(agentSessionID === undefined ? [] : [eb('session_id', '=', agentSessionID)]),
-        ]),
-      )
-      .orderBy('id', 'desc')
-      .limit(1)
-      .executeTakeFirst();
-
-    return row?.kind ?? null;
-  }
-
   async recordSpawnDir(cwd: string, grant: SpawnTarget): Promise<void> {
     await this.db
       .insertInto('spawn_history')