@myclaw163/clawclaw-cli 0.6.66 → 0.6.67

package/src/strategies/loader.test.ts

@@ -1,678 +1,678 @@
-import { describe, it, expect, vi, beforeEach, beforeAll, afterAll } from 'vitest';
-import type * as FsType from 'fs';
-import { join } from 'path';
-
-vi.mock('fs');
-vi.mock('../lib/init-command.js', () => ({
-  getWorkspaceDir: () => process.env.CLAWCLAW_WORKSPACE_DIR ?? '/default/ws',
-}));
-
-import { existsSync, readdirSync, readFileSync, realpathSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
-
-let realFs: typeof FsType;
-let tmpDir: string;
-let stratDir: string;
-
-const VALID_SRC = `
-export const strategy = {
-  id: 'test-strat',
-  description: 'A test strategy',
-  create: (args) => ({ name: 'test-strat', decide: () => [] }),
-};
-`;
-
-const INVALID_SRC = `
-export const strategy = {
-  name: 'not-a-strategy',
-  description: 'Missing id field',
-};
-`;
-
-const ERROR_SRC = `
-export const strategy = {
-  id: 'error-strat',
-  description: 'Always throws on create',
-  create: (args) => { throw new Error('create failed: ' + (args ? args.join(',') : 'no-args')); },
-};
-`;
-
-const VALID_SRC_V2 = `
-export const strategy = {
-  id: 'test-strat',
-  description: 'Updated description',
-  create: (args) => ({ name: 'test-strat-v2', decide: () => [] }),
-};
-`;
-
-const VALID_JS_SRC = `
-export const strategy = {
-  id: 'js-strat',
-  description: 'A JS strategy',
-  create: (args) => ({ name: 'js-strat', decide: () => [] }),
-};
-`;
-
-beforeAll(async () => {
-  realFs = await vi.importActual<typeof import('fs')>('fs');
-  tmpDir = realFs.mkdtempSync(join('/tmp', 'strat-test-'));
-  stratDir = join(tmpDir, 'strategies');
-  realFs.mkdirSync(stratDir, { recursive: true });
-});
-
-afterAll(() => {
-  if (tmpDir) realFs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-beforeEach(() => {
-  // Clean strategy dir to avoid test pollution
-  for (const f of realFs.readdirSync(stratDir)) {
-    realFs.rmSync(join(stratDir, f));
-  }
-  process.env.CLAWCLAW_WORKSPACE_DIR = tmpDir;
-  vi.resetModules();
-  vi.mocked(existsSync).mockImplementation(((p: any) => {
-    if (p === '/fake/ws') return true;
-    if (p === '/fake/ws/strategies') return true;
-    return realFs.existsSync(p);
-  }) as any);
-  vi.mocked(readdirSync).mockImplementation(((p: any) => {
-    if (p.endsWith('src/strategies') || p.endsWith('src\\strategies')) return [];
-    return realFs.readdirSync(p);
-  }) as any);
-  vi.mocked(readFileSync).mockImplementation(((p: any, enc?: any) => {
-    if (enc === 'utf8') return realFs.readFileSync(p, 'utf8');
-    return realFs.readFileSync(p);
-  }) as any);
-  vi.mocked(realpathSync).mockImplementation(((p: any) => realFs.realpathSync(p)) as any);
-  vi.mocked(mkdtempSync).mockImplementation(((p: any) => realFs.mkdtempSync(p)) as any);
-  vi.mocked(writeFileSync).mockImplementation(((...args: any[]) => (realFs.writeFileSync as any)(...args)) as any);
-  vi.mocked(rmSync).mockImplementation(((...args: any[]) => (realFs.rmSync as any)(...args)) as any);
-});
-
-function writeStratFile(name: string, src: string) {
-  realFs.writeFileSync(join(stratDir, name), src);
-}
-
-describe('strategy loader', () => {
-  describe('user strategies dir resolution', () => {
-    it('returns no user strategies when workspace does not exist', async () => {
-      vi.mocked(existsSync).mockReturnValue(false);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-    });
-
-    it('returns no user strategies when strategies dir does not exist', async () => {
-      vi.mocked(existsSync).mockImplementation(((p: any) => {
-        if (p === '/fake/ws') return true;
-        return false;
-      }) as any);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-    });
-
-    it('loads user strategies from <workspace>/strategies', async () => {
-      writeStratFile('my-strat.ts', VALID_SRC);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('test-strat');
-    });
-
-    it('rewrites clawclaw-cli imports during loading', async () => {
-      const srcWithImport = `
-import { Action } from 'clawclaw-cli';
-export const strategy = {
-  id: 'import-test',
-  description: 'test import rewrite',
-  create: () => ({
-    name: 'import-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('with-import.ts', srcWithImport);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('import-test');
-    });
-
-    it('silently supports dynamic import() of clawclaw-cli', async () => {
-      const srcWithDynamicImport = `
-export const strategy = {
-  id: 'dynamic-test',
-  description: 'test dynamic import',
-  create: () => ({
-    name: 'dynamic-test',
-    decide: async () => {
-      const mod = await import('clawclaw-cli');
-      return [];
-    },
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('dynamic.ts', srcWithDynamicImport);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('dynamic-test');
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('does not warn when clawclaw-cli appears only in comments', async () => {
-      const srcWithComment = `
-// import { Action } from 'clawclaw-cli';
-export const strategy = {
-  id: 'comment-test',
-  description: 'test comment',
-  create: () => ({
-    name: 'comment-test',
-    decide: () => [],
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('with-comment.ts', srcWithComment);
-      const loader = await import('./loader.js');
-      await loader.listStrategyEntries();
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('does not warn when clawclaw-cli appears only in string literals', async () => {
-      const srcWithString = `
-export const strategy = {
-  id: 'string-test',
-  description: 'A strategy for clawclaw-cli game',
-  create: () => ({
-    name: 'string-test',
-    decide: () => [],
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('with-string.ts', srcWithString);
-      const loader = await import('./loader.js');
-      await loader.listStrategyEntries();
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('handles multiple imports from clawclaw-cli in one file', async () => {
-      const srcMulti = `
-import { Action } from 'clawclaw-cli';
-import { dist } from 'clawclaw-cli';
-export const strategy = {
-  id: 'multi-import',
-  description: 'test multiple imports',
-  create: () => ({
-    name: 'multi-import',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('multi.ts', srcMulti);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('multi-import');
-    });
-
-    it('rewrites clawclaw-cli/sdk sub-path imports', async () => {
-      const srcSdkSub = `
-import { Action } from 'clawclaw-cli/sdk';
-export const strategy = {
-  id: 'sdk-sub-test',
-  description: 'test sdk sub-path',
-  create: () => ({
-    name: 'sdk-sub-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('sdk-sub.ts', srcSdkSub);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('sdk-sub-test');
-    });
-
-    it('rewrites export * from clawclaw-cli re-exports', async () => {
-      const srcReExport = `
-export * from 'clawclaw-cli';
-export const strategy = {
-  id: 'reexport-test',
-  description: 'test re-export',
-  create: () => ({
-    name: 'reexport-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('reexport.ts', srcReExport);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('reexport-test');
-    });
-
-    it('rewrites named export from clawclaw-cli', async () => {
-      const srcNamedReExport = `
-export { Action } from 'clawclaw-cli';
-export const strategy = {
-  id: 'named-reexport-test',
-  description: 'test named re-export',
-  create: () => ({
-    name: 'named-reexport-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('named-reexport.ts', srcNamedReExport);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('named-reexport-test');
-    });
-
-    it('silently supports dynamic import() with clawclaw-cli/sdk sub-path', async () => {
-      const srcSubPath = `
-export const strategy = {
-  id: 'subpath-dynamic',
-  description: 'test sub-path dynamic import',
-  create: () => ({
-    name: 'subpath-dynamic',
-    decide: async () => {
-      const mod = await import('clawclaw-cli/sdk');
-      return [];
-    },
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('subpath.ts', srcSubPath);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('subpath-dynamic');
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('fails to load when strategy uses require() with clawclaw-cli', async () => {
-      const srcRequire = `
-export const strategy = {
-  id: 'require-test',
-  description: 'test require',
-  create: () => ({
-    name: 'require-test',
-    decide: () => {
-      const mod = require('clawclaw-cli');
-      return [];
-    },
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('require.ts', srcRequire);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringContaining('Failed to load user strategy require.ts'),
-      );
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringContaining("require('clawclaw-cli') is not supported"),
-      );
-      spy.mockRestore();
-    });
-
-    it('does not rewrite from clawclaw-cli when it appears in a comment', async () => {
-      const srcComment = `
-// Old syntax: import { Action } from 'clawclaw-cli';
-export const strategy = {
-  id: 'comment-from-test',
-  description: 'test from in comment',
-  create: () => ({
-    name: 'comment-from-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('comment-from.ts', srcComment);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('comment-from-test');
-    });
-
-    it('does not rewrite from clawclaw-cli when it appears in a string literal', async () => {
-      const srcString = `
-export const strategy = {
-  id: 'string-from-test',
-  description: 'Old syntax was from "clawclaw-cli"',
-  create: () => ({
-    name: 'string-from-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('string-from.ts', srcString);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('string-from-test');
-    });
-
-    it('does not warn when dynamic import appears only in a comment', async () => {
-      const srcCommented = `
-// const mod = await import('clawclaw-cli');
-export const strategy = {
-  id: 'commented-dynamic',
-  description: 'test commented dynamic import',
-  create: () => ({
-    name: 'commented-dynamic',
-    decide: () => [],
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('commented.ts', srcCommented);
-      const loader = await import('./loader.js');
-      await loader.listStrategyEntries();
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('does not warn when dynamic import appears only in a string', async () => {
-      const srcInString = `
-export const strategy = {
-  id: 'string-dynamic',
-  description: 'Use import("clawclaw-cli") for dynamic loading',
-  create: () => ({
-    name: 'string-dynamic',
-    decide: () => [],
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('string-dyn.ts', srcInString);
-      const loader = await import('./loader.js');
-      await loader.listStrategyEntries();
-      expect(spy).not.toHaveBeenCalled();
-      spy.mockRestore();
-    });
-
-    it('resolves relative imports from the strategy directory', async () => {
-      realFs.writeFileSync(
-        join(stratDir, 'helper.ts'),
-        `export const helperValue = 'from-helper';`,
-      );
-      const srcWithRelative = `
-import { helperValue } from './helper.js';
-export const strategy = {
-  id: 'relative-import-test',
-  description: 'test relative import: ' + helperValue,
-  create: () => ({
-    name: 'relative-import-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('with-relative.ts', srcWithRelative);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('relative-import-test');
-      expect(entries[0].description).toBe('test relative import: from-helper');
-    });
-
-    it('bundles nested relative imports from helper files', async () => {
-      realFs.writeFileSync(
-        join(stratDir, 'utils.ts'),
-        `export function greet(name: string): string { return 'hello ' + name; }`,
-      );
-      realFs.writeFileSync(
-        join(stratDir, 'intermediate.ts'),
-        `import { greet } from './utils.js';
-         export const greeting = greet('world');`,
-      );
-      const srcNested = `
-import { greeting } from './intermediate.js';
-export const strategy = {
-  id: 'nested-import-test',
-  description: greeting,
-  create: () => ({
-    name: 'nested-import-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('nested.ts', srcNested);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].description).toBe('hello world');
-    });
-
-    it('redirects clawclaw-cli imports in helper files too', async () => {
-      realFs.writeFileSync(
-        join(stratDir, 'sdk-helper.ts'),
-        `import { dist } from 'clawclaw-cli';
-         export const hasDist = typeof dist === 'function';`,
-      );
-      const srcHelperSdk = `
-import { hasDist } from './sdk-helper.js';
-export const strategy = {
-  id: 'helper-sdk-test',
-  description: 'has dist: ' + hasDist,
-  create: () => ({
-    name: 'helper-sdk-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('helper-sdk.ts', srcHelperSdk);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('helper-sdk-test');
-    });
-  });
-
-  describe('file filtering', () => {
-    it('skips files starting with underscore', async () => {
-      writeStratFile('good.ts', VALID_SRC);
-      writeStratFile('_disabled.ts', VALID_SRC.replace('test-strat', 'disabled'));
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('test-strat');
-    });
-
-    it('skips non ts/js files', async () => {
-      writeStratFile('strat.ts', VALID_SRC);
-      writeStratFile('readme.md', '# not a strategy');
-      writeStratFile('data.json', '{}');
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-    });
-
-    it('loads .js strategy files', async () => {
-      writeStratFile('js-strat.js', VALID_JS_SRC);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('js-strat');
-      expect(entries[0].description).toBe('A JS strategy');
-    });
-
-    it('loads .js strategy files with clawclaw-cli imports', async () => {
-      const srcJsImport = `
-import { Action } from 'clawclaw-cli';
-export const strategy = {
-  id: 'js-import-test',
-  description: 'JS strategy with clawclaw-cli import',
-  create: () => ({
-    name: 'js-import-test',
-    decide: () => [],
-  }),
-};
-`;
-      writeStratFile('js-import.js', srcJsImport);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('js-import-test');
-    });
-
-    it('skips .d.ts files', async () => {
-      writeStratFile('strat.ts', VALID_SRC);
-      writeStratFile('types.d.ts', 'export type X = string;');
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-    });
-
-    it('skips .test.ts files', async () => {
-      writeStratFile('strat.ts', VALID_SRC);
-      writeStratFile('strat.test.ts', VALID_SRC.replace('test-strat', 'from-test'));
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('test-strat');
-    });
-
-    it('skips entries without valid id/description/create', async () => {
-      writeStratFile('invalid.ts', INVALID_SRC);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-    });
-
-    it('logs error when user strategy fails to import', async () => {
-      writeStratFile('broken.ts', 'this is not valid TypeScript {{{');
-      writeStratFile('good.ts', VALID_SRC);
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('test-strat');
-      expect(spy).toHaveBeenCalledWith(
-        expect.stringContaining('Failed to load user strategy broken.ts'),
-      );
-      spy.mockRestore();
-    });
-
-    it('includes esbuild diagnostic in error message for syntax errors', async () => {
-      writeStratFile('bad-syntax.ts', 'this is not valid TypeScript {{{');
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const loader = await import('./loader.js');
-      await loader.listStrategyEntries();
-      // Error should contain the esbuild diagnostic: filename, line:col, and description
-      const errorCalls = spy.mock.calls.map(c => String(c[0]));
-      const buildError = errorCalls.find(m => m.includes('Failed to load user strategy bad-syntax.ts'));
-      expect(buildError).toBeDefined();
-      expect(buildError).toContain('bad-syntax.ts');
-      expect(buildError).toMatch(/\d+:\d+/); // line:col from esbuild
-      spy.mockRestore();
-    });
-
-    it('fails to load when strategy imports an uninstalled npm package', async () => {
-      const srcNpm = `
-import { something } from 'lodash';
-export const strategy = {
-  id: 'npm-test',
-  description: 'test npm import: ' + something,
-  create: () => ({
-    name: 'npm-test',
-    decide: () => [],
-  }),
-};
-`;
-      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      writeStratFile('npm-strat.ts', srcNpm);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-      const errorCalls = spy.mock.calls.map(c => String(c[0]));
-      const loadError = errorCalls.find(m => m.includes('Failed to load user strategy npm-strat.ts'));
-      expect(loadError).toBeDefined();
-      // Must be a runtime resolution failure (Node cannot find 'lodash' from temp dir),
-      // not an esbuild build failure. The `something` reference MUST stay used
-      // to prevent tree-shaking from removing the import entirely.
-      expect(loadError).toMatch(/Cannot find package|cannot be resolved/i);
-      spy.mockRestore();
-    });
-
-    it('handles readdirSync errors gracefully', async () => {
-      vi.mocked(readdirSync).mockImplementation((() => {
-        throw new Error('Permission denied');
-      }) as any);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(0);
-    });
-
-    it('last strategy wins when multiple files export same id', async () => {
-      writeStratFile('a-strat.ts', VALID_SRC);
-      writeStratFile('b-strat.ts', VALID_SRC_V2);
-      const loader = await import('./loader.js');
-      const entries = await loader.listStrategyEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0].id).toBe('test-strat');
-      expect(entries[0].description).toBe('Updated description');
-    });
-  });
-
-  describe('getStrategyEntry', () => {
-    beforeEach(() => {
-      writeStratFile('s.ts', VALID_SRC);
-    });
-
-    it('returns undefined for unknown strategy', async () => {
-      const loader = await import('./loader.js');
-      expect(await loader.getStrategyEntry('nonexistent')).toBeUndefined();
-    });
-
-    it('returns entry for known strategy', async () => {
-      const loader = await import('./loader.js');
-      const entry = await loader.getStrategyEntry('test-strat');
-      expect(entry).toBeDefined();
-      expect(entry!.id).toBe('test-strat');
-      expect(entry!.description).toBe('A test strategy');
-      expect(typeof entry!.create).toBe('function');
-    });
-  });
-
-  describe('resolveStrategy', () => {
-    beforeEach(() => {
-      writeStratFile('valid.ts', VALID_SRC);
-      writeStratFile('error.ts', ERROR_SRC);
-    });
-
-    it('creates a strategy instance from entry', async () => {
-      const loader = await import('./loader.js');
-      const strat = await loader.resolveStrategy('test-strat');
-      expect(strat.name).toBe('test-strat');
-      expect(typeof strat.decide).toBe('function');
-    });
-
-    it('passes args to create', async () => {
-      const loader = await import('./loader.js');
-      await expect(loader.resolveStrategy('error-strat', ['a', 'b']))
-        .rejects.toThrow('create failed: a,b');
-    });
-
-    it('throws for unknown strategy with helpful message', async () => {
-      const loader = await import('./loader.js');
-      await expect(loader.resolveStrategy('nope'))
-        .rejects.toThrow("Unknown strategy 'nope'. Use 'strategy list' to see available strategies.");
-    });
-  });
-});
+import { describe, it, expect, vi, beforeEach, beforeAll, afterAll } from 'vitest';
+import type * as FsType from 'fs';
+import { join } from 'path';
+
+vi.mock('fs');
+vi.mock('../lib/init-command.js', () => ({
+  getWorkspaceDir: () => process.env.CLAWCLAW_WORKSPACE_DIR ?? '/default/ws',
+}));
+
+import { existsSync, readdirSync, readFileSync, realpathSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
+
+let realFs: typeof FsType;
+let tmpDir: string;
+let stratDir: string;
+
+const VALID_SRC = `
+export const strategy = {
+  id: 'test-strat',
+  description: 'A test strategy',
+  create: (args) => ({ name: 'test-strat', decide: () => [] }),
+};
+`;
+
+const INVALID_SRC = `
+export const strategy = {
+  name: 'not-a-strategy',
+  description: 'Missing id field',
+};
+`;
+
+const ERROR_SRC = `
+export const strategy = {
+  id: 'error-strat',
+  description: 'Always throws on create',
+  create: (args) => { throw new Error('create failed: ' + (args ? args.join(',') : 'no-args')); },
+};
+`;
+
+const VALID_SRC_V2 = `
+export const strategy = {
+  id: 'test-strat',
+  description: 'Updated description',
+  create: (args) => ({ name: 'test-strat-v2', decide: () => [] }),
+};
+`;
+
+const VALID_JS_SRC = `
+export const strategy = {
+  id: 'js-strat',
+  description: 'A JS strategy',
+  create: (args) => ({ name: 'js-strat', decide: () => [] }),
+};
+`;
+
+beforeAll(async () => {
+  realFs = await vi.importActual<typeof import('fs')>('fs');
+  tmpDir = realFs.mkdtempSync(join('/tmp', 'strat-test-'));
+  stratDir = join(tmpDir, 'strategies');
+  realFs.mkdirSync(stratDir, { recursive: true });
+});
+
+afterAll(() => {
+  if (tmpDir) realFs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  // Clean strategy dir to avoid test pollution
+  for (const f of realFs.readdirSync(stratDir)) {
+    realFs.rmSync(join(stratDir, f));
+  }
+  process.env.CLAWCLAW_WORKSPACE_DIR = tmpDir;
+  vi.resetModules();
+  vi.mocked(existsSync).mockImplementation(((p: any) => {
+    if (p === '/fake/ws') return true;
+    if (p === '/fake/ws/strategies') return true;
+    return realFs.existsSync(p);
+  }) as any);
+  vi.mocked(readdirSync).mockImplementation(((p: any) => {
+    if (p.endsWith('src/strategies') || p.endsWith('src\\strategies')) return [];
+    return realFs.readdirSync(p);
+  }) as any);
+  vi.mocked(readFileSync).mockImplementation(((p: any, enc?: any) => {
+    if (enc === 'utf8') return realFs.readFileSync(p, 'utf8');
+    return realFs.readFileSync(p);
+  }) as any);
+  vi.mocked(realpathSync).mockImplementation(((p: any) => realFs.realpathSync(p)) as any);
+  vi.mocked(mkdtempSync).mockImplementation(((p: any) => realFs.mkdtempSync(p)) as any);
+  vi.mocked(writeFileSync).mockImplementation(((...args: any[]) => (realFs.writeFileSync as any)(...args)) as any);
+  vi.mocked(rmSync).mockImplementation(((...args: any[]) => (realFs.rmSync as any)(...args)) as any);
+});
+
+function writeStratFile(name: string, src: string) {
+  realFs.writeFileSync(join(stratDir, name), src);
+}
+
+describe('strategy loader', () => {
+  describe('user strategies dir resolution', () => {
+    it('returns no user strategies when workspace does not exist', async () => {
+      vi.mocked(existsSync).mockReturnValue(false);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+    });
+
+    it('returns no user strategies when strategies dir does not exist', async () => {
+      vi.mocked(existsSync).mockImplementation(((p: any) => {
+        if (p === '/fake/ws') return true;
+        return false;
+      }) as any);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+    });
+
+    it('loads user strategies from <workspace>/strategies', async () => {
+      writeStratFile('my-strat.ts', VALID_SRC);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('test-strat');
+    });
+
+    it('rewrites clawclaw-cli imports during loading', async () => {
+      const srcWithImport = `
+import { Action } from 'clawclaw-cli';
+export const strategy = {
+  id: 'import-test',
+  description: 'test import rewrite',
+  create: () => ({
+    name: 'import-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('with-import.ts', srcWithImport);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('import-test');
+    });
+
+    it('silently supports dynamic import() of clawclaw-cli', async () => {
+      const srcWithDynamicImport = `
+export const strategy = {
+  id: 'dynamic-test',
+  description: 'test dynamic import',
+  create: () => ({
+    name: 'dynamic-test',
+    decide: async () => {
+      const mod = await import('clawclaw-cli');
+      return [];
+    },
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('dynamic.ts', srcWithDynamicImport);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('dynamic-test');
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('does not warn when clawclaw-cli appears only in comments', async () => {
+      const srcWithComment = `
+// import { Action } from 'clawclaw-cli';
+export const strategy = {
+  id: 'comment-test',
+  description: 'test comment',
+  create: () => ({
+    name: 'comment-test',
+    decide: () => [],
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('with-comment.ts', srcWithComment);
+      const loader = await import('./loader.js');
+      await loader.listStrategyEntries();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('does not warn when clawclaw-cli appears only in string literals', async () => {
+      const srcWithString = `
+export const strategy = {
+  id: 'string-test',
+  description: 'A strategy for clawclaw-cli game',
+  create: () => ({
+    name: 'string-test',
+    decide: () => [],
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('with-string.ts', srcWithString);
+      const loader = await import('./loader.js');
+      await loader.listStrategyEntries();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('handles multiple imports from clawclaw-cli in one file', async () => {
+      const srcMulti = `
+import { Action } from 'clawclaw-cli';
+import { dist } from 'clawclaw-cli';
+export const strategy = {
+  id: 'multi-import',
+  description: 'test multiple imports',
+  create: () => ({
+    name: 'multi-import',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('multi.ts', srcMulti);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('multi-import');
+    });
+
+    it('rewrites clawclaw-cli/sdk sub-path imports', async () => {
+      const srcSdkSub = `
+import { Action } from 'clawclaw-cli/sdk';
+export const strategy = {
+  id: 'sdk-sub-test',
+  description: 'test sdk sub-path',
+  create: () => ({
+    name: 'sdk-sub-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('sdk-sub.ts', srcSdkSub);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('sdk-sub-test');
+    });
+
+    it('rewrites export * from clawclaw-cli re-exports', async () => {
+      const srcReExport = `
+export * from 'clawclaw-cli';
+export const strategy = {
+  id: 'reexport-test',
+  description: 'test re-export',
+  create: () => ({
+    name: 'reexport-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('reexport.ts', srcReExport);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('reexport-test');
+    });
+
+    it('rewrites named export from clawclaw-cli', async () => {
+      const srcNamedReExport = `
+export { Action } from 'clawclaw-cli';
+export const strategy = {
+  id: 'named-reexport-test',
+  description: 'test named re-export',
+  create: () => ({
+    name: 'named-reexport-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('named-reexport.ts', srcNamedReExport);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('named-reexport-test');
+    });
+
+    it('silently supports dynamic import() with clawclaw-cli/sdk sub-path', async () => {
+      const srcSubPath = `
+export const strategy = {
+  id: 'subpath-dynamic',
+  description: 'test sub-path dynamic import',
+  create: () => ({
+    name: 'subpath-dynamic',
+    decide: async () => {
+      const mod = await import('clawclaw-cli/sdk');
+      return [];
+    },
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('subpath.ts', srcSubPath);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('subpath-dynamic');
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('fails to load when strategy uses require() with clawclaw-cli', async () => {
+      const srcRequire = `
+export const strategy = {
+  id: 'require-test',
+  description: 'test require',
+  create: () => ({
+    name: 'require-test',
+    decide: () => {
+      const mod = require('clawclaw-cli');
+      return [];
+    },
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('require.ts', srcRequire);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load user strategy require.ts'),
+      );
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringContaining("require('clawclaw-cli') is not supported"),
+      );
+      spy.mockRestore();
+    });
+
+    it('does not rewrite from clawclaw-cli when it appears in a comment', async () => {
+      const srcComment = `
+// Old syntax: import { Action } from 'clawclaw-cli';
+export const strategy = {
+  id: 'comment-from-test',
+  description: 'test from in comment',
+  create: () => ({
+    name: 'comment-from-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('comment-from.ts', srcComment);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('comment-from-test');
+    });
+
+    it('does not rewrite from clawclaw-cli when it appears in a string literal', async () => {
+      const srcString = `
+export const strategy = {
+  id: 'string-from-test',
+  description: 'Old syntax was from "clawclaw-cli"',
+  create: () => ({
+    name: 'string-from-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('string-from.ts', srcString);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('string-from-test');
+    });
+
+    it('does not warn when dynamic import appears only in a comment', async () => {
+      const srcCommented = `
+// const mod = await import('clawclaw-cli');
+export const strategy = {
+  id: 'commented-dynamic',
+  description: 'test commented dynamic import',
+  create: () => ({
+    name: 'commented-dynamic',
+    decide: () => [],
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('commented.ts', srcCommented);
+      const loader = await import('./loader.js');
+      await loader.listStrategyEntries();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('does not warn when dynamic import appears only in a string', async () => {
+      const srcInString = `
+export const strategy = {
+  id: 'string-dynamic',
+  description: 'Use import("clawclaw-cli") for dynamic loading',
+  create: () => ({
+    name: 'string-dynamic',
+    decide: () => [],
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('string-dyn.ts', srcInString);
+      const loader = await import('./loader.js');
+      await loader.listStrategyEntries();
+      expect(spy).not.toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('resolves relative imports from the strategy directory', async () => {
+      realFs.writeFileSync(
+        join(stratDir, 'helper.ts'),
+        `export const helperValue = 'from-helper';`,
+      );
+      const srcWithRelative = `
+import { helperValue } from './helper.js';
+export const strategy = {
+  id: 'relative-import-test',
+  description: 'test relative import: ' + helperValue,
+  create: () => ({
+    name: 'relative-import-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('with-relative.ts', srcWithRelative);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('relative-import-test');
+      expect(entries[0].description).toBe('test relative import: from-helper');
+    });
+
+    it('bundles nested relative imports from helper files', async () => {
+      realFs.writeFileSync(
+        join(stratDir, 'utils.ts'),
+        `export function greet(name: string): string { return 'hello ' + name; }`,
+      );
+      realFs.writeFileSync(
+        join(stratDir, 'intermediate.ts'),
+        `import { greet } from './utils.js';
+         export const greeting = greet('world');`,
+      );
+      const srcNested = `
+import { greeting } from './intermediate.js';
+export const strategy = {
+  id: 'nested-import-test',
+  description: greeting,
+  create: () => ({
+    name: 'nested-import-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('nested.ts', srcNested);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].description).toBe('hello world');
+    });
+
+    it('redirects clawclaw-cli imports in helper files too', async () => {
+      realFs.writeFileSync(
+        join(stratDir, 'sdk-helper.ts'),
+        `import { dist } from 'clawclaw-cli';
+         export const hasDist = typeof dist === 'function';`,
+      );
+      const srcHelperSdk = `
+import { hasDist } from './sdk-helper.js';
+export const strategy = {
+  id: 'helper-sdk-test',
+  description: 'has dist: ' + hasDist,
+  create: () => ({
+    name: 'helper-sdk-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('helper-sdk.ts', srcHelperSdk);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('helper-sdk-test');
+    });
+  });
+
+  describe('file filtering', () => {
+    it('skips files starting with underscore', async () => {
+      writeStratFile('good.ts', VALID_SRC);
+      writeStratFile('_disabled.ts', VALID_SRC.replace('test-strat', 'disabled'));
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('test-strat');
+    });
+
+    it('skips non ts/js files', async () => {
+      writeStratFile('strat.ts', VALID_SRC);
+      writeStratFile('readme.md', '# not a strategy');
+      writeStratFile('data.json', '{}');
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+    });
+
+    it('loads .js strategy files', async () => {
+      writeStratFile('js-strat.js', VALID_JS_SRC);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('js-strat');
+      expect(entries[0].description).toBe('A JS strategy');
+    });
+
+    it('loads .js strategy files with clawclaw-cli imports', async () => {
+      const srcJsImport = `
+import { Action } from 'clawclaw-cli';
+export const strategy = {
+  id: 'js-import-test',
+  description: 'JS strategy with clawclaw-cli import',
+  create: () => ({
+    name: 'js-import-test',
+    decide: () => [],
+  }),
+};
+`;
+      writeStratFile('js-import.js', srcJsImport);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('js-import-test');
+    });
+
+    it('skips .d.ts files', async () => {
+      writeStratFile('strat.ts', VALID_SRC);
+      writeStratFile('types.d.ts', 'export type X = string;');
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+    });
+
+    it('skips .test.ts files', async () => {
+      writeStratFile('strat.ts', VALID_SRC);
+      writeStratFile('strat.test.ts', VALID_SRC.replace('test-strat', 'from-test'));
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('test-strat');
+    });
+
+    it('skips entries without valid id/description/create', async () => {
+      writeStratFile('invalid.ts', INVALID_SRC);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+    });
+
+    it('logs error when user strategy fails to import', async () => {
+      writeStratFile('broken.ts', 'this is not valid TypeScript {{{');
+      writeStratFile('good.ts', VALID_SRC);
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('test-strat');
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to load user strategy broken.ts'),
+      );
+      spy.mockRestore();
+    });
+
+    it('includes esbuild diagnostic in error message for syntax errors', async () => {
+      writeStratFile('bad-syntax.ts', 'this is not valid TypeScript {{{');
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const loader = await import('./loader.js');
+      await loader.listStrategyEntries();
+      // Error should contain the esbuild diagnostic: filename, line:col, and description
+      const errorCalls = spy.mock.calls.map(c => String(c[0]));
+      const buildError = errorCalls.find(m => m.includes('Failed to load user strategy bad-syntax.ts'));
+      expect(buildError).toBeDefined();
+      expect(buildError).toContain('bad-syntax.ts');
+      expect(buildError).toMatch(/\d+:\d+/); // line:col from esbuild
+      spy.mockRestore();
+    });
+
+    it('fails to load when strategy imports an uninstalled npm package', async () => {
+      const srcNpm = `
+import { something } from 'lodash';
+export const strategy = {
+  id: 'npm-test',
+  description: 'test npm import: ' + something,
+  create: () => ({
+    name: 'npm-test',
+    decide: () => [],
+  }),
+};
+`;
+      const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      writeStratFile('npm-strat.ts', srcNpm);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+      const errorCalls = spy.mock.calls.map(c => String(c[0]));
+      const loadError = errorCalls.find(m => m.includes('Failed to load user strategy npm-strat.ts'));
+      expect(loadError).toBeDefined();
+      // Must be a runtime resolution failure (Node cannot find 'lodash' from temp dir),
+      // not an esbuild build failure. The `something` reference MUST stay used
+      // to prevent tree-shaking from removing the import entirely.
+      expect(loadError).toMatch(/Cannot find package|cannot be resolved/i);
+      spy.mockRestore();
+    });
+
+    it('handles readdirSync errors gracefully', async () => {
+      vi.mocked(readdirSync).mockImplementation((() => {
+        throw new Error('Permission denied');
+      }) as any);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(0);
+    });
+
+    it('last strategy wins when multiple files export same id', async () => {
+      writeStratFile('a-strat.ts', VALID_SRC);
+      writeStratFile('b-strat.ts', VALID_SRC_V2);
+      const loader = await import('./loader.js');
+      const entries = await loader.listStrategyEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].id).toBe('test-strat');
+      expect(entries[0].description).toBe('Updated description');
+    });
+  });
+
+  describe('getStrategyEntry', () => {
+    beforeEach(() => {
+      writeStratFile('s.ts', VALID_SRC);
+    });
+
+    it('returns undefined for unknown strategy', async () => {
+      const loader = await import('./loader.js');
+      expect(await loader.getStrategyEntry('nonexistent')).toBeUndefined();
+    });
+
+    it('returns entry for known strategy', async () => {
+      const loader = await import('./loader.js');
+      const entry = await loader.getStrategyEntry('test-strat');
+      expect(entry).toBeDefined();
+      expect(entry!.id).toBe('test-strat');
+      expect(entry!.description).toBe('A test strategy');
+      expect(typeof entry!.create).toBe('function');
+    });
+  });
+
+  describe('resolveStrategy', () => {
+    beforeEach(() => {
+      writeStratFile('valid.ts', VALID_SRC);
+      writeStratFile('error.ts', ERROR_SRC);
+    });
+
+    it('creates a strategy instance from entry', async () => {
+      const loader = await import('./loader.js');
+      const strat = await loader.resolveStrategy('test-strat');
+      expect(strat.name).toBe('test-strat');
+      expect(typeof strat.decide).toBe('function');
+    });
+
+    it('passes args to create', async () => {
+      const loader = await import('./loader.js');
+      await expect(loader.resolveStrategy('error-strat', ['a', 'b']))
+        .rejects.toThrow('create failed: a,b');
+    });
+
+    it('throws for unknown strategy with helpful message', async () => {
+      const loader = await import('./loader.js');
+      await expect(loader.resolveStrategy('nope'))
+        .rejects.toThrow("Unknown strategy 'nope'. Use 'strategy list' to see available strategies.");
+    });
+  });
+});