@myclaw163/clawclaw-cli 0.6.70 → 0.6.74

package/src/strategies/loader.ts

@@ -1,179 +1,179 @@
-import { existsSync, readdirSync, readFileSync, realpathSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { dirname, join, resolve, basename } from 'path';
-import { tmpdir } from 'os';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { getWorkspaceDir } from '../lib/init-command.js';
-import type { Plugin, OnResolveArgs } from 'esbuild';
-import type { Strategy, StrategyEntry } from './types.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Resolve SDK path for user strategy imports (raw filesystem path, not URL).
-// realpathSync ensures dedup against built-in strategies even under --preserve-symlinks.
-const SDK_PATH = realpathSync(resolve(__dirname, '../sdk/index.ts'));
-
-const strategyMap = new Map<string, StrategyEntry>();
-const knowledgeDocMap = new Map<string, string>();
-let loaded = false;
-
-const INFRA_FILES = new Set(['loader', 'types', 'game-utils', 'player-targets', 'greeting', 'spawn', 'strategy-loop', 'new-events-backfill']);
-
-function resolveUserStrategiesDir(): string | undefined {
-  const workspaceDir = getWorkspaceDir();
-  if (!existsSync(workspaceDir)) return undefined;
-  const strategiesDir = join(workspaceDir, 'strategies');
-  if (!existsSync(strategiesDir)) return undefined;
-  return strategiesDir;
-}
-
-/**
- * Create an esbuild plugin that intercepts `@myclaw163/clawclaw-cli` and
- * `@myclaw163/clawclaw-cli/*` imports (and the legacy bare `clawclaw-cli`
- * name for backward compat) and redirects them to the local SDK path
- * (marked external so Node resolves the same module instance at runtime).
- *
- * `require()` calls fail the build with a clear error, since `require` is
- * unavailable in ESM output and would otherwise crash at runtime.
- */
-function createSdkPlugin(): { plugin: Plugin } {
-  const sdkUrl = pathToFileURL(SDK_PATH).href;
-
-  const plugin: Plugin = {
-    name: 'clawclaw-cli-sdk',
-    setup(build) {
-      build.onResolve({ filter: /^(?:@myclaw163\/)?clawclaw-cli(?:\/.*)?$/ }, (args: OnResolveArgs) => {
-        if (args.kind === 'require-call') {
-          return {
-            errors: [{
-              text: `require('${args.path}') is not supported in user strategies. Use static imports: import { ... } from '${args.path}'.`,
-            }],
-          };
-        }
-        return { path: sdkUrl, external: true };
-      });
-    },
-  };
-
-  return { plugin };
-}
-
-// Returns Record<string, unknown> — slightly less precise than native import()'s
-// Module type, but both are cast to StrategyEntry via `as` in loadFromDir.
-export async function importUserFile(filePath: string): Promise<Record<string, unknown>> {
-  const { plugin } = createSdkPlugin();
-  const { build } = await import('esbuild');
-  const result = await build({
-    stdin: {
-      contents: readFileSync(filePath, 'utf8'),
-      resolveDir: dirname(filePath),
-      sourcefile: basename(filePath),
-      loader: filePath.endsWith('.ts') ? 'ts' : 'js',
-    },
-    bundle: true,
-    format: 'esm',
-    write: false,
-    platform: 'node',
-    packages: 'external',
-    plugins: [plugin],
-  });
-
-  // Write to temporary file so Node's module cache deduplicates the SDK —
-  // data URLs load as separate module instances, breaking instanceof checks.
-  const tmpDir = mkdtempSync(join(tmpdir(), 'ccl-strategy-'));
-  const tmpFile = join(tmpDir, basename(filePath).replace(/\.(ts|js)$/, '.mjs'));
-  try {
-    writeFileSync(tmpFile, result.outputFiles[0].text);
-    return await import(pathToFileURL(tmpFile).href);
-  } finally {
-    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-  }
-}
-
-async function loadFromDir(dir: string, skipInfra: boolean): Promise<void> {
-  let files: string[];
-  try {
-    files = readdirSync(dir).filter(f => {
-      if (f.startsWith('_')) return false;
-      const match = f.match(/^(.+)\.(ts|js)$/);
-      if (!match) return false;
-      if (match[1].endsWith('.d')) return false;
-      if (match[1].endsWith('.test')) return false;
-      return !skipInfra || !INFRA_FILES.has(match[1]);
-    });
-  } catch {
-    return;
-  }
-  for (const file of files) {
-    try {
-      const filePath = realpathSync(join(dir, file));
-      const mod = skipInfra
-        ? await import(pathToFileURL(filePath).href)
-        : await importUserFile(filePath);
-      const entry: StrategyEntry | undefined = mod.strategy as StrategyEntry | undefined;
-      if (entry?.id && typeof entry.description === 'string' && typeof entry.create === 'function') {
-        strategyMap.set(entry.id, entry);
-        const sidecar = filePath.replace(/\.(ts|js)$/, '.knowledge.md');
-        if (existsSync(sidecar)) knowledgeDocMap.set(entry.id, sidecar);
-      }
-    } catch (err) {
-      if (!skipInfra) {
-        // Strip temp-dir paths from error messages — they leak internal
-        // implementation details (e.g., /tmp/ccl-strategy-XXXX/strategy.mjs)
-        const raw = err instanceof Error ? err.message : String(err);
-        const cleaned = raw.replace(/\S*ccl-strategy-[^/]*\//g, '');
-        console.error(`[ccl] Failed to load user strategy ${file}: ${cleaned}`);
-      }
-    }
-  }
-}
-
-async function ensureLoaded(): Promise<void> {
-  if (loaded) return;
-  loaded = true;
-  await loadFromDir(__dirname, true);
-  const userDir = resolveUserStrategiesDir();
-  if (userDir) await loadFromDir(userDir, false);
-}
-
-export async function getStrategyEntry(idOrName: string): Promise<StrategyEntry | undefined> {
-  await ensureLoaded();
-  const byId = strategyMap.get(idOrName);
-  if (byId) return byId;
-  // Fall back to the Chinese display name (StrategyEntry.name). id always wins,
-  // so this only resolves an alias when no id matched.
-  for (const entry of strategyMap.values()) {
-    if (entry.name === idOrName) return entry;
-  }
-  return undefined;
-}
-
-export async function listStrategyEntries(): Promise<StrategyEntry[]> {
-  await ensureLoaded();
-  return [...strategyMap.values()];
-}
-
-export async function getStrategyKnowledgeDoc(id: string): Promise<string | undefined> {
-  await ensureLoaded();
-  const path = knowledgeDocMap.get(id);
-  if (!path || !existsSync(path)) return undefined;
-  try {
-    return readFileSync(path, 'utf8');
-  } catch {
-    return undefined;
-  }
-}
-
-export async function resolveStrategy(id: string, args?: string[]): Promise<Strategy> {
-  const entry = await getStrategyEntry(id);
-  if (!entry) throw new Error(`Unknown strategy '${id}'. Use 'strategy list' to see available strategies.`);
-  return entry.create(args);
-}
-
-/** Reset and re-scan — call after a new strategy file is placed, so the next list/get picks it up. */
-export async function reload(): Promise<void> {
-  loaded = false;
-  strategyMap.clear();
-  knowledgeDocMap.clear();
-  await ensureLoaded();
-}
+import { existsSync, readdirSync, readFileSync, realpathSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { dirname, join, resolve, basename } from 'path';
+import { tmpdir } from 'os';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { getWorkspaceDir } from '../lib/init-command.js';
+import type { Plugin, OnResolveArgs } from 'esbuild';
+import type { Strategy, StrategyEntry } from './types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve SDK path for user strategy imports (raw filesystem path, not URL).
+// realpathSync ensures dedup against built-in strategies even under --preserve-symlinks.
+const SDK_PATH = realpathSync(resolve(__dirname, '../sdk/index.ts'));
+
+const strategyMap = new Map<string, StrategyEntry>();
+const knowledgeDocMap = new Map<string, string>();
+let loaded = false;
+
+const INFRA_FILES = new Set(['loader', 'types', 'game-utils', 'player-targets', 'greeting', 'spawn', 'strategy-loop', 'new-events-backfill']);
+
+function resolveUserStrategiesDir(): string | undefined {
+  const workspaceDir = getWorkspaceDir();
+  if (!existsSync(workspaceDir)) return undefined;
+  const strategiesDir = join(workspaceDir, 'strategies');
+  if (!existsSync(strategiesDir)) return undefined;
+  return strategiesDir;
+}
+
+/**
+ * Create an esbuild plugin that intercepts `@myclaw163/clawclaw-cli` and
+ * `@myclaw163/clawclaw-cli/*` imports (and the legacy bare `clawclaw-cli`
+ * name for backward compat) and redirects them to the local SDK path
+ * (marked external so Node resolves the same module instance at runtime).
+ *
+ * `require()` calls fail the build with a clear error, since `require` is
+ * unavailable in ESM output and would otherwise crash at runtime.
+ */
+function createSdkPlugin(): { plugin: Plugin } {
+  const sdkUrl = pathToFileURL(SDK_PATH).href;
+
+  const plugin: Plugin = {
+    name: 'clawclaw-cli-sdk',
+    setup(build) {
+      build.onResolve({ filter: /^(?:@myclaw163\/)?clawclaw-cli(?:\/.*)?$/ }, (args: OnResolveArgs) => {
+        if (args.kind === 'require-call') {
+          return {
+            errors: [{
+              text: `require('${args.path}') is not supported in user strategies. Use static imports: import { ... } from '${args.path}'.`,
+            }],
+          };
+        }
+        return { path: sdkUrl, external: true };
+      });
+    },
+  };
+
+  return { plugin };
+}
+
+// Returns Record<string, unknown> — slightly less precise than native import()'s
+// Module type, but both are cast to StrategyEntry via `as` in loadFromDir.
+export async function importUserFile(filePath: string): Promise<Record<string, unknown>> {
+  const { plugin } = createSdkPlugin();
+  const { build } = await import('esbuild');
+  const result = await build({
+    stdin: {
+      contents: readFileSync(filePath, 'utf8'),
+      resolveDir: dirname(filePath),
+      sourcefile: basename(filePath),
+      loader: filePath.endsWith('.ts') ? 'ts' : 'js',
+    },
+    bundle: true,
+    format: 'esm',
+    write: false,
+    platform: 'node',
+    packages: 'external',
+    plugins: [plugin],
+  });
+
+  // Write to temporary file so Node's module cache deduplicates the SDK —
+  // data URLs load as separate module instances, breaking instanceof checks.
+  const tmpDir = mkdtempSync(join(tmpdir(), 'ccl-strategy-'));
+  const tmpFile = join(tmpDir, basename(filePath).replace(/\.(ts|js)$/, '.mjs'));
+  try {
+    writeFileSync(tmpFile, result.outputFiles[0].text);
+    return await import(pathToFileURL(tmpFile).href);
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+async function loadFromDir(dir: string, skipInfra: boolean): Promise<void> {
+  let files: string[];
+  try {
+    files = readdirSync(dir).filter(f => {
+      if (f.startsWith('_')) return false;
+      const match = f.match(/^(.+)\.(ts|js)$/);
+      if (!match) return false;
+      if (match[1].endsWith('.d')) return false;
+      if (match[1].endsWith('.test')) return false;
+      return !skipInfra || !INFRA_FILES.has(match[1]);
+    });
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    try {
+      const filePath = realpathSync(join(dir, file));
+      const mod = skipInfra
+        ? await import(pathToFileURL(filePath).href)
+        : await importUserFile(filePath);
+      const entry: StrategyEntry | undefined = mod.strategy as StrategyEntry | undefined;
+      if (entry?.id && typeof entry.description === 'string' && typeof entry.create === 'function') {
+        strategyMap.set(entry.id, entry);
+        const sidecar = filePath.replace(/\.(ts|js)$/, '.knowledge.md');
+        if (existsSync(sidecar)) knowledgeDocMap.set(entry.id, sidecar);
+      }
+    } catch (err) {
+      if (!skipInfra) {
+        // Strip temp-dir paths from error messages — they leak internal
+        // implementation details (e.g., /tmp/ccl-strategy-XXXX/strategy.mjs)
+        const raw = err instanceof Error ? err.message : String(err);
+        const cleaned = raw.replace(/\S*ccl-strategy-[^/]*\//g, '');
+        console.error(`[ccl] Failed to load user strategy ${file}: ${cleaned}`);
+      }
+    }
+  }
+}
+
+async function ensureLoaded(): Promise<void> {
+  if (loaded) return;
+  loaded = true;
+  await loadFromDir(__dirname, true);
+  const userDir = resolveUserStrategiesDir();
+  if (userDir) await loadFromDir(userDir, false);
+}
+
+export async function getStrategyEntry(idOrName: string): Promise<StrategyEntry | undefined> {
+  await ensureLoaded();
+  const byId = strategyMap.get(idOrName);
+  if (byId) return byId;
+  // Fall back to the Chinese display name (StrategyEntry.name). id always wins,
+  // so this only resolves an alias when no id matched.
+  for (const entry of strategyMap.values()) {
+    if (entry.name === idOrName) return entry;
+  }
+  return undefined;
+}
+
+export async function listStrategyEntries(): Promise<StrategyEntry[]> {
+  await ensureLoaded();
+  return [...strategyMap.values()];
+}
+
+export async function getStrategyKnowledgeDoc(id: string): Promise<string | undefined> {
+  await ensureLoaded();
+  const path = knowledgeDocMap.get(id);
+  if (!path || !existsSync(path)) return undefined;
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return undefined;
+  }
+}
+
+export async function resolveStrategy(id: string, args?: string[]): Promise<Strategy> {
+  const entry = await getStrategyEntry(id);
+  if (!entry) throw new Error(`Unknown strategy '${id}'. Use 'strategy list' to see available strategies.`);
+  return entry.create(args);
+}
+
+/** Reset and re-scan — call after a new strategy file is placed, so the next list/get picks it up. */
+export async function reload(): Promise<void> {
+  loaded = false;
+  strategyMap.clear();
+  knowledgeDocMap.clear();
+  await ensureLoaded();
+}

package/src/strategies/lone-kill-task.ts

@@ -1,22 +1,22 @@
-import type { StrategyEntry } from './types.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { LoneKillTaskTop } from './goals/lone-kill-task-top.js';
-import { ConversationGoal } from './goals/conversation-goal.js';
-import { SpeechModule, getSpeechConfigForRole } from './speech-module.js';
-
-export const strategy: StrategyEntry = {
-  id: 'lone-kill-task',
-  name: '潜伏猎手',
-  description: '视野里只有一个非队友且冷却可用就靠近，进入50距离就立刻出刀；刀在冷却时不追不等、改做低优先级任务伪装，冷却好且目标仍落单可见再出刀（贴脸且刀好仍会立刻出刀）。发现尸体且附近有非队友、但当前不能原地出刀时，会靠近并报告尸体。视野里出现两人以上时，暂停攻击10秒并做任意阵营的真实任务伪装；选任务时会跳过紧挨已知尸体（含看见过、已离开视野的）的任务，不在命案现场做任务。没有可做任务时按房间巡逻，绝不停在原地。残局（已知存活≤6）出现紧急维修任务时，会高优先级抢着去做（仍低于击杀落单），阻止蟹靠破坏倒计时取胜。（章鱼默认）',
-  create(args?: string[]) {
-    const role = args?.[0] ?? 'neutral_octopus';
-    let convo: ConversationGoal | null = null;
-    return new GoalRootStrategy('lone-kill-task', () => {
-      convo = new ConversationGoal(() => new LoneKillTaskTop(), new SpeechModule(getSpeechConfigForRole(role)));
-      return convo;
-    }, {
-      resetOnMeetingResume: false,
-      onUpdateRole: role => convo?.updateConfig(role),
-    });
-  },
-};
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { LoneKillTaskTop } from './goals/lone-kill-task-top.js';
+import { ConversationGoal } from './goals/conversation-goal.js';
+import { SpeechModule, getSpeechConfigForRole } from './speech-module.js';
+
+export const strategy: StrategyEntry = {
+  id: 'lone-kill-task',
+  name: '潜伏猎手',
+  description: '视野里只有一个非队友且冷却可用就靠近，进入50距离就立刻出刀；刀在冷却时不追不等、改做低优先级任务伪装，冷却好且目标仍落单可见再出刀（贴脸且刀好仍会立刻出刀）。发现尸体且附近有非队友、但当前不能原地出刀时，会靠近并报告尸体。视野里出现两人以上时，暂停攻击10秒并做任意阵营的真实任务伪装；选任务时会跳过紧挨已知尸体（含看见过、已离开视野的）的任务，不在命案现场做任务。没有可做任务时按房间巡逻，绝不停在原地。残局（已知存活≤6）出现紧急维修任务时，会高优先级抢着去做（仍低于击杀落单），阻止蟹靠破坏倒计时取胜。（章鱼默认）',
+  create(args?: string[]) {
+    const role = args?.[0] ?? 'neutral_octopus';
+    let convo: ConversationGoal | null = null;
+    return new GoalRootStrategy('lone-kill-task', () => {
+      convo = new ConversationGoal(() => new LoneKillTaskTop(), new SpeechModule(getSpeechConfigForRole(role)));
+      return convo;
+    }, {
+      resetOnMeetingResume: false,
+      onUpdateRole: role => convo?.updateConfig(role),
+    });
+  },
+};

package/src/strategies/meeting-gate.test.ts

@@ -1,59 +1,59 @@
-import { describe, expect, it } from 'vitest';
-import {
-  meetingEndedInEvents,
-  meetingStartedInEvents,
-  shouldPauseForMeeting,
-} from './meeting-gate.js';
-import type { GameState } from '../sdk/types.js';
-
-function baseState(overrides: Partial<GameState> = {}): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'me',
-      x: 0,
-      y: 0,
-      room: '酒吧',
-      role: 'crab_generic',
-      faction: 'crab',
-      is_alive: true,
-    },
-    your_tasks: [],
-    players: [],
-    corpses: [],
-    stale: false,
-    ...overrides,
-  };
-}
-
-describe('meeting-gate', () => {
-  it('detects meeting end events', () => {
-    expect(meetingEndedInEvents([{ type: 'meeting_ended' }])).toBe(true);
-    expect(meetingEndedInEvents([{ type: 'meeting_result_pending' }])).toBe(true);
-    expect(meetingEndedInEvents([{ type: 'speech' }])).toBe(false);
-  });
-
-  it('keeps pausing during meeting until end events arrive', () => {
-    const during = baseState({ phase: 'meeting', new_events: [{ type: 'speech' }] });
-    expect(shouldPauseForMeeting(during)).toBe(true);
-
-    const ending = baseState({ phase: 'meeting', new_events: [{ type: 'meeting_ended' }] });
-    expect(shouldPauseForMeeting(ending)).toBe(false);
-
-    const wandering = baseState({ phase: 'wandering' });
-    expect(shouldPauseForMeeting(wandering)).toBe(false);
-  });
-
-  it('does not re-pause after releasedEarly while HTTP phase still meeting', () => {
-    const lingering = baseState({ phase: 'meeting', new_events: [] });
-    expect(shouldPauseForMeeting(lingering, true)).toBe(false);
-    expect(shouldPauseForMeeting(lingering, false)).toBe(true);
-  });
-
-  it('detects meeting start events for cycle reset', () => {
-    expect(meetingStartedInEvents([{ type: 'meeting_start' }])).toBe(true);
-    expect(meetingStartedInEvents([{ type: 'meeting_started' }])).toBe(true);
-    expect(meetingStartedInEvents([{ type: 'speech' }])).toBe(false);
-  });
-});
+import { describe, expect, it } from 'vitest';
+import {
+  meetingEndedInEvents,
+  meetingStartedInEvents,
+  shouldPauseForMeeting,
+} from './meeting-gate.js';
+import type { GameState } from '../sdk/types.js';
+
+function baseState(overrides: Partial<GameState> = {}): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'me',
+      x: 0,
+      y: 0,
+      room: '酒吧',
+      role: 'crab_generic',
+      faction: 'crab',
+      is_alive: true,
+    },
+    your_tasks: [],
+    players: [],
+    corpses: [],
+    stale: false,
+    ...overrides,
+  };
+}
+
+describe('meeting-gate', () => {
+  it('detects meeting end events', () => {
+    expect(meetingEndedInEvents([{ type: 'meeting_ended' }])).toBe(true);
+    expect(meetingEndedInEvents([{ type: 'meeting_result_pending' }])).toBe(true);
+    expect(meetingEndedInEvents([{ type: 'speech' }])).toBe(false);
+  });
+
+  it('keeps pausing during meeting until end events arrive', () => {
+    const during = baseState({ phase: 'meeting', new_events: [{ type: 'speech' }] });
+    expect(shouldPauseForMeeting(during)).toBe(true);
+
+    const ending = baseState({ phase: 'meeting', new_events: [{ type: 'meeting_ended' }] });
+    expect(shouldPauseForMeeting(ending)).toBe(false);
+
+    const wandering = baseState({ phase: 'wandering' });
+    expect(shouldPauseForMeeting(wandering)).toBe(false);
+  });
+
+  it('does not re-pause after releasedEarly while HTTP phase still meeting', () => {
+    const lingering = baseState({ phase: 'meeting', new_events: [] });
+    expect(shouldPauseForMeeting(lingering, true)).toBe(false);
+    expect(shouldPauseForMeeting(lingering, false)).toBe(true);
+  });
+
+  it('detects meeting start events for cycle reset', () => {
+    expect(meetingStartedInEvents([{ type: 'meeting_start' }])).toBe(true);
+    expect(meetingStartedInEvents([{ type: 'meeting_started' }])).toBe(true);
+    expect(meetingStartedInEvents([{ type: 'speech' }])).toBe(false);
+  });
+});

