@cleocode/adapters 2026.9.19 → 2026.9.21

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/cursor/__tests__/adapter.test.ts

@@ -45,6 +45,13 @@ vi.mock('@cleocode/caamp', () => ({
     action: 'added',
     providerId: 'cursor',
   }),
+  // T12385: Cursor's rule files and hooks.json go through the CAAMP writers.
+  ensureProviderRuleFile: vi.fn().mockResolvedValue({
+    filePath: '/tmp/test-project/.cursor/rules/cleo.mdc',
+    action: 'created',
+    providerId: 'cursor',
+  }),
+  updateJsonConfigFile: vi.fn().mockResolvedValue(true),
 }));
 
 describe('CursorAdapter', () => {

package/src/providers/cursor/__tests__/hooks-install.test.ts

@@ -95,4 +95,40 @@ describe('CursorInstallProvider — PreCompact hook templates', () => {
     };
     expect((config.hooks?.preCompact ?? []).length).toBe(1);
   });
+
+  it('T12385: reports a malformed hooks.json and leaves it byte-identical', async () => {
+    const hooksJsonPath = join(projectDir, '.cursor', 'hooks.json');
+    mkdirSync(join(projectDir, '.cursor'), { recursive: true });
+    const malformed = '{ "hooks": { "preCompact": [ ';
+    writeFileSync(hooksJsonPath, malformed, 'utf-8');
+
+    const result = await new CursorInstallProvider().install({ projectDir });
+
+    expect(readFileSync(hooksJsonPath, 'utf-8')).toBe(malformed);
+    expect(result.success).toBe(false);
+    expect(String(result.details?.hooksError)).toMatch(/not a valid JSON object/);
+  });
+
+  it('T12385: writes rule files through the CAAMP writer (managed block, registry references)', async () => {
+    const legacyPath = join(projectDir, '.cursorrules');
+    // A pre-CAAMP .cursorrules with the old bare reference lines appended.
+    writeFileSync(
+      legacyPath,
+      '# Project Rules\nUse TypeScript.\n@~/.cleo/templates/CLEO-INJECTION.md\n@.cleo/memory-bridge.md\n',
+      'utf-8',
+    );
+
+    await new CursorInstallProvider().install({ projectDir });
+
+    const legacy = readFileSync(legacyPath, 'utf-8');
+    expect(legacy).toContain('# Project Rules\nUse TypeScript.');
+    expect(legacy).toContain('<!-- CAAMP:START -->');
+    expect(legacy.match(/CLEO-INJECTION\.md/g)).toHaveLength(1);
+
+    const mdc = readFileSync(join(projectDir, '.cursor', 'rules', 'cleo.mdc'), 'utf-8');
+    expect(mdc.startsWith('---\n')).toBe(true);
+    expect(mdc).toContain('alwaysApply: true');
+    expect(mdc).toContain('<!-- CAAMP:START -->');
+    expect(mdc).toContain('@.cleo/memory-bridge.md');
+  });
 });

package/src/providers/cursor/install.ts

