@cleocode/adapters 2026.9.19 → 2026.9.21

package/src/__tests__/cant-context.test.ts

@@ -3,7 +3,7 @@
  *
  * Tests cover:
  * - discoverCantFiles: finds .cant files, handles missing dirs
- * - resolveThreeTierPaths: XDG-compliant paths with env var overrides
+ * - resolveThreeTierPaths: tiers resolve through @cleocode/paths on every platform
  * - discoverCantFilesMultiTier: 3-tier merge with override semantics
  * - readMemoryBridge: reads file, handles missing/empty
  * - buildMemoryBridgeBlock: wraps content in labeled section
@@ -14,9 +14,10 @@
  */
 
 import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getCleoHome } from '@cleocode/paths';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
   buildCantEnrichedPrompt,
@@ -24,6 +25,7 @@ import {
   buildMentalModelInjection,
   discoverCantFiles,
   discoverCantFilesMultiTier,
+  readIdentityFile,
   readMemoryBridge,
   resolveThreeTierPaths,
 } from '../cant-context.js';
@@ -68,33 +70,81 @@ describe('discoverCantFiles', () => {
 // ---------------------------------------------------------------------------
 
 describe('resolveThreeTierPaths', () => {
+  const PLATFORM = Object.getOwnPropertyDescriptor(process, 'platform');
+
+  function stubPlatform(platform: NodeJS.Platform): void {
+    Object.defineProperty(process, 'platform', { value: platform, configurable: true });
+  }
+
+  beforeEach(() => {
+    vi.stubEnv('CLEO_HOME', undefined);
+    vi.stubEnv('CLEO_CONFIG_HOME', undefined);
+  });
+
+  afterEach(() => {
+    if (PLATFORM) Object.defineProperty(process, 'platform', PLATFORM);
+    vi.unstubAllEnvs();
+  });
+
   it('returns project tier pointing to .cleo/cant/', () => {
     const paths = resolveThreeTierPaths('/my/project');
     expect(paths.project).toBe(join('/my/project', '.cleo', 'cant'));
   });
 
-  it('respects XDG_DATA_HOME for global tier', () => {
-    const originalXdg = process.env['XDG_DATA_HOME'];
-    process.env['XDG_DATA_HOME'] = '/custom/data';
-    try {
-      const paths = resolveThreeTierPaths('/my/project');
-      expect(paths.global).toBe(join('/custom/data', 'cleo', 'cant'));
-    } finally {
-      if (originalXdg) process.env['XDG_DATA_HOME'] = originalXdg;
-      else delete process.env['XDG_DATA_HOME'];
-    }
-  });
-
-  it('respects XDG_CONFIG_HOME for user tier', () => {
-    const originalXdg = process.env['XDG_CONFIG_HOME'];
-    process.env['XDG_CONFIG_HOME'] = '/custom/config';
-    try {
-      const paths = resolveThreeTierPaths('/my/project');
-      expect(paths.user).toBe(join('/custom/config', 'cleo', 'cant'));
-    } finally {
-      if (originalXdg) process.env['XDG_CONFIG_HOME'] = originalXdg;
-      else delete process.env['XDG_CONFIG_HOME'];
-    }
+  it('global tier is <getCleoHome()>/cant and user tier is <CLEO config>/cant', () => {
+    vi.stubEnv('CLEO_HOME', '/opt/cleo-data');
+    vi.stubEnv('CLEO_CONFIG_HOME', '/opt/cleo-config');
+    const paths = resolveThreeTierPaths('/my/project');
+    expect(paths.global).toBe(join('/opt/cleo-data', 'cant'));
+    expect(paths.user).toBe(join('/opt/cleo-config', 'cant'));
+  });
+
+  it('macOS: global and user tiers are under ~/Library, not the XDG dirs (T12602)', () => {
+    stubPlatform('darwin');
+    vi.stubEnv('XDG_DATA_HOME', '/custom/data');
+    vi.stubEnv('XDG_CONFIG_HOME', '/custom/config');
+    const paths = resolveThreeTierPaths('/my/project');
+    expect(paths.global).toBe(join(getCleoHome(), 'cant'));
+    expect(paths.global).toBe(join(homedir(), 'Library', 'Application Support', 'cleo', 'cant'));
+    expect(paths.user).toBe(join(homedir(), 'Library', 'Preferences', 'cleo', 'cant'));
+  });
+
+  it('Windows: global tier is under %LOCALAPPDATA% (T12602)', () => {
+    stubPlatform('win32');
+    vi.stubEnv('LOCALAPPDATA', 'C:\\Users\\me\\AppData\\Local');
+    vi.stubEnv('XDG_DATA_HOME', '/custom/data');
+    const paths = resolveThreeTierPaths('/my/project');
+    expect(paths.global).toBe(join(getCleoHome(), 'cant'));
+    expect(paths.global.startsWith('C:\\Users\\me\\AppData\\Local')).toBe(true);
+  });
+
+  it('Linux: honours XDG_DATA_HOME and XDG_CONFIG_HOME', () => {
+    stubPlatform('linux');
+    vi.stubEnv('XDG_DATA_HOME', '/custom/data');
+    vi.stubEnv('XDG_CONFIG_HOME', '/custom/config');
+    const paths = resolveThreeTierPaths('/my/project');
+    expect(paths.global).toBe(join('/custom/data', 'cleo', 'cant'));
+    expect(paths.user).toBe(join('/custom/config', 'cleo', 'cant'));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// readIdentityFile — global tier (T12602)
+// ---------------------------------------------------------------------------
+
+describe('readIdentityFile', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('reads the global CLEOOS-IDENTITY.md from getCleoHome(), not $XDG_DATA_HOME/cleo', () => {
+    const cleoHome = join(tempDir, 'cleo-home');
+    mkdirSync(cleoHome, { recursive: true });
+    writeFileSync(join(cleoHome, 'CLEOOS-IDENTITY.md'), 'global identity');
+    vi.stubEnv('CLEO_HOME', cleoHome);
+    vi.stubEnv('XDG_DATA_HOME', join(tempDir, 'empty-xdg'));
+
+    expect(readIdentityFile(join(tempDir, 'project'))).toBe('global identity');
   });
 });
 
@@ -103,22 +153,24 @@ describe('resolveThreeTierPaths', () => {
 // ---------------------------------------------------------------------------
 
 describe('discoverCantFilesMultiTier', () => {
-  let origXdgData: string | undefined;
-  let origXdgConfig: string | undefined;
-
   beforeEach(() => {
-    // Override XDG paths so global/user tiers point to empty temp subdirs
-    origXdgData = process.env['XDG_DATA_HOME'];
-    origXdgConfig = process.env['XDG_CONFIG_HOME'];
-    process.env['XDG_DATA_HOME'] = join(tempDir, 'xdg-data');
-    process.env['XDG_CONFIG_HOME'] = join(tempDir, 'xdg-config');
+    // Point the global/user tiers at empty temp subdirs on every platform.
+    vi.stubEnv('CLEO_HOME', join(tempDir, 'cleo-home'));
+    vi.stubEnv('CLEO_CONFIG_HOME', join(tempDir, 'cleo-config'));
   });
 
   afterEach(() => {
-    if (origXdgData) process.env['XDG_DATA_HOME'] = origXdgData;
-    else delete process.env['XDG_DATA_HOME'];
-    if (origXdgConfig) process.env['XDG_CONFIG_HOME'] = origXdgConfig;
-    else delete process.env['XDG_CONFIG_HOME'];
+    vi.unstubAllEnvs();
+  });
+
+  it('discovers files from the global tier under getCleoHome() (T12602)', () => {
+    const globalCant = join(tempDir, 'cleo-home', 'cant');
+    mkdirSync(globalCant, { recursive: true });
+    writeFileSync(join(globalCant, 'global.cant'), 'team: global');
+
+    const result = discoverCantFilesMultiTier(tempDir);
+    expect(result.stats.global).toBe(1);
+    expect(result.files).toEqual([join(globalCant, 'global.cant')]);
   });
 
   it('discovers files from project tier', () => {

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

@@ -62,6 +62,7 @@ vi.mock('@cleocode/caamp', () => ({
     action: 'added',
     providerId: 'claude-code',
   }),
+  updateJsonConfigFile: vi.fn().mockResolvedValue(false),
 }));
 
 describe('ClaudeCodeAdapter', () => {

package/src/providers/claude-code/__tests__/hooks-install.test.ts

@@ -17,10 +17,11 @@
  * @epic T1000
  */
 
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ClaudeCodeHookProvider } from '../hooks.js';
 import { ClaudeCodeInstallProvider } from '../install.js';
 
 describe('ClaudeCodeInstallProvider — PreCompact hook templates', () => {
@@ -129,4 +130,64 @@ describe('ClaudeCodeInstallProvider — PreCompact hook templates', () => {
     };
     expect((settings.hooks?.PreCompact ?? []).length).toBe(1);
   });
+
+  // T12385 — a malformed settings.json used to be replaced with an object
+  // holding only CLEO's entries (the parse error was caught and the writer
+  // "started fresh"). It must now be reported and left byte-identical.
+  describe('T12385 — malformed settings.json is never rewritten', () => {
+    const malformed = '{\n  "permissions": { "allow": ["Bash(ls)"] },\n  "model": "opus",\n';
+
+    it('install reports the parse error and leaves the file byte-identical', async () => {
+      const settingsPath = join(fakeHome, '.claude', 'settings.json');
+      mkdirSync(join(fakeHome, '.claude'), { recursive: true });
+      writeFileSync(settingsPath, malformed, 'utf-8');
+
+      const result = await new ClaudeCodeInstallProvider().install({ projectDir });
+
+      expect(readFileSync(settingsPath, 'utf-8')).toBe(malformed);
+      expect(result.success).toBe(false);
+      const errors = (result.details?.settingsErrors ?? []) as string[];
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0]).toMatch(/not a valid JSON object/);
+      expect(existsSync(`${settingsPath}.lock`)).toBe(false);
+    });
+
+    it('hook registration reports the parse error and leaves the file byte-identical', async () => {
+      const settingsPath = join(fakeHome, '.claude', 'settings.json');
+      mkdirSync(join(fakeHome, '.claude'), { recursive: true });
+      writeFileSync(settingsPath, malformed, 'utf-8');
+      const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+      const hooks = new ClaudeCodeHookProvider();
+      await hooks.registerNativeHooks(projectDir);
+      await hooks.unregisterNativeHooks();
+
+      stderr.mockRestore();
+      expect(readFileSync(settingsPath, 'utf-8')).toBe(malformed);
+      expect(hooks.getSettingsError()).toMatch(/not a valid JSON object/);
+    });
+
+    it('preserves unrelated user settings when it does write', async () => {
+      const settingsPath = join(fakeHome, '.claude', 'settings.json');
+      mkdirSync(join(fakeHome, '.claude'), { recursive: true });
+      writeFileSync(
+        settingsPath,
+        JSON.stringify({ model: 'opus', hooks: { Stop: [{ matcher: 'x', hooks: [] }] } }),
+        'utf-8',
+      );
+
+      await new ClaudeCodeHookProvider().registerNativeHooks(projectDir);
+      await new ClaudeCodeInstallProvider().install({ projectDir });
+
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf-8')) as {
+        model?: string;
+        enabledPlugins?: Record<string, boolean>;
+        hooks?: Record<string, unknown[]>;
+      };
+      expect(settings.model).toBe('opus');
+      expect(settings.enabledPlugins?.['cleo@cleocode']).toBe(true);
+      expect(settings.hooks?.Stop).toHaveLength(2);
+      expect(settings.hooks?.PreCompact).toHaveLength(1);
+    });
+  });
 });

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