@cleocode/adapters 2026.9.20 → 2026.9.22

package/src/__tests__/cli-spawn-win32.test.ts

@@ -0,0 +1,105 @@
+/**
+ * T12618 — provider CLIs are spawned through their resolved path on win32,
+ * with npm `.cmd` shims routed through cmd.exe. Node refuses to spawn a
+ * `.cmd` directly and its bare-name lookup never finds one, so before this
+ * every adapter spawn failed on Windows.
+ *
+ * Platform and PATH are injected; the real resolver runs with a stubbed
+ * filesystem predicate so the test is host-independent.
+ */
+
+import type { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const PRESENT = new Set(['C:\\npm\\claude.cmd', 'C:\\npm\\codex.cmd', 'C:\\bin\\pi.exe']);
+
+vi.mock('@cleocode/paths', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@cleocode/paths')>();
+  return {
+    ...actual,
+    resolveSpawnInvocation: (
+      command: string,
+      args: readonly string[],
+      opts: import('@cleocode/paths').ExecPathOptions = {},
+    ) =>
+      actual.resolveSpawnInvocation(command, args, {
+        ...opts,
+        isExecutable: (p) => PRESENT.has(p),
+      }),
+  };
+});
+vi.mock('node:child_process', { spy: true });
+
+import { spawn } from 'node:child_process';
+import {
+  _forceSystemdRunAvailable,
+  buildAgentSpawnArgs,
+} from '../providers/shared/agent-spawn-wrapper.js';
+import { spawnCli } from '../providers/shared/cli-spawn.js';
+
+const realPlatform = process.platform;
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, 'platform', { value, configurable: true });
+}
+
+beforeEach(() => {
+  vi.stubEnv('PATH', 'C:\\npm;C:\\bin');
+  vi.stubEnv('PATHEXT', '.COM;.EXE;.BAT;.CMD');
+  vi.stubEnv('ComSpec', 'C:\\Windows\\system32\\cmd.exe');
+  vi.mocked(spawn).mockReturnValue(new EventEmitter() as ChildProcess);
+});
+afterEach(() => {
+  setPlatform(realPlatform);
+  vi.unstubAllEnvs();
+  vi.mocked(spawn).mockReset();
+  _forceSystemdRunAvailable(false);
+});
+
+describe('buildAgentSpawnArgs on win32 (claude-code)', () => {
+  it('routes the claude.cmd shim through cmd.exe with verbatim quoting', () => {
+    setPlatform('win32');
+    _forceSystemdRunAvailable(false);
+    const built = buildAgentSpawnArgs('claude', ['--print', 'C:\\Temp\\p q.txt'], 'T1');
+    expect(built.command).toBe('C:\\Windows\\system32\\cmd.exe');
+    expect(built.windowsVerbatimArguments).toBe(true);
+    expect(built.args.slice(0, 3)).toEqual(['/d', '/s', '/c']);
+    expect(built.args[3]).toContain('C:\\npm\\claude.cmd');
+  });
+
+  it('POSIX keeps the sh/ulimit wrapper and never sets the verbatim flag', () => {
+    setPlatform('linux');
+    _forceSystemdRunAvailable(false);
+    const built = buildAgentSpawnArgs('claude', ['--print'], 'T1');
+    expect(built.command).toBe('sh');
+    expect(built.windowsVerbatimArguments).toBeUndefined();
+  });
+});
+
+describe('spawnCli (codex, gemini, opencode, pi)', () => {
+  it('.cmd on win32: spawns cmd.exe with windowsVerbatimArguments', () => {
+    setPlatform('win32');
+    spawnCli('codex', ['--full-auto', 'a & b'], { detached: true, stdio: 'ignore' });
+    const [file, args, opts] = vi.mocked(spawn).mock.calls[0] ?? [];
+    expect(file).toBe('C:\\Windows\\system32\\cmd.exe');
+    expect(args?.[3]).toContain('C:\\npm\\codex.cmd');
+    expect(args?.[3]).not.toMatch(/[^^]&/);
+    expect(opts).toMatchObject({ detached: true, windowsVerbatimArguments: true });
+  });
+
+  it('.exe on win32: spawns the absolute path directly', () => {
+    setPlatform('win32');
+    spawnCli('pi', ['prompt.txt'], { stdio: 'ignore' });
+    expect(vi.mocked(spawn).mock.calls[0]).toEqual([
+      'C:\\bin\\pi.exe',
+      ['prompt.txt'],
+      { stdio: 'ignore' },
+    ]);
+  });
+
+  it('POSIX: unchanged bare-name spawn', () => {
+    setPlatform('darwin');
+    spawnCli('codex', ['x'], { stdio: 'ignore' });
+    expect(vi.mocked(spawn).mock.calls[0]).toEqual(['codex', ['x'], { stdio: 'ignore' }]);
+  });
+});