package/src/strategies/meeting-gate.ts

@@ -1,23 +1,23 @@
-import type { GameState } from '../sdk/types.js';
-
-const MEETING_END_EVENT_TYPES = new Set(['meeting_ended', 'meeting_result_pending']);
-const MEETING_START_EVENT_TYPES = new Set(['meeting_start', 'meeting_started']);
-
-export function meetingEndedInEvents(events: any[] | undefined): boolean {
-  return (events ?? []).some((e) => MEETING_END_EVENT_TYPES.has(e.type));
-}
-
-export function meetingStartedInEvents(events: any[] | undefined): boolean {
-  return (events ?? []).some((e) => MEETING_START_EVENT_TYPES.has(e.type));
-}
-
-/**
- * Keep pausing while HTTP phase is still `meeting`.
- * `releasedEarly` is set after we have seen meeting end once — avoids re-pausing
- * on later polls where phase lags but `new_events` no longer repeats `meeting_ended`.
- */
-export function shouldPauseForMeeting(state: GameState, releasedEarly = false): boolean {
-  if (state.phase !== 'meeting') return false;
-  if (releasedEarly) return false;
-  return !meetingEndedInEvents(state.new_events);
-}
+import type { GameState } from '../sdk/types.js';
+
+const MEETING_END_EVENT_TYPES = new Set(['meeting_ended', 'meeting_result_pending']);
+const MEETING_START_EVENT_TYPES = new Set(['meeting_start', 'meeting_started']);
+
+export function meetingEndedInEvents(events: any[] | undefined): boolean {
+  return (events ?? []).some((e) => MEETING_END_EVENT_TYPES.has(e.type));
+}
+
+export function meetingStartedInEvents(events: any[] | undefined): boolean {
+  return (events ?? []).some((e) => MEETING_START_EVENT_TYPES.has(e.type));
+}
+
+/**
+ * Keep pausing while HTTP phase is still `meeting`.
+ * `releasedEarly` is set after we have seen meeting end once — avoids re-pausing
+ * on later polls where phase lags but `new_events` no longer repeats `meeting_ended`.
+ */
+export function shouldPauseForMeeting(state: GameState, releasedEarly = false): boolean {
+  if (state.phase !== 'meeting') return false;
+  if (releasedEarly) return false;
+  return !meetingEndedInEvents(state.new_events);
+}

