@zgeoff/atc 3.3.1 → 3.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/atc",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "description": "Terminal control tower for coding-agent sessions",
   "homepage": "https://github.com/zgeoff/atc#readme",
   "bugs": "https://github.com/zgeoff/atc/issues",
@@ -30,8 +30,8 @@
     "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:gateway-binary": "bash scripts/with-test-home.sh bun test --timeout 20000 src/gateway.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 e2e/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",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -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-agent-adapters.ts

@@ -1,11 +1,20 @@
 import type { Config } from '../shared/config';
-import type { AgentAdapter } from './agent-adapter';
+import type { AgentAdapter, ClaudeHostPaths } from './agent-adapter';
 import { ClaudeAdapter } from './claude-adapter';
 import { CodexAdapter } from './codex-adapter';
 import { GatewayAdapter } from './gateway-adapter';
 import { GrokAdapter } from './grok-adapter';
 import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 
+/**
+ * Where the Claude and gateway adapters write their settings file and their
+ * copy of the atc-bridge mod, and the home whose Claude config they read. A
+ * field left out takes atc's state folder or the running user's home.
+ */
+interface AgentAdapterPaths extends ClaudeHostPaths {
+  readonly bridgeTarget?: string;
+}
+
 /**
  * One adapter per registry entry, in registry order. A Claude entry with a
  * base URL is a gateway, and one without is stock Claude.
@@ -13,7 +22,10 @@ import type { ClaudeHeadlessRun } from './make-claude-headless-runner';
 export function buildAgentAdapters(
   config: Config,
   headlessRun: ClaudeHeadlessRun | null = null,
+  paths: AgentAdapterPaths = {},
 ): AgentAdapter[] {
+  const { bridgeTarget, ...hostPaths } = paths;
+
   return config.agents.map((entry): AgentAdapter => {
     if (entry.kind === 'codex') {
       return new CodexAdapter(entry, config);
@@ -24,9 +36,15 @@ export function buildAgentAdapters(
     }
 
     if (entry.baseURL === undefined) {
-      return new ClaudeAdapter(entry, config, headlessRun);
+      return new ClaudeAdapter(entry, config, headlessRun, bridgeTarget, hostPaths);
     }
 
-    return new GatewayAdapter({ ...entry, baseURL: entry.baseURL }, config, headlessRun);
+    return new GatewayAdapter(
+      { ...entry, baseURL: entry.baseURL },
+      config,
+      headlessRun,
+      bridgeTarget,
+      hostPaths,
+    );
   });
 }

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

@@ -53,6 +53,11 @@ type CodexHookPayload = z.infer<typeof CODEX_HOOK_PAYLOAD_SCHEMA>;
 // The spellings of the Codex CLI's model flag.
 const CODEX_MODEL_FLAGS = ['-m', '--model'];
 
+// The Codex CLI flag that runs a terminal without the shared background
+// server, and the flag that connects it to a remote server instead.
+const NO_DAEMON_FLAG = '--no-daemon';
+const REMOTE_FLAG = '--remote';
+
 /**
  * The Codex CLI adapter: spawn arguments, hook payload mapping, resume
  * semantics, and session_index.jsonl name-pulling. Hooks are a user-installed
@@ -91,9 +96,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) {
@@ -113,6 +123,14 @@ export class CodexAdapter implements AgentAdapter {
     return {
       bin: this.entry.bin,
       args: [
+        // Codex's shared background server keeps the environment of the
+        // terminal that started it and runs every thread's hooks and tools
+        // there, so a terminal on it reports as that first session. Each
+        // terminal therefore runs its own server. The configured arguments
+        // already carry the flag, or connect to a remote server, which Codex
+        // refuses to combine with it; either way Codex takes no second copy.
+        ...(this.entry.args.some(isDaemonChoiceFlag) ? [] : [NO_DAEMON_FLAG]),
+
         // A model override replaces any model flag the configured arguments
         // carry, and travels as its own argument.
         ...(opts.model === undefined
@@ -323,7 +341,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 {
@@ -411,3 +433,10 @@ function buildCodexSpawnOptions(codexArgs: readonly string[]): SpawnOptionSpecs
     },
   };
 }
+
+// Whether a configured argument already decides which server a terminal
+// uses: the flag that runs it without the shared one, or the remote server
+// flag in either of its spellings.
+function isDaemonChoiceFlag(arg: string): boolean {
+  return arg === NO_DAEMON_FLAG || arg === REMOTE_FLAG || arg.startsWith(`${REMOTE_FLAG}=`);
+}

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/render-sdk-message.ts

@@ -0,0 +1,57 @@
+import { isRecord } from '../shared/report';
+import { truncateSummary } from '../shared/truncate-summary';
+
+interface RenderableMessage {
+  readonly type: string;
+  readonly subtype?: string;
+  readonly result?: string;
+  readonly message?: unknown;
+}
+
+/**
+ * One structured SDK message → zero or one plain-text line for the session's
+ * output pipe: assistant text verbatim, tool calls as compact one-liners,
+ * results as a closing line.
+ */
+export function renderSDKMessage(message: RenderableMessage): string | null {
+  if (message.type === 'assistant') {
+    const inner = message.message;
+
+    if (!isRecord(inner) || !Array.isArray(inner['content'])) {
+      return null;
+    }
+
+    const content = inner['content'];
+    const lines: string[] = [];
+
+    for (const raw of content) {
+      const block: unknown = raw;
+
+      if (!isRecord(block)) {
+        continue;
+      }
+
+      if (
+        block['type'] === 'text' &&
+        typeof block['text'] === 'string' &&
+        block['text'].trim() !== ''
+      ) {
+        lines.push(block['text'].replaceAll('\n', '\r\n'));
+      }
+
+      if (block['type'] === 'tool_use' && typeof block['name'] === 'string') {
+        lines.push(`⚙ ${block['name']} ${truncateSummary(JSON.stringify(block['input'] ?? {}))}`);
+      }
+    }
+
+    return lines.length === 0 ? null : lines.join('\r\n');
+  }
+
+  if (message.type === 'result') {
+    return message.subtype === 'success'
+      ? `— headless turn done: ${truncateSummary(message.result ?? '')}`
+      : `— headless turn stopped: ${message.subtype ?? 'unknown'}`;
+  }
+
+  return null;
+}

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/start-claude-headless-run.ts