package/src/__tests__/spawn-prompt-file.test.ts

@@ -0,0 +1,37 @@
+/**
+ * T12606 — spawn adapters write prompts under os.tmpdir(), never `/tmp`.
+ *
+ * The claude-code, codex and pi adapters wrote `/tmp/<provider>-spawn-<id>.txt`.
+ * Windows has no `/tmp`, so every spawn failed there; macOS ignored `$TMPDIR`.
+ */
+
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, relative } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { removeSpawnPromptFile, writeSpawnPromptFile } from '../providers/shared/prompt-file.js';
+
+describe('writeSpawnPromptFile (T12606)', () => {
+  it('writes under a fresh mkdtemp dir in os.tmpdir() and removes the dir', async () => {
+    const file = await writeSpawnPromptFile('claude-spawn', 'hello');
+    try {
+      expect(readFileSync(file, 'utf-8')).toBe('hello');
+      const rel = relative(realpathSync(tmpdir()), realpathSync(dirname(file)));
+      expect(rel.startsWith('cleo-claude-spawn-')).toBe(true);
+      // The dir's parent IS os.tmpdir() (not a hard-coded /tmp), whatever TMPDIR is.
+      expect(realpathSync(dirname(dirname(file)))).toBe(realpathSync(tmpdir()));
+    } finally {
+      await removeSpawnPromptFile(file);
+    }
+    expect(existsSync(dirname(file))).toBe(false);
+  });
+
+  it('gives concurrent spawns distinct directories', async () => {
+    const [a, b] = await Promise.all([
+      writeSpawnPromptFile('codex-spawn', 'a'),
+      writeSpawnPromptFile('codex-spawn', 'b'),
+    ]);
+    expect(dirname(a)).not.toBe(dirname(b));
+    await Promise.all([removeSpawnPromptFile(a), removeSpawnPromptFile(b)]);
+  });
+});

package/src/cant-context.ts

@@ -23,9 +23,9 @@
 
 import { execFile } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { promisify } from 'node:util';
+import { getCleoHome, getCleoPlatformPaths } from '@cleocode/paths';
 
 const execFileAsync = promisify(execFile);
 
@@ -175,10 +175,12 @@ export function discoverCantFiles(dir: string): string[] {
 }
 
 /**
- * Resolve XDG-compliant paths for the 3-tier CANT hierarchy.
+ * Resolve the platform paths for the 3-tier CANT hierarchy.
  *
- * Respects `XDG_DATA_HOME` and `XDG_CONFIG_HOME` environment variables.
- * Falls back to XDG defaults (`~/.local/share/` and `~/.config/`).
+ * The global tier lives under `getCleoHome()` and the user tier under the
+ * CLEO config dir, both from `@cleocode/paths` — on Linux that is
+ * `$XDG_DATA_HOME/cleo/cant` and `$XDG_CONFIG_HOME/cleo/cant`; on macOS
+ * `~/Library/Application Support/cleo/cant` and `~/Library/Preferences/cleo/cant`.
  *
  * @param projectDir - The project root directory (for the project tier).
  * @returns An object with `global`, `user`, and `project` CANT directory paths.
@@ -188,13 +190,9 @@ export function resolveThreeTierPaths(projectDir: string): {
   user: string;
   project: string;
 } {
-  const home = homedir();
-  const xdgData = process.env['XDG_DATA_HOME'] ?? join(home, '.local', 'share');
-  const xdgConfig = process.env['XDG_CONFIG_HOME'] ?? join(home, '.config');
-
   return {
-    global: join(xdgData, 'cleo', 'cant'),
-    user: join(xdgConfig, 'cleo', 'cant'),
+    global: join(getCleoHome(), 'cant'),
+    user: join(getCleoPlatformPaths().config, 'cant'),
     project: join(projectDir, '.cleo', 'cant'),
   };
 }
@@ -377,11 +375,11 @@ async function fetchMentalModelInjection(agentName: string, projectRoot: string)
 // ---------------------------------------------------------------------------
 
 /**
- * Read CLEOOS-IDENTITY.md from the project or global XDG location.
+ * Read CLEOOS-IDENTITY.md from the project or the global CLEO home.
  *
  * Search order:
  * 1. `<projectDir>/.cleo/CLEOOS-IDENTITY.md` (project-level, deployed by init)
- * 2. `$XDG_DATA_HOME/cleo/CLEOOS-IDENTITY.md` (global XDG default)
+ * 2. `<getCleoHome()>/CLEOOS-IDENTITY.md` (global)
  *
  * @param projectDir - The project root directory.
  * @returns The identity file content, or null if not found.
@@ -397,9 +395,7 @@ export function readIdentityFile(projectDir: string): string | null {
     }
   }
 
-  const home = homedir();
-  const xdgData = process.env['XDG_DATA_HOME'] ?? join(home, '.local', 'share');
-  const globalPath = join(xdgData, 'cleo', 'CLEOOS-IDENTITY.md');
+  const globalPath = join(getCleoHome(), 'CLEOOS-IDENTITY.md');
   if (existsSync(globalPath)) {
     try {
       const content = readFileSync(globalPath, 'utf-8');

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

@@ -7,17 +7,16 @@
  * @task T5240
  */
 
