@zgeoff/atc 3.3.1 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",
@@ -30,7 +30,7 @@
     "lint:fix": "oxlint --type-aware --type-check --report-unused-disable-directives-severity error --fix",
     "test": "bash scripts/with-test-home.sh bun test --parallel --timings=bun-test-timings.json",
     "test:timings": "bash scripts/with-test-home.sh bun test --parallel --timings=bun-test-timings.json --update-timings",
-    "test:binary": "bash scripts/with-test-home.sh bun test --timeout 20000 e2e/daemon-e2e.test.ts",
+    "test:binary": "bash scripts/with-test-home.sh bun test --timeout 20000 e2e/daemon-*.test.ts",
     "test:gateway-binary": "bash scripts/with-test-home.sh bun test --timeout 20000 src/gateway.test.ts",
     "test:atc-bridge": "bash scripts/with-test-home.sh bash scripts/test-atc-bridge.sh",
     "test:isolation": "bash scripts/check-test-isolation.sh",
@@ -57,6 +57,7 @@
   },
   "devDependencies": {
     "@commitlint/cli": "21.2.0",
+    "@faker-js/faker": "10.6.0",
     "@stylistic/eslint-plugin": "5.10.0",
     "@tsconfig/strictest": "2.0.8",
     "@types/bun": "1.4.2",
@@ -68,6 +69,7 @@
     "oxfmt": "0.57.0",
     "oxlint": "1.73.0",
     "oxlint-tsgolint": "0.24.0",
+    "tiny-invariant": "1.3.3",
     "tslib": "2.8.1",
     "type-fest": "5.8.0",
     "typescript": "7.0.2"

package/src/agents/agent-adapter.ts

@@ -179,6 +179,16 @@ export interface HeadlessRunEvents {
   readonly onNeedsYou: (msg: string) => void;
 }
 
+/**
+ * Where a Claude-family adapter writes its generated settings files and
+ * where it finds the user's home, whose Claude config it reads. A field
+ * left out takes atc's state folder or the running user's home.
+ */
+export interface ClaudeHostPaths {
+  readonly stateDir?: string;
+  readonly homeDir?: string;
+}
+
 export type HeadlessRunner = (
   opts: HeadlessRunRequest,
   hooks: HeadlessRunEvents,

package/src/agents/build-cli-argv.ts

@@ -6,8 +6,6 @@ import { isCompiledBinary } from '../shared/is-compiled-binary';
  * the CLI entry path follows the runtime; a compiled binary is itself the
  * entry.
  */
-export function buildCLIArgv(): string[] {
-  return isCompiledBinary()
-    ? [process.execPath]
-    : [process.execPath, join(import.meta.dir, '..', 'cli.ts')];
+export function buildCLIArgv(compiled: boolean = isCompiledBinary()): string[] {
+  return compiled ? [process.execPath] : [process.execPath, join(import.meta.dir, '..', 'cli.ts')];
 }

package/src/agents/claude-adapter.ts

@@ -19,6 +19,7 @@ import type {
   AgentAdapter,
   AgentProfile,
   AuthSelection,
+  ClaudeHostPaths,
   GuestPaths,
   GuestSpawnPlan,
   HeadlessRunner,
@@ -106,13 +107,17 @@ export class ClaudeAdapter implements AgentAdapter {
 
   private readonly bridgeTarget: string | undefined;
 
+  private readonly hostPaths: ClaudeHostPaths;
+
   constructor(
     entry: AgentEntry,
     config: Pick<Config, 'authProfiles'>,
     headlessRun: ClaudeHeadlessRun | null = null,
     bridgeTarget?: string,
+    hostPaths: ClaudeHostPaths = {},
   ) {
     this.bridgeTarget = bridgeTarget;
+    this.hostPaths = hostPaths;
     this.entry = entry;
     this.authProfiles = config.authProfiles;
     this.id = entry.id;
@@ -282,8 +287,9 @@ export class ClaudeAdapter implements AgentAdapter {
     );
 
     const bundle = loadClaudeConfigBundle(
-      resolveAgentHome('CLAUDE_CONFIG_DIR', '.claude'),
+      resolveAgentHome('CLAUDE_CONFIG_DIR', '.claude', this.hostPaths.homeDir),
       launch.env.CLAUDE_CONFIG_DIR,
+      this.hostPaths.homeDir,
     );
 
     const userSettings = bundle['settings.json'];
@@ -406,7 +412,11 @@ export class ClaudeAdapter implements AgentAdapter {
   }
 
   private writeSettings(): string {
-    this.settingsFile ??= writeHookSettings(this.buildSettingsProfile({}));
+    this.settingsFile ??= writeHookSettings(
+      this.buildSettingsProfile({}),
+      this.hostPaths.stateDir,
+      this.hostPaths.homeDir,
+    );
 
     return this.settingsFile;
   }
@@ -420,7 +430,7 @@ export class ClaudeAdapter implements AgentAdapter {
   // A session on the daemon's machine reads the user's own Claude config,
   // so trust for the clone is that config's entry for the clone alone.
   updateLocalWorkspaceTrust(root: string): Promise<() => Promise<void>> {
-    return updateClaudeProjectTrust(resolveClaudeGlobalConfigPath(), root);
+    return updateClaudeProjectTrust(resolveClaudeGlobalConfigPath(this.hostPaths.homeDir), root);
   }
 
   normalizeHook(e: HookEvent): AdapterEvent {

package/src/agents/codex-adapter.ts

@@ -91,9 +91,14 @@ export class CodexAdapter implements AgentAdapter {
 
   private readonly authProfiles: Config['authProfiles'];
 
-  constructor(entry: AgentEntry, config?: Pick<Config, 'authProfiles'>) {
+  // The Codex home whose session index holds session titles; unset, it follows
+  // `CODEX_HOME` or the user's home at each read.
+  private readonly codexHome: string | undefined;
+
+  constructor(entry: AgentEntry, config?: Pick<Config, 'authProfiles'>, codexHome?: string) {
     this.entry = entry;
     this.authProfiles = config?.authProfiles ?? new Map();
+    this.codexHome = codexHome;
     this.id = entry.id;
 
     if (entry.auth !== undefined) {
@@ -323,7 +328,11 @@ export class CodexAdapter implements AgentAdapter {
       return Promise.resolve(null);
     }
 
-    const index = join(resolveAgentHome('CODEX_HOME', '.codex'), 'session_index.jsonl');
+    const index = join(
+      this.codexHome ?? resolveAgentHome('CODEX_HOME', '.codex'),
+      'session_index.jsonl',
+    );
+
     let text: string;
 
     try {

package/src/agents/gateway-adapter.ts

@@ -13,6 +13,7 @@ import type {
   AgentAdapter,
   AgentProfile,
   AuthSelection,
+  ClaudeHostPaths,
   GuestPaths,
   GuestSpawnPlan,
   HeadlessRunner,
@@ -87,13 +88,17 @@ export class GatewayAdapter implements AgentAdapter {
 
   private readonly bridgeTarget: string | undefined;
 
+  private readonly hostPaths: ClaudeHostPaths;
+
   constructor(
     gateway: GatewayConfig,
     config: Config,
     headlessRun: ClaudeHeadlessRun | null = null,
     bridgeTarget?: string,
+    hostPaths: ClaudeHostPaths = {},
   ) {
     this.bridgeTarget = bridgeTarget;
+    this.hostPaths = hostPaths;
     this.gateway = gateway;
     this.config = config;
     this.id = gateway.id;
@@ -121,6 +126,9 @@ export class GatewayAdapter implements AgentAdapter {
         env: {},
       },
       config,
+      null,
+      undefined,
+      hostPaths,
     );
 
     this.headlessRunner =
@@ -433,14 +441,18 @@ export class GatewayAdapter implements AgentAdapter {
   }
 
   private writeSettings(): string {
-    this.settingsFile ??= writeHookSettings({
-      id: this.id,
-      env: { ANTHROPIC_BASE_URL: this.gateway.baseURL, ...this.gateway.env },
-      ...(this.gateway.apiKeyHelper === undefined
-        ? {}
-        : { apiKeyHelper: this.gateway.apiKeyHelper }),
-      ...(this.gateway.settings === undefined ? {} : { settings: this.gateway.settings }),
-    });
+    this.settingsFile ??= writeHookSettings(
+      {
+        id: this.id,
+        env: { ANTHROPIC_BASE_URL: this.gateway.baseURL, ...this.gateway.env },
+        ...(this.gateway.apiKeyHelper === undefined
+          ? {}
+          : { apiKeyHelper: this.gateway.apiKeyHelper }),
+        ...(this.gateway.settings === undefined ? {} : { settings: this.gateway.settings }),
+      },
+      this.hostPaths.stateDir,
+      this.hostPaths.homeDir,
+    );
 
     return this.settingsFile;
   }

package/src/agents/grok-adapter.ts

@@ -90,8 +90,13 @@ export class GrokAdapter implements AgentAdapter {
 
   private readonly hookState = new Map<SessionID, GrokSessionHookState>();
 
-  constructor(entry: AgentEntry) {
+  // Grok's home directory, or null to read it from GROK_HOME (or ~/.grok)
+  // each time it is needed.
+  private readonly home: string | null;
+
+  constructor(entry: AgentEntry, home: string | null = null) {
     this.entry = entry;
+    this.home = home;
     this.id = entry.id;
 
     this.profile = {
@@ -130,7 +135,7 @@ export class GrokAdapter implements AgentAdapter {
     const named: AdapterEvent = {
       ...base,
       ...(agentSessionID !== undefined && payload.cwd !== undefined
-        ? { nameSource: buildGrokNameSource(agentSessionID, payload.cwd) }
+        ? { nameSource: buildGrokNameSource(this.resolveHome(), agentSessionID, payload.cwd) }
         : {}),
     };
 
@@ -213,7 +218,7 @@ export class GrokAdapter implements AgentAdapter {
   }
 
   loadName(source: string, namedBy: 'user' | 'auto' | 'agent'): Promise<NameUpdate | null> {
-    const parsed = readSummary(source) ?? readSummary(findGrokSummary(source));
+    const parsed = readSummary(source) ?? readSummary(findGrokSummary(this.resolveHome(), source));
 
     if (parsed === null) {
       return Promise.resolve(null);
@@ -277,6 +282,10 @@ export class GrokAdapter implements AgentAdapter {
     return event;
   }
 
+  private resolveHome(): string {
+    return this.home ?? resolveAgentHome('GROK_HOME', '.grok');
+  }
+
   // A Map preserves insertion order, so the first key is the oldest entry.
   private removeOldestHookState(): void {
     const oldest = this.hookState.keys().next().value;
@@ -287,14 +296,8 @@ export class GrokAdapter implements AgentAdapter {
   }
 }
 
-function buildGrokNameSource(sessionID: AgentSessionID, cwd: string): string {
-  return join(
-    resolveAgentHome('GROK_HOME', '.grok'),
-    'sessions',
-    encodeURIComponent(cwd),
-    sessionID,
-    'summary.json',
-  );
+function buildGrokNameSource(home: string, sessionID: AgentSessionID, cwd: string): string {
+  return join(home, 'sessions', encodeURIComponent(cwd), sessionID, 'summary.json');
 }
 
 function buildTurnDoneEvent(named: Readonly<AdapterEvent>, payload: GrokHookPayload): AdapterEvent {
@@ -323,14 +326,14 @@ function readSummary(source: string | null): Record<string, unknown> | null {
   }
 }
 
-function findGrokSummary(source: string): string | null {
+function findGrokSummary(home: string, source: string): string | null {
   const sessionID = source.split('/').at(-2);
 
   if (sessionID === undefined || sessionID === '') {
     return null;
   }
 
-  const root = join(resolveAgentHome('GROK_HOME', '.grok'), 'sessions');
+  const root = join(home, 'sessions');
 
   try {
     for (const group of readdirSync(root)) {

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

@@ -17,17 +17,19 @@ import { buildClaudeBundleSettings } from './build-claude-bundle-settings';
  * 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.
+ * missing entry ships nothing. `homeDir` is the user's home, which decides
+ * whether the host folder is the default one.
  */
 export function loadClaudeConfigBundle(
   hostDir: string,
   guestDir: string,
+  homeDir: string = resolveHomeDir(),
 ): Record<string, GuestFile> {
   const hostSettings = readSettings(join(hostDir, 'settings.json'));
 
   const settings = buildClaudeBundleSettings(
     hostSettings,
-    buildHostDirSpellings(hostDir),
+    buildHostDirSpellings(hostDir, homeDir),
     guestDir,
   );
 
@@ -66,10 +68,8 @@ export function loadClaudeConfigBundle(
 // 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];
+function buildHostDirSpellings(hostDir: string, homeDir: string): string[] {
+  return hostDir === join(homeDir, '.claude') ? [hostDir, '~/.claude', '$HOME/.claude'] : [hostDir];
 }
 
 // The host's settings, or none when the file is missing or is not JSON,

package/src/agents/print-codex-hook-file.ts

@@ -4,8 +4,12 @@ import { buildCodexHookFile } from './build-codex-hook-file';
  * Print the Codex hook entries to stdout. The operator merges them into
  * `$CODEX_HOME/hooks.json` and trusts them once in the Codex TUI — Codex
  * parses untrusted hooks but never runs them. atc never writes the user's
- * own Codex config.
+ * own Codex config. `write` takes the printed text, stdout by default.
  */
-export function printCodexHookFile(): void {
-  process.stdout.write(buildCodexHookFile());
+export function printCodexHookFile(
+  write: (text: string) => void = (text) => {
+    process.stdout.write(text);
+  },
+): void {
+  write(buildCodexHookFile());
 }

package/src/agents/print-grok-hook-file.ts

@@ -12,10 +12,15 @@ const GROK_HOOK_EVENTS = [
 
 /**
  * Print the Grok hook file to stdout. The operator copies it to
- * `$GROK_HOME/hooks/atc-reporter.json`; atc never writes that path.
+ * `$GROK_HOME/hooks/atc-reporter.json`; atc never writes that path. `write`
+ * takes the printed text, stdout by default.
  */
-export function printGrokHookFile(): void {
-  process.stdout.write(buildGrokHookFile());
+export function printGrokHookFile(
+  write: (text: string) => void = (text) => {
+    process.stdout.write(text);
+  },
+): void {
+  write(buildGrokHookFile());
 }
 
 function buildGrokHookFile(): string {

package/src/agents/resolve-agent-home.ts

@@ -4,10 +4,14 @@ import { resolveHomeDir } from '../shared/resolve-home-dir';
 /**
  * An agent CLI's home directory: the named environment variable when it is
  * set and non-empty, otherwise the given default directory under the user's
- * home.
+ * home `homeDir`.
  */
-export function resolveAgentHome(envVar: string, defaultDirName: string): string {
+export function resolveAgentHome(
+  envVar: string,
+  defaultDirName: string,
+  homeDir: string = resolveHomeDir(),
+): string {
   const home = process.env[envVar];
 
-  return home !== undefined && home !== '' ? home : join(resolveHomeDir(), defaultDirName);
+  return home !== undefined && home !== '' ? home : join(homeDir, defaultDirName);
 }

package/src/agents/resolve-claude-global-config-path.ts

@@ -7,12 +7,12 @@ import { resolveHomeDir } from '../shared/resolve-home-dir';
  * in, folder trust included, resolved as the CLI resolves it: a legacy
  * `.config.json` in its config folder when one exists, otherwise
  * `.claude.json` in `$CLAUDE_CONFIG_DIR`, or in the user's home when that
- * is unset or empty.
+ * is unset or empty, where `homeDir` is the user's home.
  */
-export function resolveClaudeGlobalConfigPath(): string {
+export function resolveClaudeGlobalConfigPath(homeDir: string = resolveHomeDir()): string {
   const configDir = process.env['CLAUDE_CONFIG_DIR'];
   const custom = configDir !== undefined && configDir !== '' ? configDir : null;
-  const legacy = join(custom ?? join(resolveHomeDir(), '.claude'), '.config.json');
+  const legacy = join(custom ?? join(homeDir, '.claude'), '.config.json');
 
-  return existsSync(legacy) ? legacy : join(custom ?? resolveHomeDir(), '.claude.json');
+  return existsSync(legacy) ? legacy : join(custom ?? homeDir, '.claude.json');
 }

package/src/agents/update-claude-project-trust.ts

@@ -3,6 +3,7 @@ import { readFile, realpath, rename, rm, stat, writeFile } from 'node:fs/promise
 import { dirname, join } from 'node:path';
 import { isRecord } from '../shared/report';
 import { withClaudeConfigLock } from './with-claude-config-lock';
+import type { ClaudeConfigLockOptions } from './with-claude-config-lock';
 
 /**
  * Accepts the Claude CLI's folder trust for one exact directory in its
@@ -15,30 +16,36 @@ import { withClaudeConfigLock } from './with-claude-config-lock';
  * Resolves to a function that takes the trust back, for a launch that
  * fails before the CLI starts: it puts back the entry as it was, unless
  * something has changed the entry since, which leaves it as it stands.
+ * The lock options apply to both the trust and its taking back.
  */
 export async function updateClaudeProjectTrust(
   configPath: string,
   root: string,
+  lockOptions: ClaudeConfigLockOptions = {},
 ): Promise<() => Promise<void>> {
-  const previous = await withClaudeConfigLock(configPath, async () => {
-    const config = await loadClaudeConfig(configPath);
+  const previous = await withClaudeConfigLock(
+    configPath,
+    async () => {
+      const config = await loadClaudeConfig(configPath);
 
-    const projects = isRecord(config['projects']) ? config['projects'] : {};
-    const entry = projects[root];
+      const projects = isRecord(config['projects']) ? config['projects'] : {};
+      const entry = projects[root];
 
-    if (isRecord(entry) && entry['hasTrustDialogAccepted'] === true) {
-      return null;
-    }
+      if (isRecord(entry) && entry['hasTrustDialogAccepted'] === true) {
+        return null;
+      }
 
-    const base = isRecord(entry) ? entry : {};
+      const base = isRecord(entry) ? entry : {};
 
-    await writeClaudeConfig(configPath, {
-      ...config,
-      projects: { ...projects, [root]: { ...base, hasTrustDialogAccepted: true } },
-    });
+      await writeClaudeConfig(configPath, {
+        ...config,
+        projects: { ...projects, [root]: { ...base, hasTrustDialogAccepted: true } },
+      });
 
-    return { entry: isRecord(entry) ? entry : null };
-  });
+      return { entry: isRecord(entry) ? entry : null };
+    },
+    lockOptions,
+  );
 
   if (previous === null) {
     return () => Promise.resolve();
@@ -50,22 +57,26 @@ export async function updateClaudeProjectTrust(
   });
 
   return () =>
-    withClaudeConfigLock(configPath, async () => {
-      const config = await loadClaudeConfig(configPath);
-
-      const projects = isRecord(config['projects']) ? config['projects'] : {};
-
-      if (JSON.stringify(projects[root]) !== written) {
-        return;
-      }
-
-      const { [root]: _trusted, ...others } = projects;
-
-      await writeClaudeConfig(configPath, {
-        ...config,
-        projects: previous.entry === null ? others : { ...others, [root]: previous.entry },
-      });
-    });
+    withClaudeConfigLock(
+      configPath,
+      async () => {
+        const config = await loadClaudeConfig(configPath);
+
+        const projects = isRecord(config['projects']) ? config['projects'] : {};
+
+        if (JSON.stringify(projects[root]) !== written) {
+          return;
+        }
+
+        const { [root]: _trusted, ...others } = projects;
+
+        await writeClaudeConfig(configPath, {
+          ...config,
+          projects: previous.entry === null ? others : { ...others, [root]: previous.entry },
+        });
+      },
+      lockOptions,
+    );
 }
 
 // The config as the CLI last wrote it; a missing file is an empty config,

package/src/agents/with-claude-config-lock.ts

@@ -12,6 +12,15 @@ const REFRESH_MS = 1000;
 const WAIT_MS = 5000;
 const RETRY_MS = 50;
 
+/**
+ * Tuning a caller may pass: how often a held lock's age is refreshed, and a
+ * callback run each time the lock is found held by someone else.
+ */
+export interface ClaudeConfigLockOptions {
+  readonly refreshMs?: number;
+  readonly onBusy?: () => void;
+}
+
 /**
  * Runs the callback while holding the lock the Claude CLI takes before it
  * writes its global config: a directory beside the file named for it with
@@ -25,6 +34,7 @@ const RETRY_MS = 50;
 export async function withClaudeConfigLock<T>(
   configPath: string,
   run: () => Promise<T>,
+  options: ClaudeConfigLockOptions = {},
 ): Promise<T> {
   const lockPath = `${configPath}.lock`;
   const deadline = Date.now() + WAIT_MS;
@@ -34,6 +44,8 @@ export async function withClaudeConfigLock<T>(
   let held = await tryCreateLockDir(lockPath);
 
   while (held === null) {
+    options.onBusy?.();
+
     if (Date.now() > deadline) {
       throw new Error(`timed out waiting for the Claude config lock ${lockPath}`);
     }
@@ -52,7 +64,7 @@ export async function withClaudeConfigLock<T>(
 
       owned = refreshed ?? owned;
     })();
-  }, REFRESH_MS);
+  }, options.refreshMs ?? REFRESH_MS);
 
   try {
     return await run();

package/src/agents/write-atc-bridge.ts

@@ -6,14 +6,17 @@ import { buildCLIArgv } from './build-cli-argv';
 
 /**
  * Writes the atc-bridge mod that every Claude session loads with
- * `--plugin-dir`, with the atc command it runs rendered for this install,
- * and returns its folder. A file whose content already matches is left
- * untouched, since any write reloads the mod in every running session, and
- * the folder is never cleared, since Claude Code keeps its own type files
- * there.
+ * `--plugin-dir`, with the atc command it runs rendered in (by default this
+ * install's own), and returns its folder. A file whose content already
+ * matches is left untouched, since any write reloads the mod in every running
+ * session, and the folder is never cleared, since Claude Code keeps its own
+ * type files there.
  */
-export function writeATCBridge(dir: string = join(stateDir, 'atc-bridge')): string {
-  const files = buildATCBridgeFiles(buildCLIArgv());
+export function writeATCBridge(
+  dir: string = join(stateDir, 'atc-bridge'),
+  argv: readonly string[] = buildCLIArgv(),
+): string {
+  const files = buildATCBridgeFiles(argv);
 
   for (const [path, content] of Object.entries(files)) {
     const file = join(dir, path);

package/src/agents/write-hook-settings.ts

@@ -8,13 +8,19 @@ import type { HookSettingsProfile } from './build-hook-settings';
 
 /**
  * Writes the settings file passed to a wrangled session as
- * `claude --settings`, one per agent id, and returns its path.
+ * `claude --settings`, one per agent id, into the folder `dir`, and returns
+ * its path. The statusline padding comes from the Claude settings in the
+ * user's home `homeDir`.
  */
-export function writeHookSettings(profile: HookSettingsProfile): string {
-  const file = join(stateDir, `hook-settings-${profile.id}.json`);
-  const settings = buildHookSettings(profile, readStatuslinePadding());
+export function writeHookSettings(
+  profile: HookSettingsProfile,
+  dir: string = stateDir,
+  homeDir: string = resolveHomeDir(),
+): string {
+  const file = join(dir, `hook-settings-${profile.id}.json`);
+  const settings = buildHookSettings(profile, readStatuslinePadding(homeDir));
 
-  mkdirSync(stateDir, { recursive: true });
+  mkdirSync(dir, { recursive: true });
   writeFileSync(file, JSON.stringify(settings, null, 2));
 
   return file;
@@ -24,9 +30,9 @@ export function writeHookSettings(profile: HookSettingsProfile): string {
  * The padding on the user's own statusline, so the chained one lines up with
  * it. An unreadable or unconfigured setting is no padding.
  */
-function readStatuslinePadding(): number {
+function readStatuslinePadding(homeDir: string): number {
   try {
-    const raw = readFileSync(join(resolveHomeDir(), '.claude', 'settings.json'), 'utf8');
+    const raw = readFileSync(join(homeDir, '.claude', 'settings.json'), 'utf8');
     const user: unknown = JSON.parse(raw);
     const statusLine = isRecord(user) ? user['statusLine'] : undefined;
     const padding = isRecord(statusLine) ? statusLine['padding'] : undefined;