@myclaw163/clawclaw-cli 0.6.70 → 0.6.74

package/src/commands/strategy.test.ts

@@ -1,145 +1,145 @@
-// src/commands/strategy.test.ts
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { createStrategyCommand } from './strategy.js';
-
-let ws: string;
-let logs: string[];
-let errs: string[];
-
-beforeEach(() => {
-  ws = mkdtempSync(join(tmpdir(), 'ccl-strategy-cmd-'));
-  process.env.CLAWCLAW_WORKSPACE_DIR = ws;
-  logs = []; errs = [];
-  vi.spyOn(console, 'log').mockImplementation((...a) => { logs.push(a.join(' ')); });
-  vi.spyOn(console, 'error').mockImplementation((...a) => { errs.push(a.join(' ')); });
-  vi.spyOn(process, 'exit').mockImplementation((() => { throw new Error('process.exit'); }) as any);
-});
-
-afterEach(() => {
-  delete process.env.CLAWCLAW_WORKSPACE_DIR;
-  vi.restoreAllMocks();
-  rmSync(ws, { recursive: true, force: true });
-});
-
-async function run(argv: string[]) {
-  const cmd = createStrategyCommand();
-  await cmd.parseAsync(['node', 'ccl', ...argv]);
-}
-
-describe('strategy command', () => {
-  describe('--export', () => {
-    it('should export a valid strategy', async () => {
-      await run(['--export', 'task-only']);
-
-      const strategyFile = join(ws, 'strategies', 'task-only.ts');
-      expect(logs[0]).toContain('task-only');
-      expect(logs[0]).toContain('exported');
-
-      const content = readFileSync(strategyFile, 'utf8');
-      expect(content).toContain('// Exported from task-only@');
-      expect(content).toContain("from '@myclaw163/clawclaw-cli'");
-    });
-
-    it('should export with --force to overwrite', async () => {
-      // First export
-      await run(['--export', 'task-only']);
-
-      // Modify the file
-      const strategyFile = join(ws, 'strategies', 'task-only.ts');
-      writeFileSync(strategyFile, '// customized', 'utf8');
-
-      // Re-export with --force
-      await run(['--export', 'task-only', '--force']);
-
-      const content = readFileSync(strategyFile, 'utf8');
-      expect(content).toContain('// Exported from task-only@');
-    });
-
-    it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
-      await run(['--export', 'kill-lone']);
-
-      expect(existsSync(join(ws, 'strategies', 'kill-lone.ts'))).toBe(true);
-      expect(existsSync(join(ws, 'strategies', 'kill-lone.knowledge.md'))).toBe(true);
-    });
-
-    it('should reject non-existent strategies', async () => {
-      await expect(run(['--export', 'non-existent'])).rejects.toThrow('process.exit');
-
-      expect(errs[0]).toContain('export_failed');
-      expect(errs[0]).toContain('not found');
-    });
-
-    it('should warn about other stale strategies after export', async () => {
-      // Export two strategies
-      await run(['--export', 'task-only']);
-      await run(['--export', 'kill-lone']);
-      logs = []; errs = [];
-
-      // Tamper kill-lone's hash to make it stale
-      const manifestFile = join(ws, 'strategies', '.official', 'manifest.json');
-      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
-      manifest['kill-lone'].sourceHash = 'stale';
-      writeFileSync(manifestFile, JSON.stringify(manifest), 'utf8');
-
-      // Re-export task-only — should warn about kill-lone being stale
-      await run(['--export', 'task-only', '--force']);
-
-      expect(errs.join(' ')).toContain('kill-lone');
-      expect(errs.join(' ')).toContain('提示');
-    });
-  });
-
-  describe('--info', () => {
-    it('should show strategy info', async () => {
-      await run(['--info', 'task-only']);
-
-      expect(logs[0]).toContain('"id": "task-only"');
-      expect(logs[0]).toContain('"description"');
-    });
-
-    it('should show knowledge contract if available', async () => {
-      await run(['--info', 'task-report']);
-
-      const output = JSON.parse(logs[0]);
-      expect(output.id).toBe('task-report');
-      expect(output.description).toBeDefined();
-      // knowledge might be null if no .knowledge.md file exists
-    });
-
-    it('should resolve a Chinese name and show its knowledge contract', async () => {
-      await run(['--info', '武士虾']);
-
-      const output = JSON.parse(logs[0]);
-      expect(output.id).toBe('warrior-memory');
-      expect(output.name).toBe('武士虾');
-      expect(output.knowledge).toContain('warrior-memory');
-    });
-
-    it('should reject non-existent strategies', async () => {
-      await expect(run(['--info', 'non-existent'])).rejects.toThrow('process.exit');
-
-      expect(errs[0]).toContain('unknown_strategy');
-      expect(errs[0]).toContain('non-existent');
-    });
-  });
-
-  describe('--list', () => {
-    it('should list all available strategies', async () => {
-      await run(['--list']);
-
-      const output = JSON.parse(logs[0]);
-      expect(output.strategies).toBeDefined();
-      expect(Array.isArray(output.strategies)).toBe(true);
-      expect(output.strategies.length).toBeGreaterThan(0);
-
-      // Check that task-only is in the list
-      const taskOnly = output.strategies.find((s: any) => s.id === 'task-only');
-      expect(taskOnly).toBeDefined();
-      expect(taskOnly.name).toBe('纯任务');
-      expect(taskOnly.description).toBeDefined();
-    });
-  });
-});
+// src/commands/strategy.test.ts
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { createStrategyCommand } from './strategy.js';
+
+let ws: string;
+let logs: string[];
+let errs: string[];
+
+beforeEach(() => {
+  ws = mkdtempSync(join(tmpdir(), 'ccl-strategy-cmd-'));
+  process.env.CLAWCLAW_WORKSPACE_DIR = ws;
+  logs = []; errs = [];
+  vi.spyOn(console, 'log').mockImplementation((...a) => { logs.push(a.join(' ')); });
+  vi.spyOn(console, 'error').mockImplementation((...a) => { errs.push(a.join(' ')); });
+  vi.spyOn(process, 'exit').mockImplementation((() => { throw new Error('process.exit'); }) as any);
+});
+
+afterEach(() => {
+  delete process.env.CLAWCLAW_WORKSPACE_DIR;
+  vi.restoreAllMocks();
+  rmSync(ws, { recursive: true, force: true });
+});
+
+async function run(argv: string[]) {
+  const cmd = createStrategyCommand();
+  await cmd.parseAsync(['node', 'ccl', ...argv]);
+}
+
+describe('strategy command', () => {
+  describe('--export', () => {
+    it('should export a valid strategy', async () => {
+      await run(['--export', 'task-only']);
+
+      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      expect(logs[0]).toContain('task-only');
+      expect(logs[0]).toContain('exported');
+
+      const content = readFileSync(strategyFile, 'utf8');
+      expect(content).toContain('// Exported from task-only@');
+      expect(content).toContain("from '@myclaw163/clawclaw-cli'");
+    });
+
+    it('should export with --force to overwrite', async () => {
+      // First export
+      await run(['--export', 'task-only']);
+
+      // Modify the file
+      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      writeFileSync(strategyFile, '// customized', 'utf8');
+
+      // Re-export with --force
+      await run(['--export', 'task-only', '--force']);
+
+      const content = readFileSync(strategyFile, 'utf8');
+      expect(content).toContain('// Exported from task-only@');
+    });
+
+    it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
+      await run(['--export', 'kill-lone']);
+
+      expect(existsSync(join(ws, 'strategies', 'kill-lone.ts'))).toBe(true);
+      expect(existsSync(join(ws, 'strategies', 'kill-lone.knowledge.md'))).toBe(true);
+    });
+
+    it('should reject non-existent strategies', async () => {
+      await expect(run(['--export', 'non-existent'])).rejects.toThrow('process.exit');
+
+      expect(errs[0]).toContain('export_failed');
+      expect(errs[0]).toContain('not found');
+    });
+
+    it('should warn about other stale strategies after export', async () => {
+      // Export two strategies
+      await run(['--export', 'task-only']);
+      await run(['--export', 'kill-lone']);
+      logs = []; errs = [];
+
+      // Tamper kill-lone's hash to make it stale
+      const manifestFile = join(ws, 'strategies', '.official', 'manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
+      manifest['kill-lone'].sourceHash = 'stale';
+      writeFileSync(manifestFile, JSON.stringify(manifest), 'utf8');
+
+      // Re-export task-only — should warn about kill-lone being stale
+      await run(['--export', 'task-only', '--force']);
+
+      expect(errs.join(' ')).toContain('kill-lone');
+      expect(errs.join(' ')).toContain('提示');
+    });
+  });
+
+  describe('--info', () => {
+    it('should show strategy info', async () => {
+      await run(['--info', 'task-only']);
+
+      expect(logs[0]).toContain('"id": "task-only"');
+      expect(logs[0]).toContain('"description"');
+    });
+
+    it('should show knowledge contract if available', async () => {
+      await run(['--info', 'task-report']);
+
+      const output = JSON.parse(logs[0]);
+      expect(output.id).toBe('task-report');
+      expect(output.description).toBeDefined();
+      // knowledge might be null if no .knowledge.md file exists
+    });
+
+    it('should resolve a Chinese name and show its knowledge contract', async () => {
+      await run(['--info', '武士虾']);
+
+      const output = JSON.parse(logs[0]);
+      expect(output.id).toBe('warrior-memory');
+      expect(output.name).toBe('武士虾');
+      expect(output.knowledge).toContain('warrior-memory');
+    });
+
+    it('should reject non-existent strategies', async () => {
+      await expect(run(['--info', 'non-existent'])).rejects.toThrow('process.exit');
+
+      expect(errs[0]).toContain('unknown_strategy');
+      expect(errs[0]).toContain('non-existent');
+    });
+  });
+
+  describe('--list', () => {
+    it('should list all available strategies', async () => {
+      await run(['--list']);
+
+      const output = JSON.parse(logs[0]);
+      expect(output.strategies).toBeDefined();
+      expect(Array.isArray(output.strategies)).toBe(true);
+      expect(output.strategies.length).toBeGreaterThan(0);
+
+      // Check that task-only is in the list
+      const taskOnly = output.strategies.find((s: any) => s.id === 'task-only');
+      expect(taskOnly).toBeDefined();
+      expect(taskOnly.name).toBe('纯任务');
+      expect(taskOnly.description).toBeDefined();
+    });
+  });
+});