package/src/strategies/move-room.ts

@@ -1,16 +1,16 @@
-import type { StrategyEntry } from './types.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { MoveRoomGoal } from './goals/move-room-goal.js';
-
-export const strategy: StrategyEntry = {
-  id: 'move-room',
-  name: '前往',
-  description: '前往指定房间，到达后停下。参数为目标房间名（如 酒吧）。单纯走位，不做任务、不打人、不报告。',
-  create(args?: string[]) {
-    const targetRoom = args?.join(' ').trim() ?? '';
-    if (!targetRoom) {
-      throw new Error('move-room strategy requires a room name. Example: move-room 酒吧');
-    }
-    return new GoalRootStrategy('move-room', () => new MoveRoomGoal(targetRoom));
-  },
-};
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { MoveRoomGoal } from './goals/move-room-goal.js';
+
+export const strategy: StrategyEntry = {
+  id: 'move-room',
+  name: '前往',
+  description: '前往指定房间，到达后停下。参数为目标房间名（如 酒吧）。单纯走位，不做任务、不打人、不报告。',
+  create(args?: string[]) {
+    const targetRoom = args?.join(' ').trim() ?? '';
+    if (!targetRoom) {
+      throw new Error('move-room strategy requires a room name. Example: move-room 酒吧');
+    }
+    return new GoalRootStrategy('move-room', () => new MoveRoomGoal(targetRoom));
+  },
+};