@zgeoff/atc 2.33.0 → 2.35.0

package/package.json

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

@@ -452,10 +452,12 @@ async function runDaemon(listenArg: string | null, tokenFile: string | null): Pr
       principals: cfg.principals,
       sources: sources.sources,
       gitTransports: cfg.workspaces.gitTransports,
+      workspaceRoots: { root: cfg.workspaces.root, targetRoots: cfg.workspaces.targetRoots },
       ...(listen === null || tokenFile === null
         ? {}
         : { listen: { host: listen.host, port: listen.port, tokenFile } }),
       restoreBootTimeoutMs,
+      resumeInterruptedTurns: cfg.resumeInterruptedTurns,
       ...(Number.isFinite(graceOverride) && graceOverride >= 0
         ? { tapGraceMs: graceOverride }
         : {}),

package/src/client/index.ts

@@ -2,6 +2,7 @@ import { match } from 'ts-pattern';
 import { createActor } from 'xstate';
 import { countSessionStates } from '../protocol/count-session-states';
 import { DaemonError } from '../protocol/daemon-error';
+import type { DaemonFeature } from '../protocol/daemon-features';
 import type { EventMsg } from '../protocol/protocol';
 import { sortGroupedSessionViews } from '../protocol/sort-grouped-session-views';
 import { sortSessionViews } from '../protocol/sort-session-views';
@@ -339,12 +340,17 @@ const picker = new SpawnPicker<MirrorSession>({
   attach,
   toMirrorSession,
   upsertMirror,
+  hasDaemonFeature,
 });
 
 function openPicker(resume: boolean) {
   picker.open(resume);
 }
 
+function hasDaemonFeature(feature: DaemonFeature): boolean {
+  return daemonFeatures.has(feature);
+}
+
 function sendRequest(m: string, p?: Readonly<Record<string, unknown>>) {
   return client.sendRequest(m, p);
 }
@@ -832,6 +838,7 @@ const boot = await bootDaemonClient({
 
 let client = boot.client;
 let daemonStale = boot.stale;
+let daemonFeatures = boot.features;
 let daemonRestarting = false;
 
 lastUsedAgent = boot.lastUsedAgent;
@@ -950,6 +957,7 @@ async function restartDaemon() {
 
   client = next.client;
   daemonStale = next.stale;
+  daemonFeatures = next.features;
   lastUsedAgent = next.lastUsedAgent;
   client.onEvent = applyDaemonEvent;