-import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import type {
   AdapterCapabilities,
   AdapterHealthStatus,
   AdapterSpawnProvider,
   CLEOProviderAdapter,
 } from '@cleocode/contracts';
+import { findOnPath } from '@cleocode/paths';
 import { ClaudeSDKSpawnProvider } from '../claude-sdk/spawn.js';
 import { ClaudeCodeContextMonitorProvider } from './context-monitor.js';
 import { ClaudeCodeHookProvider } from './hooks.js';
@@ -27,8 +26,6 @@ import { ClaudeCodeSpawnProvider } from './spawn.js';
 import { ClaudeCodeTaskSyncProvider } from './task-sync.js';
 import { ClaudeCodeTransportProvider } from './transport.js';
 
-const execAsync = promisify(exec);
-
 /**
  * CLEO provider adapter for Anthropic Claude Code CLI.
  *
@@ -202,13 +199,11 @@ export class ClaudeCodeAdapter implements CLEOProviderAdapter {
 
     // Check Claude CLI availability
     let cliAvailable = false;
-    try {
-      const { stdout } = await execAsync('which claude');
-      cliAvailable = stdout.trim().length > 0;
-      details.cliPath = stdout.trim();
-    } catch {
-      details.cliAvailable = false;
-    }
+    // In-process PATH/PATHEXT lookup: there is no `which` on Windows (T12604).
+    const resolvedCli = findOnPath('claude');
+    cliAvailable = resolvedCli !== null;
+    if (resolvedCli) details.cliPath = resolvedCli;
+    else details.cliAvailable = false;
 
     // Check for Claude Code config directory
     const claudeConfigDir = join(homedir(), '.claude');

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 {

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

@@ -56,7 +56,7 @@ export class ClaudeSDKSpawnProvider implements AdapterSpawnProvider {
    *
    * Uses 3-tier key resolution so the provider works with:
    * - `ANTHROPIC_API_KEY` environment variable (explicit)
-   * - `~/.local/share/cleo/anthropic-key` (user-stored via cleo config)
+   * - `<getCleoHome()>/anthropic-key` (user-stored via cleo config)
    * - Claude Code OAuth token (zero-config for Claude Code users)
    *
    * @returns `true` when any Anthropic credential is available

package/src/providers/codex/adapter.ts

@@ -8,21 +8,18 @@
  * @epic T134
  */
 
-import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import type {
   AdapterCapabilities,
   AdapterHealthStatus,
   CLEOProviderAdapter,
 } from '@cleocode/contracts';
+import { findOnPath } from '@cleocode/paths';
 import { CodexHookProvider } from './hooks.js';
 import { CodexInstallProvider } from './install.js';
 
-const execAsync = promisify(exec);
-
 /**
  * CLEO provider adapter for OpenAI Codex CLI.
  *
@@ -124,13 +121,11 @@ export class CodexAdapter implements CLEOProviderAdapter {
 
     // Check Codex CLI availability
     let cliAvailable = false;
-    try {
-      const { stdout } = await execAsync('which codex');
-      cliAvailable = stdout.trim().length > 0;
-      details.cliPath = stdout.trim();
-    } catch {
-      details.cliAvailable = false;
-    }
+    // In-process PATH/PATHEXT lookup: there is no `which` on Windows (T12604).
+    const resolvedCli = findOnPath('codex');
+    cliAvailable = resolvedCli !== null;
+    if (resolvedCli) details.cliPath = resolvedCli;
+    else details.cliAvailable = false;
 
     // Check for Codex CLI config directory
     const codexConfigDir = join(homedir(), '.codex');

package/src/providers/codex/spawn.ts

@@ -24,13 +24,12 @@
  * @task T648
  */
 