@@ -16,9 +16,14 @@
  * @task T1013
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { ensureProviderInstructionFile } from '@cleocode/caamp';
+import {
+  type EnsureProviderRuleFileResult,
+  ensureProviderInstructionFile,
+  ensureProviderRuleFile,
+  updateJsonConfigFile,
+} from '@cleocode/caamp';
 import type { AdapterInstallProvider, InstallOptions, InstallResult } from '@cleocode/contracts';
 import {
   type InstallHookTemplatesResult,
@@ -26,6 +31,21 @@ import {
 } from '../shared/hook-template-installer.js';
 import { getCleoTemplatesTildePath } from '../shared/paths.js';
 
+/** MDC frontmatter for the CLEO-owned `.cursor/rules/cleo.mdc` rule file. */
+const CLEO_MDC_FRONTMATTER = [
+  '---',
+  'description: CLEO task management protocol references',
+  'globs: "**/*"',
+  'alwaysApply: true',
+  '---',
+  '',
+].join('\n');
+
+/** Whether a parsed JSON value is a plain object. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 /**
  * Install provider for Cursor.
  *
@@ -57,7 +77,7 @@ export class CursorInstallProvider implements AdapterInstallProvider {
     // ensureProviderInstructionFile handles the primary AGENTS.md (registry instructFile);
     // updateInstructionFiles also manages cursor-specific MDC + legacy .cursorrules formats.
     const instructionResult = await ensureProviderInstructionFile('cursor', projectDir, {});
-    const cursorFilesUpdated = this.updateInstructionFiles(projectDir);
+    const cursorFilesUpdated = await this.updateInstructionFiles(projectDir);
     instructionFileUpdated = instructionResult.action !== 'intact' || cursorFilesUpdated;
     if (instructionFileUpdated) {
       details.instructionFiles = this.getUpdatedFileList(projectDir);
@@ -65,13 +85,21 @@ export class CursorInstallProvider implements AdapterInstallProvider {
 
     // Step 2 (T1013): Install PreCompact hook templates + wire the handler
     // command into .cursor/hooks.json's `preCompact` event.
-    const hookResult = this.installHookTemplates(projectDir);
-    if (hookResult) {
-      details.hookTemplates = hookResult;
+    // T12385: a malformed hooks.json aborts the write and is reported; it is
+    // never reset to `{}`.
+    let hooksError: string | null = null;
+    try {
+      const hookResult = await this.installHookTemplates(projectDir);
+      if (hookResult) {
+        details.hookTemplates = hookResult;
+      }
+    } catch (err) {
+      hooksError = err instanceof Error ? err.message : String(err);
+      details.hooksError = hooksError;
     }
 
     return {
-      success: true,
+      success: hooksError === null,
       installedAt,
       instructionFileUpdated,
       details,
@@ -127,102 +155,37 @@ export class CursorInstallProvider implements AdapterInstallProvider {
    */
   async ensureInstructionReferences(projectDir: string): Promise<void> {
     await ensureProviderInstructionFile('cursor', projectDir, {});
-    this.updateInstructionFiles(projectDir);
+    await this.updateInstructionFiles(projectDir);
   }
 
   /**
-   * Update instruction files with CLEO @-references.
-   *
-   * Handles both legacy (.cursorrules) and modern (.cursor/rules/cleo.mdc) formats.
+   * Update Cursor's auxiliary rule files through the CAAMP writer.
    *
-   * @returns true if any file was created or modified
-   */
-  private updateInstructionFiles(projectDir: string): boolean {
-    let updated = false;
-
-    // Update legacy .cursorrules if it exists
-    if (this.updateLegacyRules(projectDir)) {
-      updated = true;
-    }
-
-    // Create/update modern .cursor/rules/cleo.mdc
-    if (this.updateModernRules(projectDir)) {
-      updated = true;
-    }
-
-    return updated;
-  }
-
-  /**
-   * Update legacy .cursorrules file with @-references.
-   *
-   * References are sourced from the CAAMP provider registry (T1919) rather than
-   * a local constant, keeping this adapter in sync with the single source of truth.
-   * Only modifies the file if it already exists (does not create it).
-   *
-   * @returns true if the file was modified
-   */
-  private updateLegacyRules(projectDir: string): boolean {
-    const rulesPath = join(projectDir, '.cursorrules');
-    if (!existsSync(rulesPath)) {
-      return false;
-    }
-
-    let content = readFileSync(rulesPath, 'utf-8');
-    const cursorRefs = [
-      `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`,
-      '@.cleo/memory-bridge.md',
-    ];
-    const missingRefs = cursorRefs.filter((ref) => !content.includes(ref));
-
-    if (missingRefs.length === 0) {
-      return false;
-    }
-
-    const separator = content.endsWith('\n') ? '' : '\n';
-    content = content + separator + missingRefs.join('\n') + '\n';
-    writeFileSync(rulesPath, content, 'utf-8');
-    return true;
-  }
-
-  /**
-   * Create or update .cursor/rules/cleo.mdc with CLEO references.
+   * @remarks
+   * ADR-064 / T12385: both files are written by CAAMP's
+   * `ensureProviderRuleFile` — locked, atomic, with references taken from the
+   * provider registry — instead of raw `writeFileSync` with a local copy of
+   * the references.
    *
-   * MDC (Markdown Component) format is Cursor's modern rule file format.
-   * Each .mdc file in .cursor/rules/ is loaded as a rule set.
-   * References are sourced from the CAAMP provider registry (T1919).
+   * - Legacy `.cursorrules` is only updated when it already exists; CLEO's
+   *   references live in a CAAMP block and user text is preserved.
+   * - Modern `.cursor/rules/cleo.mdc` is CLEO-owned: MDC frontmatter followed
+   *   by the CAAMP block.
    *
-   * @returns true if the file was created or modified
+   * @returns true if any file was created or modified
    */
-  private updateModernRules(projectDir: string): boolean {
-    const rulesDir = join(projectDir, '.cursor', 'rules');
-    const mdcPath = join(rulesDir, 'cleo.mdc');
-
-    const cursorRefs = [
-      `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`,
-      '@.cleo/memory-bridge.md',
+  private async updateInstructionFiles(projectDir: string): Promise<boolean> {
+    const results: Array<EnsureProviderRuleFileResult | null> = [
+      await ensureProviderRuleFile('cursor', projectDir, {
+        relativePath: '.cursorrules',
+        onlyIfExists: true,
+      }),
+      await ensureProviderRuleFile('cursor', projectDir, {
+        relativePath: join('.cursor', 'rules', 'cleo.mdc'),
+        preamble: CLEO_MDC_FRONTMATTER,
+      }),
     ];
-    const expectedContent = [
-      '---',
-      'description: CLEO task management protocol references',
-      'globs: "**/*"',
-      'alwaysApply: true',
-      '---',
-      '',
-      ...cursorRefs,
-      '',
-    ].join('\n');
-
-    if (existsSync(mdcPath)) {
-      const existing = readFileSync(mdcPath, 'utf-8');
-      if (existing === expectedContent) {
-        return false;
-      }
-    }
-
-    mkdirSync(rulesDir, { recursive: true });
-    writeFileSync(mdcPath, expectedContent, 'utf-8');
-    return true;
+    return results.some((r) => r !== null && r.action !== 'intact');
   }
 
   /**
@@ -255,10 +218,10 @@ export class CursorInstallProvider implements AdapterInstallProvider {
    *
    * @task T1013
    */
-  private installHookTemplates(projectDir: string): {
+  private async installHookTemplates(projectDir: string): Promise<{
     templates: InstallHookTemplatesResult;
     hooksJsonEntryAdded: boolean;
-  } | null {
+  } | null> {
     const hooksDir = join(projectDir, '.cursor', 'hooks');
 
     // Template copy is best-effort so missing/locked filesystems (CI sandboxes,
@@ -273,7 +236,7 @@ export class CursorInstallProvider implements AdapterInstallProvider {
       return null;
     }
 
-    const hooksJsonEntryAdded = this.registerPreCompactHook(
+    const hooksJsonEntryAdded = await this.registerPreCompactHook(
       projectDir,
       join(hooksDir, 'precompact.sh'),
     );
@@ -298,45 +261,35 @@ export class CursorInstallProvider implements AdapterInstallProvider {
    *
    * @task T1013
    */
-  private registerPreCompactHook(projectDir: string, shimPath: string): boolean {
+  private async registerPreCompactHook(projectDir: string, shimPath: string): Promise<boolean> {
     const hooksJsonPath = join(projectDir, '.cursor', 'hooks.json');
-
-    let config: Record<string, unknown> = {};
-    if (existsSync(hooksJsonPath)) {
-      try {
-        config = JSON.parse(readFileSync(hooksJsonPath, 'utf-8'));
-      } catch {
-        // Start fresh on corrupt config.
+    return updateJsonConfigFile(hooksJsonPath, (config) => {
+      const hooks = config.hooks ?? {};
+      if (!isRecord(hooks)) {
+        throw new Error('.cursor/hooks.json "hooks" is not an object; not modifying it');
+      }
+      const entries = hooks.preCompact ?? [];
+      if (!Array.isArray(entries)) {
+        throw new Error('.cursor/hooks.json "hooks.preCompact" is not an array; not modifying it');
       }
-    }
-
-    const hooks = (config.hooks as Record<string, unknown[]> | undefined) ?? {};
-    const entries = (hooks.preCompact as unknown[] | undefined) ?? [];
-
-    const alreadyWired = entries.some(
-      (entry) =>
-        typeof entry === 'object' &&
-        entry !== null &&
-        typeof (entry as Record<string, unknown>).command === 'string' &&
-        ((entry as Record<string, unknown>).command as string).includes('# cleo-hook') &&
-        ((entry as Record<string, unknown>).command as string).includes('precompact.sh'),
-    );
 
-    if (alreadyWired) {
-      return false;
-    }
+      const alreadyWired = entries.some(
+        (entry) =>
+          isRecord(entry) &&
+          typeof entry.command === 'string' &&
+          entry.command.includes('# cleo-hook') &&
+          entry.command.includes('precompact.sh'),
+      );
+      if (alreadyWired) {
+        return false;
+      }
 
-    entries.push({
-      type: 'command',
-      command: `"${shimPath}" # cleo-hook`,
-      timeout: 30,
+      hooks.preCompact = [
+        ...entries,
+        { type: 'command', command: `"${shimPath}" # cleo-hook`, timeout: 30 },
+      ];
+      config.hooks = hooks;
+      return true;
     });
-
-    hooks.preCompact = entries;
-    config.hooks = hooks;
-
-    mkdirSync(join(projectDir, '.cursor'), { recursive: true });
-    writeFileSync(hooksJsonPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-    return true;
   }
 }

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');