package/src/commands/strategy.ts

@@ -1,181 +1,181 @@
-import { Command } from 'commander';
-import { join } from 'path';
-import { GameClient } from '../lib/game-client.js';
-import { getProfileStateDir, getWorkspaceDir } from '../lib/init-command.js';
-import { AuthStore } from '../lib/auth.js';
-import { sendOwnerControlRequest } from '../runtime/owner-control.js';
-
-const KILL_STRATEGIES = new Set([
-  'kill-frenzy', 'kill-lone', 'kill-target', 'warrior-memory',
-  'crab-sabotage', 'lone-kill-task', 'task-kill-report',
-]);
-const KILL_CAPABLE_ROLES = new Set([
-  'crab_generic', 'shrimp_warrior', 'shrimp_pistol', 'neutral_octopus',
-]);
-
-export function createStrategyCommand(): Command {
-  const cmd = new Command('strategy')
-    .alias('stg')
-    .description('Run a named strategy, or manage exported strategies')
-    .argument('[name]', 'Strategy name to start')
-    .argument('[args...]', 'Strategy arguments')
-    .option('--list', 'List all available strategies')
-    .option('--stop', 'Stop any running strategy')
-    .option('--info <id>', 'Show a strategy\'s knowledge contract')
-    .option('--export <id>', 'Export an official strategy to workspace for customization')
-    .option('--force', 'Force overwrite if strategy file already exists (use with --export)')
-    .allowUnknownOption()
-    .addHelpText('after', () => {
-      const strategiesDir = join(getWorkspaceDir(), 'strategies');
-      return `
-Custom strategies:
-  Place .ts or .js files in ${strategiesDir}
-  (or $CLAWCLAW_WORKSPACE_DIR/strategies/)
-  Each file must export a 'strategy' object with id, name (中文别名), description, and create() function.
-  Use 'import { ... } from "@myclaw163/clawclaw-cli"' to access Action, GameState, and utilities.
-  See docs/自定义策略.md for full API reference and examples.
-`;
-    })
-    .action(async (name: string | undefined, args: string[], opts: { list?: boolean; stop?: boolean; info?: string; export?: string; force?: boolean }) => {
-      if (opts.info) {
-        const { getStrategyEntry, getStrategyKnowledgeDoc, listStrategyEntries } = await import('../strategies/loader.js');
-        const entry = await getStrategyEntry(opts.info);
-        if (!entry) {
-          const available = await listStrategyEntries();
-          console.error(JSON.stringify({
-            error: 'unknown_strategy',
-            message: `Unknown strategy '${opts.info}'.`,
-            available: available.map(e => e.id),
-          }, null, 2));
-          process.exit(1);
-        }
-        const knowledge = await getStrategyKnowledgeDoc(entry.id);
-        console.log(JSON.stringify({ id: entry.id, name: entry.name ?? entry.id, description: entry.description, knowledge: knowledge ?? null }, null, 2));
-        return;
-      }
-
-      if (opts.export) {
-        try {
-          const { exportStrategy } = await import('../lib/strategy-export.js');
-          await exportStrategy(opts.export, { force: opts.force ?? false });
-          console.log(JSON.stringify({ message: `Strategy '${opts.export}' exported to workspace.`, path: `${opts.export}.ts` }, null, 2));
-        } catch (err: any) {
-          console.error(JSON.stringify({ error: 'export_failed', message: err?.message ?? String(err) }, null, 2));
-          process.exit(1);
-        }
-
-        // After exporting, check if there are other stale strategies.
-        try {
-          const { detectStaleOfficialStrategies } = await import('../lib/strategy-export.js');
-          const staleIds = detectStaleOfficialStrategies().filter(id => id !== opts.export);
-          if (staleIds.length > 0) {
-            const ids = staleIds.join(', ');
-            console.error(`[提示] 还有其他官方策略有更新 (${ids})，运行 \`ccl strategy --export <id> --force\` 重新导出`);
-          }
-        } catch {
-          // Silently ignore
-        }
-
-        return;
-      }
-
-      if (opts.list) {
-        const { listStrategyEntries } = await import('../strategies/loader.js');
-        const entries = await listStrategyEntries();
-        if (entries.length === 0) {
-          console.log(JSON.stringify({ strategies: [], message: 'No strategies found.' }, null, 2));
-          return;
-        }
-        console.log(JSON.stringify({
-          strategies: entries.map(e => ({ id: e.id, name: e.name ?? e.id, description: e.description })),
-        }, null, 2));
-        return;
-      }
-
-      if (opts.stop) {
-        const profile = new AuthStore().getActive();
-        const response = profile
-          ? await sendOwnerControlRequest(getProfileStateDir(profile), 'stop_strategy')
-          : null;
-        if (!response?.ok) {
-          console.error(JSON.stringify({
-            error: 'no_game_start_owner',
-            message: 'No active ccl game start owner is available to stop strategy.',
-          }, null, 2));
-          process.exit(1);
-        }
-        console.log(JSON.stringify({ message: 'Strategy stopped.' }, null, 2));
-        return;
-      }
-
-      if (!name) {
-        cmd.help();
-        return;
-      }
-
-      const { listStrategyEntries, getStrategyEntry } = await import('../strategies/loader.js');
-      const entry = await getStrategyEntry(name);
-      if (!entry) {
-        const available = await listStrategyEntries();
-        console.error(JSON.stringify({
-          error: 'unknown_strategy',
-          message: `Unknown strategy '${name}'.`,
-          available: available.map(e => ({ id: e.id, name: e.name ?? e.id, description: e.description })),
-        }, null, 2));
-        process.exit(1);
-      }
-
-      try {
-        entry.create(args.length > 0 ? args : undefined);
-      } catch (err: any) {
-        console.error(JSON.stringify({
-          error: 'strategy_create_failed',
-          message: err?.message ?? String(err),
-          strategy: name,
-        }, null, 2));
-        process.exit(1);
-      }
-
-      if (KILL_STRATEGIES.has(entry.id)) {
-        try {
-          const client = GameClient.fromAuth();
-          await client.discoverGameServer();
-          const roleInfo = await client.getRoleInfo();
-          const role: string = roleInfo?.data?.role ?? roleInfo?.role ?? '';
-          const displayName: string = roleInfo?.data?.display_name ?? role;
-          if (role && !KILL_CAPABLE_ROLES.has(role)) {
-            console.error(JSON.stringify({
-              error: 'role_incompatible',
-              message: `Strategy '${entry.id}' requires kill ability, but your role '${displayName}' (${role}) cannot kill. Use a non-kill strategy like task-report, patrol, or report-patrol.`,
-              strategy: entry.id,
-              role,
-            }, null, 2));
-            process.exit(1);
-          }
-        } catch {}
-      }
-
-      const profile = new AuthStore().getActive();
-      const response = profile
-        ? await sendOwnerControlRequest(getProfileStateDir(profile), 'switch_strategy', {
-          strategy: entry.id,
-          args: args.length > 0 ? args : undefined,
-        })
-        : null;
-      if (!response?.ok) {
-        console.error(JSON.stringify({
-          error: 'no_game_start_owner',
-          message: 'Run `ccl game start` before switching strategy; strategy processes are owned by the game start runtime.',
-        }, null, 2));
-        process.exit(1);
-      }
-      console.log(JSON.stringify({
-        message: `Strategy started: ${entry.id}`,
-        name: entry.name ?? entry.id,
-        description: entry.description,
-        pid: response.pid,
-      }, null, 2));
-    });
-
-  return cmd;
-}
+import { Command, Option } from 'commander';
+import { join } from 'path';
+import { GameClient } from '../lib/game-client.js';
+import { getProfileStateDir, getWorkspaceDir } from '../lib/init-command.js';
+import { AuthStore } from '../lib/auth.js';
+import { sendOwnerControlRequest } from '../runtime/owner-control.js';
+
+const KILL_STRATEGIES = new Set([
+  'kill-frenzy', 'kill-lone', 'kill-target', 'warrior-memory',
+  'crab-sabotage', 'lone-kill-task', 'task-kill-report',
+]);
+const KILL_CAPABLE_ROLES = new Set([
+  'crab_generic', 'shrimp_warrior', 'shrimp_pistol', 'neutral_octopus',
+]);
+
+export function createStrategyCommand(): Command {
+  const cmd = new Command('strategy')
+    .alias('stg')
+    .description('Run a named strategy, or manage exported strategies')
+    .argument('[name]', 'Strategy name to start')
+    .argument('[args...]', 'Strategy arguments')
+    .option('--list', 'List all available strategies')
+    .addOption(new Option('--stop', 'Stop any running strategy').hideHelp())
+    .option('--info <id>', 'Show a strategy\'s knowledge contract')
+    .addOption(new Option('--export <id>', 'Export an official strategy to workspace for customization').hideHelp())
+    .addOption(new Option('--force', 'Force overwrite if strategy file already exists (use with --export)').hideHelp())
+    .allowUnknownOption()
+    .addHelpText('after', () => {
+      const strategiesDir = join(getWorkspaceDir(), 'strategies');
+      return `
+Custom strategies:
+  Place .ts or .js files in ${strategiesDir}
+  (or $CLAWCLAW_WORKSPACE_DIR/strategies/)
+  Each file must export a 'strategy' object with id, name (中文别名), description, and create() function.
+  Use 'import { ... } from "@myclaw163/clawclaw-cli"' to access Action, GameState, and utilities.
+  See docs/自定义策略.md for full API reference and examples.
+`;
+    })
+    .action(async (name: string | undefined, args: string[], opts: { list?: boolean; stop?: boolean; info?: string; export?: string; force?: boolean }) => {
+      if (opts.info) {
+        const { getStrategyEntry, getStrategyKnowledgeDoc, listStrategyEntries } = await import('../strategies/loader.js');
+        const entry = await getStrategyEntry(opts.info);
+        if (!entry) {
+          const available = await listStrategyEntries();
+          console.error(JSON.stringify({
+            error: 'unknown_strategy',
+            message: `Unknown strategy '${opts.info}'.`,
+            available: available.map(e => e.id),
+          }, null, 2));
+          process.exit(1);
+        }
+        const knowledge = await getStrategyKnowledgeDoc(entry.id);
+        console.log(JSON.stringify({ id: entry.id, name: entry.name ?? entry.id, description: entry.description, knowledge: knowledge ?? null }, null, 2));
+        return;
+      }
+
+      if (opts.export) {
+        try {
+          const { exportStrategy } = await import('../lib/strategy-export.js');
+          await exportStrategy(opts.export, { force: opts.force ?? false });
+          console.log(JSON.stringify({ message: `Strategy '${opts.export}' exported to workspace.`, path: `${opts.export}.ts` }, null, 2));
+        } catch (err: any) {
+          console.error(JSON.stringify({ error: 'export_failed', message: err?.message ?? String(err) }, null, 2));
+          process.exit(1);
+        }
+
+        // After exporting, check if there are other stale strategies.
+        try {
+          const { detectStaleOfficialStrategies } = await import('../lib/strategy-export.js');
+          const staleIds = detectStaleOfficialStrategies().filter(id => id !== opts.export);
+          if (staleIds.length > 0) {
+            const ids = staleIds.join(', ');
+            console.error(`[提示] 还有其他官方策略有更新 (${ids})，运行 \`ccl strategy --export <id> --force\` 重新导出`);
+          }
+        } catch {
+          // Silently ignore
+        }
+
+        return;
+      }
+
+      if (opts.list) {
+        const { listStrategyEntries } = await import('../strategies/loader.js');
+        const entries = await listStrategyEntries();
+        if (entries.length === 0) {
+          console.log(JSON.stringify({ strategies: [], message: 'No strategies found.' }, null, 2));
+          return;
+        }
+        console.log(JSON.stringify({
+          strategies: entries.map(e => ({ id: e.id, name: e.name ?? e.id, description: e.description })),
+        }, null, 2));
+        return;
+      }
+
+      if (opts.stop) {
+        const profile = new AuthStore().getActive();
+        const response = profile
+          ? await sendOwnerControlRequest(getProfileStateDir(profile), 'stop_strategy')
+          : null;
+        if (!response?.ok) {
+          console.error(JSON.stringify({
+            error: 'no_game_start_owner',
+            message: 'No active ccl game start owner is available to stop strategy.',
+          }, null, 2));
+          process.exit(1);
+        }
+        console.log(JSON.stringify({ message: 'Strategy stopped.' }, null, 2));
+        return;
+      }
+
+      if (!name) {
+        cmd.help();
+        return;
+      }
+
+      const { listStrategyEntries, getStrategyEntry } = await import('../strategies/loader.js');
+      const entry = await getStrategyEntry(name);
+      if (!entry) {
+        const available = await listStrategyEntries();
+        console.error(JSON.stringify({
+          error: 'unknown_strategy',
+          message: `Unknown strategy '${name}'.`,
+          available: available.map(e => ({ id: e.id, name: e.name ?? e.id, description: e.description })),
+        }, null, 2));
+        process.exit(1);
+      }
+
+      try {
+        entry.create(args.length > 0 ? args : undefined);
+      } catch (err: any) {
+        console.error(JSON.stringify({
+          error: 'strategy_create_failed',
+          message: err?.message ?? String(err),
+          strategy: name,
+        }, null, 2));
+        process.exit(1);
+      }
+
+      if (KILL_STRATEGIES.has(entry.id)) {
+        try {
+          const client = GameClient.fromAuth();
+          await client.discoverGameServer();
+          const roleInfo = await client.getRoleInfo();
+          const role: string = roleInfo?.data?.role ?? roleInfo?.role ?? '';
+          const displayName: string = roleInfo?.data?.display_name ?? role;
+          if (role && !KILL_CAPABLE_ROLES.has(role)) {
+            console.error(JSON.stringify({
+              error: 'role_incompatible',
+              message: `Strategy '${entry.id}' requires kill ability, but your role '${displayName}' (${role}) cannot kill. Use a non-kill strategy like task-report, patrol, or report-patrol.`,
+              strategy: entry.id,
+              role,
+            }, null, 2));
+            process.exit(1);
+          }
+        } catch {}
+      }
+
+      const profile = new AuthStore().getActive();
+      const response = profile
+        ? await sendOwnerControlRequest(getProfileStateDir(profile), 'switch_strategy', {
+          strategy: entry.id,
+          args: args.length > 0 ? args : undefined,
+        })
+        : null;
+      if (!response?.ok) {
+        console.error(JSON.stringify({
+          error: 'no_game_start_owner',
+          message: 'Run `ccl game start` before switching strategy; strategy processes are owned by the game start runtime.',
+        }, null, 2));
+        process.exit(1);
+      }
+      console.log(JSON.stringify({
+        message: `Strategy started: ${entry.id}`,
+        name: entry.name ?? entry.id,
+        description: entry.description,
+        pid: response.pid,
+      }, null, 2));
+    });
+
+  return cmd;
+}