@@ -1,8 +1,8 @@
 import { isCompiledBinary } from '../shared/is-compiled-binary';
-import { isRecord } from '../shared/report';
 import { truncateSummary } from '../shared/truncate-summary';
 import { buildClaudeQueryOptions } from './build-claude-query-options';
 import type { ClaudeHeadlessRunRequest } from './build-claude-query-options';
+import { renderSDKMessage } from './render-sdk-message';
 
 interface HeadlessRunHooks {
   readonly onOutput: (text: string) => void;
@@ -47,7 +47,7 @@ export function startClaudeHeadlessRun(
       });
 
       for await (const message of stream) {
-        const rendered = renderSdkMessage(message);
+        const rendered = renderSDKMessage(message);
 
         if (rendered !== null) {
           hooks.onOutput(`${rendered}\r\n`);
@@ -84,58 +84,3 @@ export function startClaudeHeadlessRun(
     },
   };
 }
-
-interface RenderableMessage {
-  readonly type: string;
-  readonly subtype?: string;
-  readonly result?: string;
-  readonly message?: unknown;
-}
-
-/**
- * One structured SDK message → zero or one plain-text line for the session's
- * output pipe: assistant text verbatim, tool calls as compact one-liners,
- * results as a closing line.
- */
-export function renderSdkMessage(message: RenderableMessage): string | null {
-  if (message.type === 'assistant') {
-    const inner = message.message;
-
-    if (!isRecord(inner) || !Array.isArray(inner['content'])) {
-      return null;
-    }
-
-    const content = inner['content'];
-    const lines: string[] = [];
-
-    for (const raw of content) {
-      const block: unknown = raw;
-
-      if (!isRecord(block)) {
-        continue;
-      }
-
-      if (
-        block['type'] === 'text' &&
-        typeof block['text'] === 'string' &&
-        block['text'].trim() !== ''
-      ) {
-        lines.push(block['text'].replaceAll('\n', '\r\n'));
-      }
-
-      if (block['type'] === 'tool_use' && typeof block['name'] === 'string') {
-        lines.push(`⚙ ${block['name']} ${truncateSummary(JSON.stringify(block['input'] ?? {}))}`);
-      }
-    }
-
-    return lines.length === 0 ? null : lines.join('\r\n');
-  }
-
-  if (message.type === 'result') {
-    return message.subtype === 'success'
-      ? `— headless turn done: ${truncateSummary(message.result ?? '')}`
-      : `— headless turn stopped: ${message.subtype ?? 'unknown'}`;
-  }
-
-  return null;
-}