-import { exec, spawn as nodeSpawn } from 'node:child_process';
-import { unlink, writeFile } from 'node:fs/promises';
-import { promisify } from 'node:util';
+import type { SpawnOptions } from 'node:child_process';
 import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
 import { getErrorMessage } from '@cleocode/contracts';
-
-const execAsync = promisify(exec);
+import { findOnPath } from '@cleocode/paths';
+import { spawnCli } from '../shared/cli-spawn.js';
+import { removeSpawnPromptFile, writeSpawnPromptFile } from '../shared/prompt-file.js';
 
 /** Internal tracking entry for a spawned process. */
 interface TrackedProcess {
@@ -63,20 +62,16 @@ export class CodexSpawnProvider implements AdapterSpawnProvider {
   /**
    * Check if the Codex CLI is available in PATH.
    *
-   * @returns `true` if `codex` is found via `which`
+   * @returns `true` if `codex` is found on PATH (PATHEXT-aware on Windows)
    */
   async canSpawn(): Promise<boolean> {
-    try {
-      await execAsync('which codex');
-      return true;
-    } catch {
-      console.warn(
-        '[CodexSpawnProvider] codex CLI not found. ' +
-          'Install: npm install -g @openai/codex  ' +
-          'Docs: https://github.com/openai/codex',
-      );
-      return false;
-    }
+    if (findOnPath('codex') !== null) return true;
+    console.warn(
+      '[CodexSpawnProvider] codex CLI not found. ' +
+        'Install: npm install -g @openai/codex  ' +
+        'Docs: https://github.com/openai/codex',
+    );
+    return false;
   }
 
   /**
@@ -108,12 +103,11 @@ export class CodexSpawnProvider implements AdapterSpawnProvider {
         // CANT enrichment unavailable — use raw prompt
       }
 
-      tmpFile = `/tmp/codex-spawn-${instanceId}.txt`;
-      await writeFile(tmpFile, enrichedPrompt, 'utf-8');
+      tmpFile = await writeSpawnPromptFile('codex-spawn', enrichedPrompt);
 
       // --full-auto: non-interactive batch mode (auto-approve all actions)
       const args = ['--full-auto', tmpFile];
-      const spawnOpts: Parameters<typeof nodeSpawn>[2] = {
+      const spawnOpts: SpawnOptions = {
         detached: true,
         stdio: 'ignore',
       };
@@ -122,7 +116,7 @@ export class CodexSpawnProvider implements AdapterSpawnProvider {
         spawnOpts.cwd = context.workingDirectory;
       }
 
-      const child = nodeSpawn('codex', args, spawnOpts);
+      const child = spawnCli('codex', args, spawnOpts);
       child.unref();
 
       if (child.pid) {
@@ -136,11 +130,7 @@ export class CodexSpawnProvider 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 {
@@ -154,11 +144,7 @@ export class CodexSpawnProvider implements AdapterSpawnProvider {
       console.error(`[CodexSpawnProvider] Failed to spawn: ${getErrorMessage(error)}`);
 
       if (tmpFile) {
-        try {
-          await unlink(tmpFile);
-        } catch {
-          // Ignore cleanup errors
-        }
+        await removeSpawnPromptFile(tmpFile);
       }
 
       return {

package/src/providers/gemini-cli/adapter.ts

@@ -8,21 +8,18 @@
  * @epic T134
  */
 
-import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import type {
   AdapterCapabilities,
   AdapterHealthStatus,
   CLEOProviderAdapter,
 } from '@cleocode/contracts';
+import { findOnPath } from '@cleocode/paths';
 import { GeminiCliHookProvider } from './hooks.js';
 import { GeminiCliInstallProvider } from './install.js';
 
-const execAsync = promisify(exec);
-
 /**
  * CLEO provider adapter for Google Gemini CLI.
  *
@@ -136,13 +133,11 @@ export class GeminiCliAdapter implements CLEOProviderAdapter {
 
     // Check Gemini CLI availability
     let cliAvailable = false;
-    try {
-      const { stdout } = await execAsync('which gemini');
-      cliAvailable = stdout.trim().length > 0;
-      details.cliPath = stdout.trim();
-    } catch {
-      details.cliAvailable = false;
-    }
+    // In-process PATH/PATHEXT lookup: there is no `which` on Windows (T12604).
+    const resolvedCli = findOnPath('gemini');
+    cliAvailable = resolvedCli !== null;
+    if (resolvedCli) details.cliPath = resolvedCli;
+    else details.cliAvailable = false;
 
     // Check for Gemini CLI config directory
     const geminiConfigDir = join(homedir(), '.gemini');

package/src/providers/gemini-cli/spawn.ts

@@ -25,12 +25,11 @@
  * @task T648
  */
 
-import { exec, spawn as nodeSpawn } from 'node:child_process';
-import { promisify } from 'node:util';
+import type { SpawnOptions } from 'node:child_process';
 import type { AdapterSpawnProvider, SpawnContext, SpawnResult } from '@cleocode/contracts';
 import { getErrorMessage } from '@cleocode/contracts';
-
-const execAsync = promisify(exec);
+import { findOnPath } from '@cleocode/paths';
+import { spawnCli } from '../shared/cli-spawn.js';
 
 /** Default Gemini model for subagent spawns. */
 const DEFAULT_MODEL = 'gemini-2.5-pro';
@@ -66,20 +65,16 @@ export class GeminiCliSpawnProvider implements AdapterSpawnProvider {
   /**
    * Check if the Gemini CLI is available in PATH.
    *
-   * @returns `true` if `gemini` is found via `which`
+   * @returns `true` if `gemini` is found on PATH (PATHEXT-aware on Windows)
    */
   async canSpawn(): Promise<boolean> {
-    try {
-      await execAsync('which gemini');
-      return true;
-    } catch {
-      console.warn(
-        '[GeminiCliSpawnProvider] gemini CLI not found. ' +
-          'Install: npm install -g @google/gemini-cli  ' +
-          'Docs: https://github.com/google-gemini/gemini-cli',
-      );
-      return false;
-    }
+    if (findOnPath('gemini') !== null) return true;
+    console.warn(
+      '[GeminiCliSpawnProvider] gemini CLI not found. ' +
+        'Install: npm install -g @google/gemini-cli  ' +
+        'Docs: https://github.com/google-gemini/gemini-cli',
+    );
+    return false;
   }
 
   /**
@@ -116,7 +111,7 @@ export class GeminiCliSpawnProvider implements AdapterSpawnProvider {
       // --model: select the Gemini model variant
       // Prompt is supplied via stdin (pipe)
       const args = ['--yolo', '--model', model];
-      const spawnOpts: Parameters<typeof nodeSpawn>[2] = {
+      const spawnOpts: SpawnOptions = {
         detached: true,
         stdio: ['pipe', 'ignore', 'ignore'],
       };
@@ -125,7 +120,7 @@ export class GeminiCliSpawnProvider implements AdapterSpawnProvider {
         spawnOpts.cwd = context.workingDirectory;
       }
 
-      const child = nodeSpawn('gemini', args, spawnOpts);
+      const child = spawnCli('gemini', args, spawnOpts);
 
       // Write the prompt to stdin then close so the CLI receives it.
       if (child.stdin) {

package/src/providers/kimi/adapter.ts

@@ -9,21 +9,18 @@
  * @epic T134
  */
 
-import { exec } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import type {
   AdapterCapabilities,
   AdapterHealthStatus,
   CLEOProviderAdapter,
 } from '@cleocode/contracts';
+import { findOnPath } from '@cleocode/paths';
 import { KimiHookProvider } from './hooks.js';
 import { KimiInstallProvider } from './install.js';
 
-const execAsync = promisify(exec);
-
 /**
  * CLEO provider adapter for Moonshot AI Kimi.
  *
@@ -123,13 +120,11 @@ export class KimiAdapter implements CLEOProviderAdapter {
 
     // Check Kimi CLI availability
     let cliAvailable = false;
-    try {
-      const { stdout } = await execAsync('which kimi');
-      cliAvailable = stdout.trim().length > 0;
-      details.cliPath = stdout.trim();
-    } catch {
-      details.cliAvailable = false;
-    }
+    // In-process PATH/PATHEXT lookup: there is no `which` on Windows (T12604).
+    const resolvedCli = findOnPath('kimi');
+    cliAvailable = resolvedCli !== null;
+    if (resolvedCli) details.cliPath = resolvedCli;
+    else details.cliAvailable = false;
 
     // Check for Kimi config directory
     const kimiConfigDir = join(homedir(), '.kimi');