@zgeoff/atc 2.34.0 → 2.35.0

package/package.json

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

@@ -22,12 +22,15 @@ export interface SpawnOptions {
 
 /**
  * The per-launch choices a spawn asks for. Model and effort are checked
- * against what the agent advertises; workspace trust requires a verified clone.
+ * against what the agent advertises; workspace trust requires a verified
+ * clone; resuming an interrupted turn overrides the daemon's config for the
+ * session's whole life.
  */
 export interface SpawnOverrides {
   readonly trustClonedWorkspace?: boolean;
   readonly model?: string;
   readonly effort?: string;
+  readonly resumeInterruptedTurns?: boolean;
 }
 
 export interface SpawnPlan {
@@ -62,6 +65,15 @@ export interface AuthSelection {
   readonly brokerRequired: boolean;
 }
 
+/**
+ * One file a guest plan ships: its text, its bytes, or its bytes with the
+ * permission bits it unpacks with.
+ */
+export type GuestFile =
+  | string
+  | Uint8Array
+  | { readonly content: Uint8Array; readonly mode: number };
+
 /**
  * A spawn on a remote host, with the files the harness reads there, keyed
  * by their path inside the session's guest folder, and the variables the
@@ -69,7 +81,7 @@ export interface AuthSelection {
  * overrides.
  */
 export interface GuestSpawnPlan extends SpawnPlan {
-  readonly files: Readonly<Record<string, string>>;
+  readonly files: Readonly<Record<string, GuestFile>>;
   readonly env?: Readonly<Record<string, string>>;
 }
 

package/src/agents/build-claude-bundle-settings.ts

@@ -0,0 +1,91 @@
+import { isRecord } from '../shared/report';
+
+/**
+ * The user settings a session's own Claude config folder starts with, from
+ * the host's own `settings.json`: the keys on the allow-list alone, an
+ * `env` block cut to its own allow-list, and a permission default of auto
+ * mode, which Claude Code honours at user scope only. Any other key stays on
+ * the host, so a setting that holds a credential, a plugin, or a host path
+ * never reaches a guest unless it is listed here. The statusline command
+ * reads the guest's copy of a script under the host's config folder: a path
+ * under any of `hostDirs`, the spellings of that folder, moves under
+ * `guestDir`.
+ */
+export function buildClaudeBundleSettings(
+  settings: unknown,
+  hostDirs: readonly string[],
+  guestDir: string,
+): Record<string, unknown> {
+  const source = isRecord(settings) ? settings : {};
+  const shipped: Record<string, unknown> = {};
+
+  for (const key of SETTINGS_ALLOW_LIST) {
+    if (source[key] !== undefined) {
+      shipped[key] = source[key];
+    }
+  }
+
+  const env = buildBundleEnv(source['env']);
+  const statusLine = buildBundleStatusLine(source['statusLine'], hostDirs, guestDir);
+
+  return {
+    ...shipped,
+    ...(env === null ? {} : { env }),
+    ...(statusLine === null ? {} : { statusLine }),
+    permissions: {
+      ...(isRecord(source['permissions']) ? source['permissions'] : {}),
+      defaultMode: 'auto',
+    },
+  };
+}
+
+const SETTINGS_ALLOW_LIST = [
+  'model',
+  'effortLevel',
+  'advisorModel',
+  'outputStyle',
+  'autoCompactWindow',
+  'autoMode',
+  'attribution',
+  'includeCoAuthoredBy',
+  'skipAutoPermissionPrompt',
+  'skipWorkflowUsageWarning',
+  'editorMode',
+  'tui',
+] as const;
+
+// The variables an `env` block may ship. A variable off this list may hold
+// a credential, so it stays on the host.
+const ENV_ALLOW_LIST: ReadonlySet<string> = new Set(['CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS']);
+
+function buildBundleEnv(env: unknown): Record<string, string> | null {
+  if (!isRecord(env)) {
+    return null;
+  }
+
+  const shipped = Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] =>
+        ENV_ALLOW_LIST.has(entry[0]) && typeof entry[1] === 'string',
+    ),
+  );
+
+  return Object.keys(shipped).length === 0 ? null : shipped;
+}
+
+function buildBundleStatusLine(
+  statusLine: unknown,
+  hostDirs: readonly string[],
+  guestDir: string,
+): Record<string, unknown> | null {
+  if (!isRecord(statusLine) || typeof statusLine['command'] !== 'string') {
+    return null;
+  }
+
+  const command = hostDirs.reduce(
+    (rewritten, hostDir) => rewritten.replaceAll(`${hostDir}/`, `${guestDir}/`),
+    statusLine['command'],
+  );
+
+  return { ...statusLine, command };
+}

