@cleocode/adapters 2026.9.19 → 2026.9.21

package/src/providers/claude-code/hooks.ts

@@ -16,11 +16,18 @@
  * @epic T134
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { updateJsonConfigFile } from '@cleocode/caamp';
 import type { AdapterHookProvider } from '@cleocode/contracts';
+import {
+  appendHookEntry,
+  claudeSettingsPath,
+  hasCleoHook,
+  hookMap,
+  removeCleoHookEntries,
+} from './paths.js';
 
 /** CAAMP provider identifier for Claude Code. */
 const PROVIDER_ID = 'claude-code' as const;
@@ -133,56 +140,23 @@ export class ClaudeCodeHookProvider implements AdapterHookProvider {
     this.projectDir = projectDir;
     this.registered = true;
 
-    // Write CLEO hook entries to ~/.claude/settings.json (idempotent)
-    try {
-      const home = homedir();
-      const settingsPath = join(home, '.claude', 'settings.json');
-
-      let settings: Record<string, unknown> = {};
-      if (existsSync(settingsPath)) {
-        try {
-          settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-        } catch {
-          // Start fresh if settings.json is corrupt
-        }
-      }
-
-      const hooks = (settings.hooks ?? {}) as Record<string, unknown[]>;
-
-      // Check if CLEO hooks already registered (look for our marker comment in commands)
-      const alreadyRegistered = Object.values(hooks).some(
-        (entries) =>
-          Array.isArray(entries) &&
-          entries.some(
-            (e) =>
-              typeof e === 'object' &&
-              e !== null &&
-              Array.isArray((e as Record<string, unknown>).hooks) &&
-              ((e as Record<string, unknown>).hooks as Array<Record<string, string>>).some(
-                (h) => typeof h.command === 'string' && h.command.includes('# cleo-hook'),
-              ),
-          ),
-      );
-
-      if (alreadyRegistered) {
-        return; // Already wired — idempotent
+    // Write CLEO hook entries to settings.json (idempotent). T12385: locked,
+    // atomic, and a malformed file is reported and left untouched — never
+    // replaced with an object holding only CLEO's entries.
+    await this.updateSettings((settings) => {
+      const hooks = hookMap(settings);
+      if (Object.values(hooks).some((entries) => hasCleoHook(entries))) {
+        return false; // Already wired — idempotent
       }
 
       // Register Stop hook → triggers cleo session end (LLM extraction, reflector, consolidation)
-      if (!hooks.Stop) hooks.Stop = [];
-      (hooks.Stop as unknown[]).push({
+      appendHookEntry(hooks, 'Stop', {
         matcher: '',
-        hooks: [
-          {
-            type: 'command',
-            command: `cleo session end --quiet # cleo-hook`,
-          },
-        ],
+        hooks: [{ type: 'command', command: `cleo session end --quiet # cleo-hook` }],
       });
 
       // Register PostToolUse hook → brain observation for file writes + NEXUS post-check (T625)
-      if (!hooks.PostToolUse) hooks.PostToolUse = [];
-      (hooks.PostToolUse as unknown[]).push({
+      appendHookEntry(hooks, 'PostToolUse', {
         matcher: 'Write|Edit',
         hooks: [
           {
@@ -197,20 +171,16 @@ export class ClaudeCodeHookProvider implements AdapterHookProvider {
           },
         ],
       });
-
-      settings.hooks = hooks;
-      mkdirSync(join(home, '.claude'), { recursive: true });
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    } catch {
-      // Settings write failure is non-fatal — hooks can be registered manually
-    }
+      return true;
+    });
   }
 
   /**
    * Unregister native hooks.
    *
-   * Removes CLEO hook entries from `~/.claude/settings.json` by filtering out
-   * entries containing the `# cleo-hook` marker.
+   * Removes CLEO hook entries from Claude Code's `settings.json` by filtering
+   * out entries containing the `# cleo-hook` marker. Same locking, atomicity
+   * and parse-error rules as {@link registerNativeHooks}.
    *
    * @task T164 @task T555
    */
@@ -218,42 +188,43 @@ export class ClaudeCodeHookProvider implements AdapterHookProvider {
     this.registered = false;
     this.projectDir = null;
 
-    try {
-      const home = homedir();
-      const settingsPath = join(home, '.claude', 'settings.json');
-      if (!existsSync(settingsPath)) return;
-
-      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8')) as Record<string, unknown>;
-      const hooks = settings.hooks as Record<string, unknown[]> | undefined;
-      if (!hooks) return;
-
-      // Filter out entries with the cleo-hook marker
-      let changed = false;
-      for (const [event, entries] of Object.entries(hooks)) {
-        if (!Array.isArray(entries)) continue;
-        const filtered = entries.filter(
-          (e) =>
-            !(
-              typeof e === 'object' &&
-              e !== null &&
-              Array.isArray((e as Record<string, unknown>).hooks) &&
-              ((e as Record<string, unknown>).hooks as Array<Record<string, string>>).some(
-                (h) => typeof h.command === 'string' && h.command.includes('# cleo-hook'),
-              )
-            ),
-        );
-        if (filtered.length !== entries.length) {
-          hooks[event] = filtered;
-          changed = true;
-        }
-      }
+    if (!existsSync(claudeSettingsPath())) return;
+    await this.updateSettings((settings) => {
+      if (settings.hooks === undefined) return false;
+      return removeCleoHookEntries(hookMap(settings));
+    });
+  }
 
-      if (changed) {
-        settings.hooks = hooks;
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-      }
-    } catch {
-      // Cleanup failure is non-fatal
+  /** The last settings.json failure, or `null` when the last update succeeded. */
+  private settingsError: string | null = null;
+
+  /**
+   * Why the last settings.json update did not happen, or `null`.
+   *
+   * @remarks
+   * Hook registration stays non-fatal for adapter initialisation, so a
+   * refused write (malformed settings.json, lock timeout) is surfaced here and
+   * on stderr instead of being swallowed (T12385).
+   *
+   * @returns The failure message, or `null`
+   */
+  getSettingsError(): string | null {
+    return this.settingsError;
+  }
+
+  /** Apply `mutate` to settings.json via CAAMP's locked, atomic JSON writer. */
+  private async updateSettings(
+    mutate: (settings: Record<string, unknown>) => boolean,
+  ): Promise<void> {
+    const settingsPath = claudeSettingsPath();
+    try {
+      await updateJsonConfigFile(settingsPath, mutate);
+      this.settingsError = null;
+    } catch (err) {
+      this.settingsError = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `[cleo:claude-code] hooks not written to ${settingsPath}: ${this.settingsError}\n`,
+      );
     }
   }
 

package/src/providers/claude-code/install.ts

@@ -10,23 +10,23 @@
  * @task T5240
  */
 
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { ensureProviderInstructionFile } from '@cleocode/caamp';
+import { ensureProviderInstructionFile, updateJsonConfigFile } from '@cleocode/caamp';
 import type { AdapterInstallProvider, InstallOptions, InstallResult } from '@cleocode/contracts';
 import {
   type InstallHookTemplatesResult,
   installProviderHookTemplates,
 } from '../shared/hook-template-installer.js';
+import {
+  appendHookEntry,
+  claudeSettingsPath,
+  hasCleoHook,
+  hookMap,
+  isPlainObject,
+} from './paths.js';
 
 /** Resolve Claude Code's config directory, honoring the documented CI override. */
 function getClaudeConfigDir(): string {
@@ -80,21 +80,37 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
       details.commands = commandsInstalled;
     }
 
+    // T12385: settings.json writes are locked + atomic, and a malformed file
+    // aborts the write and is reported here — it is never reset to `{}`.
+    const settingsErrors: string[] = [];
+
     // Step 3: Register plugin in ~/.claude/settings.json
-    const pluginResult = this.registerPlugin();
-    if (pluginResult) {
-      details.plugin = pluginResult;
+    try {
+      const pluginResult = await this.registerPlugin();
+      if (pluginResult) {
+        details.plugin = pluginResult;
+      }
+    } catch (err) {
+      settingsErrors.push(err instanceof Error ? err.message : String(err));
     }
 
     // Step 4 (T1013): Install PreCompact hook templates + wire the handler
     // command into ~/.claude/settings.json's `PreCompact` event.
-    const hookResult = this.installHookTemplates();
-    if (hookResult) {
-      details.hookTemplates = hookResult;
+    try {
+      const hookResult = await this.installHookTemplates();
+      if (hookResult) {
+        details.hookTemplates = hookResult;
+      }
+    } catch (err) {
+      settingsErrors.push(err instanceof Error ? err.message : String(err));
+    }
+
+    if (settingsErrors.length > 0) {
+      details.settingsErrors = settingsErrors;
     }
 
     return {
-      success: true,
+      success: settingsErrors.length === 0,
       installedAt,
       instructionFileUpdated,
       details,
@@ -115,7 +131,7 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
    */
   async isInstalled(): Promise<boolean> {
     // Check ~/.claude/settings.json for plugin registration
-    const settingsPath = join(getClaudeConfigDir(), 'settings.json');
+    const settingsPath = claudeSettingsPath();
     if (existsSync(settingsPath)) {
       try {
         const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
@@ -179,38 +195,28 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
    *
    * @returns Description of what was registered, or null if no change needed
    */
-  private registerPlugin(): string | null {
-    const claudeDir = getClaudeConfigDir();
-    const settingsPath = join(claudeDir, 'settings.json');
-
-    let settings: Record<string, unknown> = {};
-    if (existsSync(settingsPath)) {
-      try {
-        settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-      } catch {
-        // Start fresh
-      }
-    }
-
-    const enabledPlugins = (settings.enabledPlugins as Record<string, boolean>) ?? {};
+  private async registerPlugin(): Promise<string | null> {
     const pluginKey = 'cleo@cleocode';
+    const wrote = await updateJsonConfigFile(claudeSettingsPath(), (settings) => {
+      const enabledPlugins = settings.enabledPlugins ?? {};
+      if (!isPlainObject(enabledPlugins)) {
+        throw new Error('settings.json "enabledPlugins" is not an object; not modifying it');
+      }
+      if (enabledPlugins[pluginKey] === true) {
+        return false;
+      }
 
-    if (enabledPlugins[pluginKey] === true) {
-      return null;
-    }
-
-    // Disable old claude-mem if present
-    if (enabledPlugins['claude-mem@thedotmack'] === true) {
-      enabledPlugins['claude-mem@thedotmack'] = false;
-    }
-
-    enabledPlugins[pluginKey] = true;
-    settings.enabledPlugins = enabledPlugins;
+      // Disable old claude-mem if present
+      if (enabledPlugins['claude-mem@thedotmack'] === true) {
+        enabledPlugins['claude-mem@thedotmack'] = false;
+      }
 
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+      enabledPlugins[pluginKey] = true;
+      settings.enabledPlugins = enabledPlugins;
+      return true;
+    });
 
-    return `Enabled ${pluginKey} in ~/.claude/settings.json`;
+    return wrote ? `Enabled ${pluginKey} in ~/.claude/settings.json` : null;
   }
 
   /**
@@ -233,10 +239,10 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
    *
    * @task T1013
    */
-  private installHookTemplates(): {
+  private async installHookTemplates(): Promise<{
     templates: InstallHookTemplatesResult;
     settingsEntryAdded: boolean;
-  } | null {
+  } | null> {
     const claudeDir = getClaudeConfigDir();
     const hooksDir = join(claudeDir, 'hooks');
 
@@ -254,7 +260,7 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
     }
 
     // 2. Wire the PreCompact event in ~/.claude/settings.json.
-    const settingsEntryAdded = this.registerPreCompactHook(
+    const settingsEntryAdded = await this.registerPreCompactHook(
       join(hooksDir, 'precompact-safestop.sh'),
     );
 
@@ -279,55 +285,23 @@ export class ClaudeCodeInstallProvider implements AdapterInstallProvider {
    *
    * @task T1013
    */
-  private registerPreCompactHook(shimPath: string): boolean {
-    const claudeDir = getClaudeConfigDir();
-    const settingsPath = join(claudeDir, 'settings.json');
-
-    let settings: Record<string, unknown> = {};
-    if (existsSync(settingsPath)) {
-      try {
-        settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
-      } catch {
-        // Start fresh on corrupt settings — safer than aborting install.
+  private async registerPreCompactHook(shimPath: string): Promise<boolean> {
+    return updateJsonConfigFile(claudeSettingsPath(), (settings) => {
+      const hooks = hookMap(settings);
+      if (hasCleoHook(hooks.PreCompact, 'precompact-safestop.sh')) {
+        return false;
       }
-    }
-
-    const hooks = (settings.hooks as Record<string, unknown[]> | undefined) ?? {};
-    const preCompactEntries = (hooks.PreCompact as unknown[] | undefined) ?? [];
-
-    const alreadyWired = preCompactEntries.some(
-      (entry) =>
-        typeof entry === 'object' &&
-        entry !== null &&
-        Array.isArray((entry as Record<string, unknown>).hooks) &&
-        ((entry as Record<string, unknown>).hooks as Array<Record<string, unknown>>).some(
-          (h) =>
-            typeof h.command === 'string' &&
-            (h.command as string).includes('# cleo-hook') &&
-            (h.command as string).includes('precompact-safestop.sh'),
-        ),
-    );
-
-    if (alreadyWired) {
-      return false;
-    }
-
-    preCompactEntries.push({
-      matcher: '',
-      hooks: [
-        {
-          type: 'command',
-          command: `"${shimPath}" # cleo-hook`,
-          timeout: 30,
-        },
-      ],
+      appendHookEntry(hooks, 'PreCompact', {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: `"${shimPath}" # cleo-hook`,
+            timeout: 30,
+          },
+        ],
+      });
+      return true;
     });
-
-    hooks.PreCompact = preCompactEntries;
-    settings.hooks = hooks;
-
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return true;
   }
 }

package/src/providers/claude-code/paths.ts

@@ -44,3 +44,158 @@ export class ClaudeCodePathProvider implements AdapterPathProvider {
     return process.env['CLAUDE_MEM_DB'] ?? join(homedir(), '.claude-mem', 'claude-mem.db');
   }
 }
+
+/**
+ * Resolve Claude Code's `settings.json`, honouring `CLAUDE_SETTINGS` and
+ * `CLAUDE_HOME`.
+ *
+ * @remarks
+ * The single resolver for every adapter write to the settings file (T12385).
+ * Hook registration previously hard-coded `~/.claude/settings.json` while the
+ * installer honoured `CLAUDE_HOME`, so the two wrote different files whenever
+ * the override was set.
+ *
+ * @returns Absolute path of the settings file
+ *
+ * @example
+ * ```typescript
+ * const settingsPath = claudeSettingsPath();
+ * ```
+ */
+export function claudeSettingsPath(): string {
+  return (
+    new ClaudeCodePathProvider().getSettingsPath() ?? join(homedir(), '.claude', 'settings.json')
+  );
+}
+
+/** Marker CLEO puts in every hook command it owns. */
+const CLEO_HOOK_MARKER = '# cleo-hook';
+
+/**
+ * Whether a parsed settings value is a plain JSON object.
+ *
+ * @param value - Any parsed JSON value
+ * @returns `true` for a non-null, non-array object
+ *
+ * @example
+ * ```typescript
+ * isPlainObject(settings.enabledPlugins);
+ * ```
+ */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Whether a settings.json hook entry carries a CLEO-owned command.
+ *
+ * @param entry - One element of a `hooks.<Event>` array
+ * @param commandIncludes - Extra substring the CLEO command must contain
+ * @returns `true` when one of the entry's commands has the `# cleo-hook` marker
+ *
+ * @example
+ * ```typescript
+ * isCleoHookEntry({ hooks: [{ type: "command", command: "x # cleo-hook" }] }); // true
+ * ```
+ */
+export function isCleoHookEntry(entry: unknown, commandIncludes?: string): boolean {
+  if (!isPlainObject(entry) || !Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some(
+    (hook) =>
+      isPlainObject(hook) &&
+      typeof hook.command === 'string' &&
+      hook.command.includes(CLEO_HOOK_MARKER) &&
+      (commandIncludes === undefined || hook.command.includes(commandIncludes)),
+  );
+}
+
+/**
+ * Whether a `hooks.<Event>` value holds a CLEO-owned entry.
+ *
+ * @param entries - The event's value (non-arrays hold none)
+ * @param commandIncludes - Extra substring the CLEO command must contain
+ * @returns `true` when a CLEO entry is present
+ *
+ * @example
+ * ```typescript
+ * hasCleoHook(hookMap(settings).Stop);
+ * ```
+ */
+export function hasCleoHook(entries: unknown, commandIncludes?: string): boolean {
+  return Array.isArray(entries) && entries.some((e) => isCleoHookEntry(e, commandIncludes));
+}
+
+/**
+ * Return the settings object's `hooks` map, creating an empty one if absent.
+ *
+ * @param settings - Parsed settings.json
+ * @returns The live `hooks` object (mutations apply to `settings`)
+ * @throws Error when `hooks` exists but is not an object — the caller's write
+ *   is aborted and the file left untouched
+ *
+ * @example
+ * ```typescript
+ * const hooks = hookMap(settings);
+ * ```
+ */
+export function hookMap(settings: Record<string, unknown>): Record<string, unknown> {
+  const existing = settings.hooks;
+  if (existing === undefined) {
+    const created: Record<string, unknown> = {};
+    settings.hooks = created;
+    return created;
+  }
+  if (!isPlainObject(existing)) {
+    throw new Error('settings.json "hooks" is not an object; not modifying it');
+  }
+  return existing;
+}
+
+/**
+ * Append a hook entry to `hooks[event]`, preserving existing entries.
+ *
+ * @param hooks - The settings `hooks` map
+ * @param event - Native event name (e.g. `Stop`, `PreCompact`)
+ * @param entry - Entry to append
+ * @throws Error when `hooks[event]` exists but is not an array
+ *
+ * @example
+ * ```typescript
+ * appendHookEntry(hookMap(settings), "Stop", { matcher: "", hooks: [] });
+ * ```
+ */
+export function appendHookEntry(
+  hooks: Record<string, unknown>,
+  event: string,
+  entry: Record<string, unknown>,
+): void {
+  const existing = hooks[event];
+  if (existing !== undefined && !Array.isArray(existing)) {
+    throw new Error(`settings.json "hooks.${event}" is not an array; not modifying it`);
+  }
+  hooks[event] = [...(existing ?? []), entry];
+}
+
+/**
+ * Remove every CLEO-owned entry from every event array in `hooks`.
+ *
+ * @param hooks - The settings `hooks` map
+ * @returns Whether anything was removed
+ *
+ * @example
+ * ```typescript
+ * const changed = removeCleoHookEntries(hookMap(settings));
+ * ```
+ */
+export function removeCleoHookEntries(hooks: Record<string, unknown>): boolean {
+  let changed = false;
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const kept = entries.filter((e) => !isCleoHookEntry(e));
+    if (kept.length !== entries.length) {
+      hooks[event] = kept;
+      changed = true;
+    }
+  }
+  return changed;
+}

package/src/providers/claude-code/spawn.ts

@@ -13,9 +13,7 @@
  * @task T11998 — per-session scope/pgid suite containment
  */
 
-import { exec, spawn as nodeSpawn } from 'node:child_process';
-import { unlink, writeFile } from 'node:fs/promises';
-import { promisify } from 'node:util';
+import { spawn as nodeSpawn } from 'node:child_process';
 import type {
   AdapterSpawnProvider,
   AgentSuiteOwnership,
@@ -23,11 +21,11 @@ import type {
   SpawnResult,
 } from '@cleocode/contracts';
 import { getErrorMessage } from '@cleocode/contracts';
+import { findOnPath } from '@cleocode/paths';
 import { buildAgentSpawnArgs } from '../shared/agent-spawn-wrapper.js';
+import { removeSpawnPromptFile, writeSpawnPromptFile } from '../shared/prompt-file.js';
 import { reapAgentSuite } from './suite-reaper.js';
 
-const execAsync = promisify(exec);
-
 /** Internal tracking entry for a spawned process. */
 interface TrackedProcess {
   pid: number;
@@ -48,7 +46,7 @@ interface TrackedProcess {
  * @remarks
  * The provider uses `--allow-insecure --no-upgrade-check` flags to
  * ensure the Claude CLI starts without interactive prompts. Prompts are
- * written to temporary files under `/tmp/` and cleaned up after the
+ * written to temporary files under a private temp directory (`os.tmpdir()`) and cleaned up after the
  * child process exits. Processes are tracked by instance ID in an
  * in-memory map and verified via `kill(pid, 0)` liveness checks.
  */
@@ -59,15 +57,10 @@ export class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
   /**
    * Check if the Claude CLI is available in PATH.
    *
-   * @returns true if `claude` is found via `which`
+   * @returns true if `claude` is found on PATH (PATHEXT-aware on Windows)
    */
   async canSpawn(): Promise<boolean> {
-    try {
-      await execAsync('which claude');
-      return true;
-    } catch {
-      return false;
-    }
+    return findOnPath('claude') !== null;
   }
 
   /**
@@ -103,8 +96,7 @@ export class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
         // CANT enrichment unavailable — use raw prompt
       }
 
-      tmpFile = `/tmp/claude-spawn-${instanceId}.txt`;
-      await writeFile(tmpFile, enrichedPrompt, 'utf-8');
+      tmpFile = await writeSpawnPromptFile('claude-spawn', enrichedPrompt);
 
       // --print: non-interactive batch mode (process prompt, output response, exit)
       // --dangerously-skip-permissions: allow all tool calls without human approval
@@ -131,6 +123,8 @@ export class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
       const spawnOpts: Parameters<typeof nodeSpawn>[2] = {
         detached: !isSystemd,
         stdio: ['ignore', 'pipe', 'pipe'],
+        // win32 `.cmd` shim routed through cmd.exe: keep its quoting (T12618).
+        ...(spawnBuild.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
       };
 
       if (context.workingDirectory) {
@@ -177,11 +171,7 @@ export class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
       const capturedTmpFile = tmpFile;
       child.on('exit', async () => {
         this.processMap.delete(instanceId);
-        try {
-          await unlink(capturedTmpFile);
-        } catch {
-          // Ignore cleanup errors
-        }
+        await removeSpawnPromptFile(capturedTmpFile);
       });
 
       return {
@@ -199,11 +189,7 @@ export class ClaudeCodeSpawnProvider implements AdapterSpawnProvider {
       console.error(`[ClaudeCodeSpawnProvider] Failed to spawn: ${getErrorMessage(error)}`);
 
       if (tmpFile) {
-        try {
-          await unlink(tmpFile);
-        } catch {
-          // Ignore cleanup errors
-        }
+        await removeSpawnPromptFile(tmpFile);
       }
 
       return {