package/src/agents/build-claude-guest-launch.ts

@@ -1,4 +1,5 @@
 import type { SpawnPlan } from './agent-adapter';
+import { CLAUDE_CONFIG_BUNDLE_FOLDER } from './claude-config-bundle-folder';
 import { CLAUDE_CONFIG_SEED_FILE } from './claude-config-seed-file';
 
 /**
@@ -7,7 +8,11 @@ import { CLAUDE_CONFIG_SEED_FILE } from './claude-config-seed-file';
  * setting of the host's image reaches it. A shell copies the seed into the
  * folder only when the folder holds no `.claude.json` yet, then runs the
  * CLI, so a resumed session keeps the state the CLI wrote, a folder trust
- * a person accepted included. `argv` is the CLI's own command line. The
+ * a person accepted included. When the guest folder holds the config bundle
+ * staged under `bundleKey`, the shell replaces the bundle's entries in the
+ * config folder with the staged ones and removes every staged bundle, so
+ * each launch reads the bundle its own transfer carried and never one an
+ * earlier launch left. `argv` is the CLI's own command line. The
  * shell exits before it runs the CLI when the host's environment sets any
  * of `refusedEnv`, which must be variable names, and says which one.
  */
@@ -15,7 +20,8 @@ export function buildClaudeGuestLaunch(
   guestDir: string,
   argv: readonly string[],
   refusedEnv: readonly string[] = [],
-): SpawnPlan & { readonly env: Readonly<Record<string, string>> } {
+  bundleKey = 'none',
+): SpawnPlan & { readonly env: { readonly CLAUDE_CONFIG_DIR: string } } {
   const configDir = `${guestDir}/${CLAUDE_CONFIG_FOLDER}`;
   const guards = refusedEnv.map((name) => buildEnvGuard(name)).join('');
 
@@ -27,6 +33,8 @@ export function buildClaudeGuestLaunch(
       'sh',
       configDir,
       `${guestDir}/${CLAUDE_CONFIG_SEED_FILE}`,
+      `${guestDir}/${CLAUDE_CONFIG_BUNDLE_FOLDER}`,
+      `${guestDir}/${CLAUDE_CONFIG_BUNDLE_FOLDER}/${bundleKey}`,
       ...argv,
     ],
     env: { CLAUDE_CONFIG_DIR: configDir },
@@ -49,7 +57,14 @@ function buildEnvGuard(name: string): string {
 const REFUSED_EXIT = 78;
 const CLAUDE_CONFIG_FOLDER = 'claude-config';
 
-// The arguments are the config folder, the seed, and the CLI's own command
-// line.
-const SEED_CONFIG_SCRIPT =
-  'mkdir -p "$1" && { [ -e "$1/.claude.json" ] || cp "$2" "$1/.claude.json"; } && shift 2 && exec "$@"';
+// The arguments are the config folder, the seed, the folder bundles stage
+// in, this launch's staged bundle, and the CLI's own command line. The
+// removed entries are every top-level entry a bundle can hold, so one the
+// host dropped leaves the config folder too.
+const SEED_CONFIG_SCRIPT = [
+  'mkdir -p "$1"',
+  '{ [ -e "$1/.claude.json" ] || cp "$2" "$1/.claude.json"; }',
+  '{ [ ! -d "$4" ] || { rm -rf "$1/CLAUDE.md" "$1/settings.json" "$1/statusline.sh" "$1/agents" "$1/output-styles" "$1/skills" && cp -R "$4/." "$1/" && rm -rf "$3"; }; }',
+  'shift 4',
+  'exec "$@"',
+].join(' && ');

package/src/agents/claude-adapter.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { z } from 'zod';
 import type { AdapterEvent } from '../protocol/adapter-event';
@@ -30,13 +31,16 @@ import { buildClaudeConfigSeed } from './build-claude-config-seed';
 import { buildClaudeGuestLaunch } from './build-claude-guest-launch';
 import { buildClaudeOverrideArgs } from './build-claude-override-args';
 import { buildHookSettings } from './build-hook-settings';
+import { CLAUDE_CONFIG_BUNDLE_FOLDER } from './claude-config-bundle-folder';
 import { CLAUDE_EFFORT_LEVELS } from './claude-effort-levels';
 import { findClaudePermissionMode } from './find-claude-permission-mode';
 import { findFlagValue } from './find-flag-value';
+import { loadClaudeConfigBundle } from './load-claude-config-bundle';
 import { makeClaudeHeadlessRunner } from './make-claude-headless-runner';
 import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 import { parseClaudeTranscriptLine } from './parse-claude-transcript-line';
 import { planPastedLineInput } from './plan-pasted-line-input';
+import { resolveAgentHome } from './resolve-agent-home';
 import { resolveClaudeGlobalConfigPath } from './resolve-claude-global-config-path';
 import { resolveClaudePermissionMode } from './resolve-claude-permission-mode';
 import { updateClaudeProjectTrust } from './update-claude-project-trust';
@@ -189,9 +193,11 @@ export class ClaudeAdapter implements AgentAdapter {
   // A settings file of the session's own per binding revision carries the
   // placeholder, and so does the CLI's environment. The configured
   // arguments go without a permission mode, so the mode the session's own
-  // user settings set applies. A credential, endpoint, or provider variable
-  // in the configured settings, or in the host's environment, would keep
-  // the CLI from sending the placeholder, so either refuses the start.
+  // user settings set applies. Those user settings, with the rest of the
+  // config bundle, come from the host's own Claude config folder as it is
+  // at this launch, staged under a key of this launch's own. A credential, endpoint, or provider variable in the
+  // configured settings, or in the host's environment, would keep the CLI
+  // from sending the placeholder, so either refuses the start.
   private planSubscriptionGuestSpawn(
     opts: SpawnOptions,
     dir: string,
@@ -206,12 +212,7 @@ export class ClaudeAdapter implements AgentAdapter {
     }
 
     const settingsPath = `auth-r${auth.revision}/settings.json`;
-
-    const settings = buildHookSettings(
-      { id: this.id, env: { ...auth.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' } },
-      0,
-      argv,
-    );
+    const bundleKey = randomUUID();
 
     const launch = buildClaudeGuestLaunch(
       dir,
@@ -225,6 +226,21 @@ export class ClaudeAdapter implements AgentAdapter {
         ),
       ],
       [...OUTRANKING_VARIABLES],
+      bundleKey,
+    );
+
+    const bundle = loadClaudeConfigBundle(
+      resolveAgentHome('CLAUDE_CONFIG_DIR', '.claude'),
+      launch.env.CLAUDE_CONFIG_DIR,
+    );
+
+    const userSettings = bundle['settings.json'];
+    const padding = typeof userSettings === 'string' ? findStatuslinePadding(userSettings) : 0;
+
+    const settings = buildHookSettings(
+      { id: this.id, env: { ...auth.env, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' } },
+      padding,
+      argv,
     );
 
     return {
@@ -233,6 +249,12 @@ export class ClaudeAdapter implements AgentAdapter {
       files: {
         [settingsPath]: JSON.stringify(settings, null, 2),
         ...buildClaudeConfigSeed(null),
+        ...Object.fromEntries(
+          Object.entries(bundle).map(([path, content]) => [
+            `${CLAUDE_CONFIG_BUNDLE_FOLDER}/${bundleKey}/${path}`,
+            content,
+          ]),
+        ),
         ...Object.fromEntries(bridge),
       },
       env: { ...launch.env, ...auth.env },
@@ -464,6 +486,20 @@ const OUTRANKING_VARIABLES: ReadonlySet<string> = new Set([
   'CLAUDE_CODE_USE_GATEWAY',
 ]);
 
+// The padding of the statusline the bundle's user settings set, which atc's
+// own statusline mirrors since it renders that one first, or none.
+function findStatuslinePadding(settings: string): number {
+  try {
+    const parsed: unknown = JSON.parse(settings);
+    const statusLine = isRecord(parsed) ? parsed['statusLine'] : undefined;
+    const padding = isRecord(statusLine) ? statusLine['padding'] : undefined;
+
+    return typeof padding === 'number' ? padding : 0;
+  } catch {
+    return 0;
+  }
+}
+
 // 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 = [

package/src/agents/claude-config-bundle-folder.ts

@@ -0,0 +1,8 @@
+/**
+ * Where the Claude config bundle of a session travels inside its guest
+ * folder, each launch's bundle under a key of its own: beside the config
+ * folder rather than in it, so the launch replaces the bundle's own entries
+ * in the config folder whole, and an entry the host no longer holds leaves
+ * the config folder with it.
+ */
+export const CLAUDE_CONFIG_BUNDLE_FOLDER = 'claude-config-bundle';

package/src/agents/load-claude-config-bundle.ts

@@ -0,0 +1,169 @@
+import { readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import type { Stats } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
+import { resolveHomeDir } from '../shared/resolve-home-dir';
+import type { GuestFile } from './agent-adapter';
+import { buildClaudeBundleSettings } from './build-claude-bundle-settings';
+
+/**
+ * The files of the Claude config bundle, read from the host's config folder
+ * `hostDir` and keyed by their path inside the guest's config folder
+ * `guestDir`: `CLAUDE.md`, the filtered `settings.json`, `statusline.sh`,
+ * every file under `agents/` and `output-styles/`, and each folder under
+ * `skills/` that holds a `SKILL.md`. Symlinks resolve to copies of what
+ * they point at, and a file its owner may execute unpacks executable.
+ * Nothing else in the host's folder ships, so its account state, history,
+ * credentials, and backups stay there, and so does any entry whose name
+ * starts with a dot. A symlink ships only when what it resolves to could
+ * ship by its own path: a file whose name starts with a dot never does, and
+ * neither does a file in the host's folder outside the shipped entries. A
+ * missing entry ships nothing.
+ */
+export function loadClaudeConfigBundle(
+  hostDir: string,
+  guestDir: string,
+): Record<string, GuestFile> {
+  const hostSettings = readSettings(join(hostDir, 'settings.json'));
+
+  const settings = buildClaudeBundleSettings(
+    hostSettings,
+    buildHostDirSpellings(hostDir),
+    guestDir,
+  );
+
+  const files: Record<string, GuestFile> = {
+    'settings.json': JSON.stringify(settings, null, 2),
+  };
+
+  const hostReal = findStats(hostDir) === null ? hostDir : realpathSync(hostDir);
+
+  for (const name of ['CLAUDE.md', 'statusline.sh']) {
+    const path = join(hostDir, name);
+    const stats = findStats(path);
+
+    if (stats?.isFile() === true && shouldShipFile(path, hostReal)) {
+      files[name] = readBundleFile(path, stats.mode);
+    }
+  }
+
+  for (const name of ['agents', 'output-styles']) {
+    Object.assign(files, collectTreeFiles(join(hostDir, name), name, hostReal, new Set()));
+  }
+
+  const skills = join(hostDir, 'skills');
+
+  for (const name of readEntryNames(skills)) {
+    const path = join(skills, name);
+
+    if (findStats(join(path, 'SKILL.md'))?.isFile() === true) {
+      Object.assign(files, collectTreeFiles(path, `skills/${name}`, hostReal, new Set()));
+    }
+  }
+
+  return files;
+}
+
+// The ways a command can spell the host's config folder: its path, and
+// when it is the default folder in the user's home, the home-relative forms
+// a shell expands.
+function buildHostDirSpellings(hostDir: string): string[] {
+  return hostDir === join(resolveHomeDir(), '.claude')
+    ? [hostDir, '~/.claude', '$HOME/.claude']
+    : [hostDir];
+}
+
+// The host's settings, or none when the file is missing or is not JSON,
+// which still ships the auto-mode default.
+function readSettings(path: string): unknown {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// The stats of what a path resolves to, or null for a missing path or a
+// symlink that points nowhere.
+function findStats(path: string): Stats | null {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+
+// A folder's entry names, sorted, without the ones that start with a dot,
+// or none when the path is not a folder.
+function readEntryNames(dir: string): string[] {
+  if (findStats(dir)?.isDirectory() !== true) {
+    return [];
+  }
+
+  return readdirSync(dir)
+    .filter((name) => !name.startsWith('.'))
+    .toSorted();
+}
+
+// Every file under `dir` that may ship, keyed by its path under `prefix`,
+// with symlinks followed. `seen` holds the real paths of the folders on the
+// way down, so a symlink back up the tree ends there.
+function collectTreeFiles(
+  dir: string,
+  prefix: string,
+  hostReal: string,
+  seen: ReadonlySet<string>,
+): Record<string, GuestFile> {
+  const real = findStats(dir) === null ? null : realpathSync(dir);
+
+  if (real === null || seen.has(real)) {
+    return {};
+  }
+
+  const below = new Set([...seen, real]);
+
+  const files: Record<string, GuestFile> = {};
+
+  for (const name of readEntryNames(dir)) {
+    const path = join(dir, name);
+    const stats = findStats(path);
+
+    if (stats?.isFile() === true && shouldShipFile(path, hostReal)) {
+      files[`${prefix}/${name}`] = readBundleFile(path, stats.mode);
+    } else if (stats?.isDirectory() === true) {
+      Object.assign(files, collectTreeFiles(path, `${prefix}/${name}`, hostReal, below));
+    }
+  }
+
+  return files;
+}
+
+// Whether the file a path resolves to may ship: its name starts with no
+// dot, and inside the host's real folder `hostReal` it sits in a shipped
+// entry, so a symlink never carries credentials, account state, or the
+// unfiltered settings.
+function shouldShipFile(path: string, hostReal: string): boolean {
+  const real = realpathSync(path);
+
+  if (basename(real).startsWith('.')) {
+    return false;
+  }
+
+  const inside = relative(hostReal, real);
+
+  return inside.startsWith('..') || SHIPPED_ENTRIES.has(inside.split(sep)[0] ?? '');
+}
+
+const SHIPPED_ENTRIES: ReadonlySet<string> = new Set([
+  'CLAUDE.md',
+  'statusline.sh',
+  'agents',
+  'output-styles',
+  'skills',
+]);
+
+// A file's bytes, with an executable mode when its owner may execute it.
+function readBundleFile(path: string, mode: number): GuestFile {
+  const content = readFileSync(path);
+
+  return (mode & 0o100) === 0 ? content : { content, mode: 0o755 };
+}

package/src/cli.ts

@@ -457,6 +457,7 @@ async function runDaemon(listenArg: string | null, tokenFile: string | null): Pr
         ? {}
         : { listen: { host: listen.host, port: listen.port, tokenFile } }),
       restoreBootTimeoutMs,
+      resumeInterruptedTurns: cfg.resumeInterruptedTurns,
       ...(Number.isFinite(graceOverride) && graceOverride >= 0
         ? { tapGraceMs: graceOverride }
         : {}),

package/src/daemon/build-tar-archive.ts

@@ -12,8 +12,9 @@ const BLOCK = 512;
 
 /**
  * Packs files into a POSIX ustar archive that `tar -x` unpacks, each with
- * its parent directories created on the way. A path longer than ustar
- * holds is refused.
+ * its parent directories created on the way. A path longer than 100 bytes
+ * splits at a slash into ustar's prefix and name fields, and a path that
+ * fits no such split is refused.
  */
 // oxlint-disable-next-line prefer-readonly-parameter-types -- file bytes have no readonly form
 export function buildTarArchive(files: readonly ArchiveFile[]): Uint8Array {
@@ -50,15 +51,11 @@ export function buildTarArchive(files: readonly ArchiveFile[]): Uint8Array {
 function buildHeader(path: string, size: number, mode: number): Uint8Array {
   const encoder = new TextEncoder();
 
-  const name = encoder.encode(path);
-
-  if (name.length > 100) {
-    throw new Error(`archive path is longer than 100 bytes: ${path}`);
-  }
+  const split = splitArchivePath(path);
 
   const header = new Uint8Array(BLOCK);
 
-  header.set(name, 0);
+  header.set(encoder.encode(split.name), 0);
   header.set(encoder.encode(formatOctal(mode, 8)), 100);
   header.set(encoder.encode(formatOctal(0, 8)), 108);
   header.set(encoder.encode(formatOctal(0, 8)), 116);
@@ -71,6 +68,7 @@ function buildHeader(path: string, size: number, mode: number): Uint8Array {
   header[156] = '0'.codePointAt(0) ?? 0;
 
   header.set(encoder.encode('ustar\u000000'), 257);
+  header.set(encoder.encode(split.prefix), 345);
 
   const checksum = header.reduce((total, byte) => total + byte, 0);
 
@@ -79,6 +77,33 @@ function buildHeader(path: string, size: number, mode: number): Uint8Array {
   return header;
 }
 
+const NAME_BYTES = 100;
+const PREFIX_BYTES = 155;
+
+// The ustar fields a path fills: the whole path as the name when it fits,
+// otherwise the part before the last slash that leaves a name short enough,
+// with that slash dropped, as the prefix.
+function splitArchivePath(path: string): { readonly prefix: string; readonly name: string } {
+  if (countBytes(path) <= NAME_BYTES) {
+    return { prefix: '', name: path };
+  }
+
+  for (let at = path.indexOf('/'); at !== -1; at = path.indexOf('/', at + 1)) {
+    const prefix = path.slice(0, at);
+    const name = path.slice(at + 1);
+
+    if (countBytes(prefix) <= PREFIX_BYTES && countBytes(name) <= NAME_BYTES && name !== '') {
+      return { prefix, name };
+    }
+  }
+
+  throw new Error(`archive path does not fit a ustar header: ${path}`);
+}
+
+function countBytes(text: string): number {
+  return new TextEncoder().encode(text).length;
+}
+
 // An octal number padded to fill its field, ending in a NUL.
 function formatOctal(value: number, width: number): string {
   return `${value.toString(8).padStart(width - 1, '0')}\u0000`;

package/src/daemon/daemon-connection.ts

@@ -1034,6 +1034,9 @@ 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

@@ -157,6 +157,11 @@ 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;
+
   // How long a confirm token from `session.forget` stays usable.
   readonly forgetConfirmMs?: number;
 
@@ -281,6 +286,11 @@ 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;
 
@@ -1308,6 +1318,37 @@ 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 (
@@ -1776,7 +1817,16 @@ export async function startDaemon(opts: DaemonOptions): Promise<DaemonHandle> {
       attachments.findEffectiveDims(sessionID) ??
       runtimes.get(sessionID)?.dims ?? { cols: 80, rows: 24 },
     restoreFleet: (cols, rows) =>
-      restoreFleet({ mgr, store, findRuntime, cols, rows, capMs: opts.restoreBootTimeoutMs ?? 0 }),
+      restoreFleet({
+        mgr,
+        store,
+        findRuntime,
+        cols,
+        rows,
+        capMs: opts.restoreBootTimeoutMs ?? 0,
+        resumeInterruptedTurns: opts.resumeInterruptedTurns ?? false,
+        sendResumeMessage,
+      }),
     readSessionRecord: async (id, access) => {
       const s = mgr.sessions.find((x) => x.id === id);
 

package/src/daemon/restore-fleet.ts

@@ -16,6 +16,12 @@ export interface RestoreFleetParams {
   // it has booted before moving on regardless; zero waits on the signal
   // alone.
   readonly capMs: 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>;
 }
 
 /**
@@ -23,7 +29,9 @@ 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.
+ * 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.
  */
 export async function restoreFleet(params: RestoreFleetParams): Promise<number> {
   const mgr = params.mgr;
@@ -32,6 +40,7 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   const cols = params.cols;
   const rows = params.rows;
   const capMs = params.capMs;
+  const sendResumeMessage = params.sendResumeMessage;
 
   const hasLiveSession = (entry: FleetEntry) =>
     mgr.sessions.some(
@@ -83,11 +92,33 @@ 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.
+  // 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.
   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;
   };
 
@@ -174,6 +205,39 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   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);
+    }
+  }
+
+  return interrupted;
+}
+
 // A stored entry matches a listed session by its atc session id, or by its
 // agent session id when a listed session resumed the same agent session.
 function isSameSession(s: Session, entry: FleetEntry): boolean {

package/src/daemon/sessions.ts

@@ -3,6 +3,7 @@ import { posix } from 'node:path';
 import type {
   AgentAdapter,
   GuestPaths,
+  GuestSpawnPlan,
   SpawnOptions,
   SpawnOverrides,
   SpawnPlan,
@@ -183,6 +184,10 @@ 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.
@@ -569,6 +574,9 @@ 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);
@@ -1125,6 +1133,9 @@ export class SessionManager {
       suspended: false,
       hostKey,
       bridgeEpoch: binding.epoch,
+      ...(overrides.resumeInterruptedTurns === undefined
+        ? {}
+        : { resumeInterruptedTurns: overrides.resumeInterruptedTurns }),
     };
 
     this.attachHarness(session, pty, this.hasHostLifecycle(target));
@@ -2082,7 +2093,9 @@ export class SessionManager {
     hostKey: SessionID,
     target: string,
     dir: string,
-    planned: Readonly<Record<string, string>>,
+
+    // oxlint-disable-next-line prefer-readonly-parameter-types -- file bytes have no readonly form
+    planned: GuestSpawnPlan['files'],
   ): Promise<void> {
     await provider.prepareHost({
       host: hostKey,
@@ -2105,7 +2118,11 @@ export class SessionManager {
       }
     }
 
-    const files = Object.entries(planned).map(([path, content]) => ({ path, content }));
+    const files = Object.entries(planned).map(([path, file]) =>
+      typeof file === 'string' || file instanceof Uint8Array
+        ? { path, content: file }
+        : { path, content: file.content, mode: file.mode },
+    );
 
     if (files.length > 0) {
       await provider.transferArchive(buildTarArchive(files), dir, hostKey);
@@ -2895,6 +2912,9 @@ 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,6 +65,9 @@ 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()
@@ -420,6 +423,7 @@ 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,6 +26,7 @@ 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,6 +58,9 @@ export function runTool(
         ...(args['trustClonedWorkspace'] === undefined
           ? {}
           : { trustClonedWorkspace: args['trustClonedWorkspace'] }),
+        ...(args['resumeInterruptedTurns'] === undefined
+          ? {}
+          : { resumeInterruptedTurns: args['resumeInterruptedTurns'] }),
         cols: 100,
         rows: 30,
       };
@@ -78,6 +81,9 @@ 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[] =
@@ -91,6 +97,7 @@ export function runTool(
         ...targetFeatures,
         ...workspaceFeatures,
         ...trustFeatures,
+        ...resumeFeatures,
         ...autoDirFeatures,
       ];
 

package/src/protocol/daemon-features.ts

@@ -85,6 +85,9 @@ 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,6 +196,12 @@ 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/config.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
+import { buildOptionalBoolean } from './build-optional-boolean';
 import { buildOptionalString } from './build-optional-string';
 import { buildOptionalStringArray } from './build-optional-string-array';
 import { collectAuthProfiles } from './collect-auth-profiles';
@@ -65,6 +66,11 @@ 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;
 }
 
 /**
@@ -109,6 +115,7 @@ const DEFAULTS: Config = {
   principals: null,
   principalErrors: [],
   workspaceErrors: [],
+  resumeInterruptedTurns: false,
 };
 
 const configDir = join(resolveHomeDir(), '.config', 'atc');
@@ -148,6 +155,7 @@ const CONFIG_SCHEMA = z.object({
   targets: z.unknown().optional(),
   defaultTarget: z.unknown().optional(),
   principals: z.unknown().optional(),
+  resumeInterruptedTurns: buildOptionalBoolean(),
 });
 
 /**
@@ -336,6 +344,7 @@ export function parseConfig(raw: unknown, file: string = configFile): Config {
     principals: principals.principals,
     principalErrors: principals.errors,
     workspaceErrors: workspaces.errors,
+    resumeInterruptedTurns: parsed.data.resumeInterruptedTurns ?? DEFAULTS.resumeInterruptedTurns,
   };
 }
 

package/src/statusline.ts

@@ -1,13 +1,14 @@
 import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { resolveAgentHome } from './agents/resolve-agent-home';
 import { sendBridgeRequest } from './protocol/send-bridge-request';
 import { statusFile } from './shared/config';
 import { isRecord, sendReport } from './shared/report';
 
 /**
  * Runs as the statusLine command injected into wrangled sessions. Chains the
- * user's own statusline (from ~/.claude/settings.json), appends the atc fleet
+ * user's own statusline (from settings.json in the Claude config folder,
+ * `$CLAUDE_CONFIG_DIR` or ~/.claude), appends the atc fleet
  * segment, and heartbeats the session id back to the atc socket, with the
  * agent id the command gave it. Always exits 0 so it never breaks the
  * session it renders for.
@@ -37,7 +38,7 @@ export async function runStatusline(agent: string): Promise<void> {
   let chained = '';
 
   try {
-    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const settingsPath = join(resolveAgentHome('CLAUDE_CONFIG_DIR', '.claude'), 'settings.json');
     const rawSettings = readFileSync(settingsPath, 'utf8');
     const settings: unknown = JSON.parse(rawSettings);
     const statusLine = isRecord(settings) ? settings['statusLine'] : undefined;

package/src/store/fleet-entry.ts

@@ -67,6 +67,11 @@ 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,6 +34,10 @@ 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 {
@@ -549,6 +553,14 @@ const MIGRATIONS: Record<string, Migration> = {
         .execute();
     },
   },
+  '026_add_fleet_resume_interrupted_turns': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .alterTable('fleet')
+        .addColumn('resume_interrupted_turns', 'integer')
+        .execute();
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {

package/src/store/state-store.ts

@@ -38,6 +38,7 @@ 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
@@ -210,6 +211,7 @@ export class StateStore {
         'workspace.withheld_env',
         'fleet.desired',
         'fleet.host_key',
+        'fleet.resume_interrupted_turns',
       ])
       .execute();
 
@@ -239,6 +241,9 @@ 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 }),
       });
     }
 
@@ -346,6 +351,10 @@ 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();
 
@@ -539,6 +548,31 @@ 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')