@myclaw163/clawclaw-cli 0.6.76 → 0.6.77

package/src/commands/knowledge.ts

@@ -1,139 +1,139 @@
-import { Command } from 'commander';
-import { DROPPED_PLAYER_MARK_TAGS, KnowledgeStore, type KnowledgeSetInput, type PlayerMark } from '../lib/knowledge-store.js';
-
-// 玩家只标两档：hostile（坏人）/ trusted（好人）。未标记的默认「被怀疑」，无需也无法显式标。
-const PLAYER_MARKS = new Set<PlayerMark>(['hostile', 'trusted']);
-const LEGACY_MARK_TAGS = ['kill_if_armed', 'cleared', 'protected', 'do_not_kill'];
-
-export function normalizePlayerMark(mark?: string): PlayerMark | null {
-  const normalized = mark?.trim().toLowerCase() as PlayerMark | undefined;
-  return normalized && PLAYER_MARKS.has(normalized) ? normalized : null;
-}
-
-/** "true"/"false"/数字 自动转类型，其余按字符串。 */
-function coerceValue(raw: string | undefined): unknown {
-  if (raw == null) return true;
-  if (raw === 'true') return true;
-  if (raw === 'false') return false;
-  if (raw !== '' && !Number.isNaN(Number(raw))) return Number(raw);
-  return raw;
-}
-
-function collectTag(value: string, prev: string[]): string[] {
-  return [...prev, value];
-}
-
-function print(data: unknown): void {
-  console.log(JSON.stringify(data, null, 2));
-}
-
-function fail(error: string, message: string): never {
-  console.error(JSON.stringify({ error, message }, null, 2));
-  process.exit(1);
-}
-
-function setPlayerMark(store: KnowledgeStore, player: string, mark: PlayerMark, opts: { note?: string }) {
-  const removeTags = [
-    ...[...PLAYER_MARKS].filter(candidate => candidate !== mark),
-    ...LEGACY_MARK_TAGS,
-    ...DROPPED_PLAYER_MARK_TAGS, // 顺手清掉旧数据残留的 suspect/avoid raw tag，别再从 get/subject() 漏出去
-  ];
-  return store.set({
-    type: 'player',
-    selector: player,
-    tags: [mark],
-    removeTags,
-    note: opts.note,
-  });
-}
-
-export function createKnowledgeCommand(): Command {
-  const cmd = new Command('knowledge')
-    .alias('kn')
-    .description('Per-game structured knowledge that a running strategy can query (no restart needed)');
-
-  cmd
-    .command('set [type] [selector] [key] [value]', { hidden: true })
-    .description('Advanced: upsert arbitrary facts/tags. Use `knowledge mark` for player strategy behavior.')
-    .option('--tag <tag>', 'Custom tag, repeatable', collectTag, [])
-    .option('--note <text>', 'Free-text reason')
-    .option('--json <json>', 'Provide the whole input object as JSON instead of positional args')
-    .action((type: string | undefined, selector: string | undefined, key: string | undefined, value: string | undefined, opts: {
-      tag: string[]; note?: string; json?: string;
-    }) => {
-      try {
-        const store = KnowledgeStore.forActiveAccount();
-        let input: KnowledgeSetInput;
-        if (opts.json) {
-          input = JSON.parse(opts.json) as KnowledgeSetInput;
-        } else {
-          if (!type || !selector) {
-            fail('missing_args', 'Usage: ccl knowledge set <type> <selector> [key] [value] [--tag ...]  —  or:  ccl knowledge set --json "{...}"');
-          }
-          input = {
-            type,
-            selector,
-            key,
-            value: key != null ? coerceValue(value) : undefined,
-            tags: opts.tag.length > 0 ? opts.tag : undefined,
-            note: opts.note,
-          };
-        }
-        const entry = store.set(input);
-        print({ ok: true, gameId: store.gameId ?? null, subject: entry });
-      } catch (e) {
-        fail('knowledge_set_failed', e instanceof Error ? e.message : String(e));
-      }
-    });
-
-  cmd
-    .command('mark <player> <mark>')
-    .description('Set the strategy mark for a player: hostile | trusted (unmarked players are suspected by default)')
-    .option('--note <text>', 'Free-text reason')
-    .action((player: string, rawMark: string, opts: { note?: string }) => {
-      const mark = normalizePlayerMark(rawMark);
-      if (!mark) fail('invalid_mark', `Unknown mark '${rawMark}'. Use: hostile | trusted. (Unmarked = suspected by default.)`);
-      try {
-        const store = KnowledgeStore.forActiveAccount();
-        const entry = setPlayerMark(store, player, mark, opts);
-        print({ ok: true, gameId: store.gameId ?? null, mark, subject: entry });
-      } catch (e) {
-        fail('knowledge_mark_failed', e instanceof Error ? e.message : String(e));
-      }
-    });
-
-  cmd
-    .command('get [type] [selector]')
-    .description('Read knowledge: all, all of a type, or one subject')
-    .action((type: string | undefined, selector: string | undefined) => {
-      const store = KnowledgeStore.forActiveAccount();
-      const file = store.list();
-      if (type && selector) {
-        print({ gameId: file.gameId ?? null, subject: file.subjects[`${type}:${selector}`] ?? null });
-        return;
-      }
-      const subjects = Object.values(file.subjects).filter((s) => !type || s.type === type);
-      print({ gameId: file.gameId ?? null, count: subjects.length, subjects });
-    });
-
-  cmd
-    .command('del <type> <selector> [key]')
-    .description('Delete a subject, or just one fact (key) / tag (--tag)')
-    .option('--tag <tag>', 'Delete only this tag')
-    .action((type: string, selector: string, key: string | undefined, opts: { tag?: string }) => {
-      const store = KnowledgeStore.forActiveAccount();
-      const removed = store.del(type, selector, { key, tag: opts.tag });
-      print({ ok: removed, gameId: store.gameId ?? null });
-    });
-
-  cmd
-    .command('clear')
-    .description('Clear all knowledge for the current game')
-    .action(() => {
-      const store = KnowledgeStore.forActiveAccount();
-      store.clear();
-      print({ ok: true, gameId: store.gameId ?? null });
-    });
-
-  return cmd;
-}
+import { Command } from 'commander';
+import { DROPPED_PLAYER_MARK_TAGS, KnowledgeStore, type KnowledgeSetInput, type PlayerMark } from '../lib/knowledge-store.js';
+
+// 玩家只标两档：hostile（坏人）/ trusted（好人）。未标记的默认「被怀疑」，无需也无法显式标。
+const PLAYER_MARKS = new Set<PlayerMark>(['hostile', 'trusted']);
+const LEGACY_MARK_TAGS = ['kill_if_armed', 'cleared', 'protected', 'do_not_kill'];
+
+export function normalizePlayerMark(mark?: string): PlayerMark | null {
+  const normalized = mark?.trim().toLowerCase() as PlayerMark | undefined;
+  return normalized && PLAYER_MARKS.has(normalized) ? normalized : null;
+}
+
+/** "true"/"false"/数字 自动转类型，其余按字符串。 */
+function coerceValue(raw: string | undefined): unknown {
+  if (raw == null) return true;
+  if (raw === 'true') return true;
+  if (raw === 'false') return false;
+  if (raw !== '' && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+
+function collectTag(value: string, prev: string[]): string[] {
+  return [...prev, value];
+}
+
+function print(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function fail(error: string, message: string): never {
+  console.error(JSON.stringify({ error, message }, null, 2));
+  process.exit(1);
+}
+
+function setPlayerMark(store: KnowledgeStore, player: string, mark: PlayerMark, opts: { note?: string }) {
+  const removeTags = [
+    ...[...PLAYER_MARKS].filter(candidate => candidate !== mark),
+    ...LEGACY_MARK_TAGS,
+    ...DROPPED_PLAYER_MARK_TAGS, // 顺手清掉旧数据残留的 suspect/avoid raw tag，别再从 get/subject() 漏出去
+  ];
+  return store.set({
+    type: 'player',
+    selector: player,
+    tags: [mark],
+    removeTags,
+    note: opts.note,
+  });
+}
+
+export function createKnowledgeCommand(): Command {
+  const cmd = new Command('knowledge')
+    .alias('kn')
+    .description('Per-game structured knowledge that a running strategy can query (no restart needed)');
+
+  cmd
+    .command('set [type] [selector] [key] [value]', { hidden: true })
+    .description('Advanced: upsert arbitrary facts/tags. Use `knowledge mark` for player strategy behavior.')
+    .option('--tag <tag>', 'Custom tag, repeatable', collectTag, [])
+    .option('--note <text>', 'Free-text reason')
+    .option('--json <json>', 'Provide the whole input object as JSON instead of positional args')
+    .action((type: string | undefined, selector: string | undefined, key: string | undefined, value: string | undefined, opts: {
+      tag: string[]; note?: string; json?: string;
+    }) => {
+      try {
+        const store = KnowledgeStore.forActiveAccount();
+        let input: KnowledgeSetInput;
+        if (opts.json) {
+          input = JSON.parse(opts.json) as KnowledgeSetInput;
+        } else {
+          if (!type || !selector) {
+            fail('missing_args', 'Usage: ccl knowledge set <type> <selector> [key] [value] [--tag ...]  —  or:  ccl knowledge set --json "{...}"');
+          }
+          input = {
+            type,
+            selector,
+            key,
+            value: key != null ? coerceValue(value) : undefined,
+            tags: opts.tag.length > 0 ? opts.tag : undefined,
+            note: opts.note,
+          };
+        }
+        const entry = store.set(input);
+        print({ ok: true, gameId: store.gameId ?? null, subject: entry });
+      } catch (e) {
+        fail('knowledge_set_failed', e instanceof Error ? e.message : String(e));
+      }
+    });
+
+  cmd
+    .command('mark <player> <mark>')
+    .description('Set the strategy mark for a player: hostile | trusted (unmarked players are suspected by default)')
+    .option('--note <text>', 'Free-text reason')
+    .action((player: string, rawMark: string, opts: { note?: string }) => {
+      const mark = normalizePlayerMark(rawMark);
+      if (!mark) fail('invalid_mark', `Unknown mark '${rawMark}'. Use: hostile | trusted. (Unmarked = suspected by default.)`);
+      try {
+        const store = KnowledgeStore.forActiveAccount();
+        const entry = setPlayerMark(store, player, mark, opts);
+        print({ ok: true, gameId: store.gameId ?? null, mark, subject: entry });
+      } catch (e) {
+        fail('knowledge_mark_failed', e instanceof Error ? e.message : String(e));
+      }
+    });
+
+  cmd
+    .command('get [type] [selector]')
+    .description('Read knowledge: all, all of a type, or one subject')
+    .action((type: string | undefined, selector: string | undefined) => {
+      const store = KnowledgeStore.forActiveAccount();
+      const file = store.list();
+      if (type && selector) {
+        print({ gameId: file.gameId ?? null, subject: file.subjects[`${type}:${selector}`] ?? null });
+        return;
+      }
+      const subjects = Object.values(file.subjects).filter((s) => !type || s.type === type);
+      print({ gameId: file.gameId ?? null, count: subjects.length, subjects });
+    });
+
+  cmd
+    .command('del <type> <selector> [key]')
+    .description('Delete a subject, or just one fact (key) / tag (--tag)')
+    .option('--tag <tag>', 'Delete only this tag')
+    .action((type: string, selector: string, key: string | undefined, opts: { tag?: string }) => {
+      const store = KnowledgeStore.forActiveAccount();
+      const removed = store.del(type, selector, { key, tag: opts.tag });
+      print({ ok: removed, gameId: store.gameId ?? null });
+    });
+
+  cmd
+    .command('clear')
+    .description('Clear all knowledge for the current game')
+    .action(() => {
+      const store = KnowledgeStore.forActiveAccount();
+      store.clear();
+      print({ ok: true, gameId: store.gameId ?? null });
+    });
+
+  return cmd;
+}

package/src/commands/load.test.ts

@@ -1,51 +1,51 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('../lib/load-context.js', () => ({
-  loadContext: vi.fn(() => ({ persona: { exists: true }, memory: { exists: false } })),
-}));
-
-vi.mock('../runtime/auto-upgrade.js', () => ({
-  runAutoUpgradeOnLoad: vi.fn(),
-}));
-
-import { runAutoUpgradeOnLoad } from '../runtime/auto-upgrade.js';
-import { createLoadCommand } from './load.js';
-
-describe('load command', () => {
-  let logSpy: ReturnType<typeof vi.spyOn>;
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.mocked(runAutoUpgradeOnLoad).mockClear();
-    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-  });
-
-  it('runs auto-upgrade check before printing JSON load context', async () => {
-    const cmd = createLoadCommand();
-    await cmd.parseAsync(['node', 'load'], { from: 'node' });
-
-    expect(runAutoUpgradeOnLoad).toHaveBeenCalledOnce();
-    expect(logSpy).toHaveBeenCalledOnce();
-    expect(JSON.parse(String(logSpy.mock.calls[0][0]))).toEqual({
-      persona: { exists: true },
-      memory: { exists: false },
-    });
-  });
-
-  it('routes auto-upgrade notifications to stderr', async () => {
-    vi.mocked(runAutoUpgradeOnLoad).mockImplementation(({ notify }: any) => {
-      notify('[clawclaw-cli] auto-upgrade installed 0.6.39');
-    });
-
-    const cmd = createLoadCommand();
-    await cmd.parseAsync(['node', 'load'], { from: 'node' });
-
-    expect(errorSpy).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade installed 0.6.39');
-  });
-});
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../lib/load-context.js', () => ({
+  loadContext: vi.fn(() => ({ persona: { exists: true }, memory: { exists: false } })),
+}));
+
+vi.mock('../runtime/auto-upgrade.js', () => ({
+  runAutoUpgradeOnLoad: vi.fn(),
+}));
+
+import { runAutoUpgradeOnLoad } from '../runtime/auto-upgrade.js';
+import { createLoadCommand } from './load.js';
+
+describe('load command', () => {
+  let logSpy: ReturnType<typeof vi.spyOn>;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.mocked(runAutoUpgradeOnLoad).mockClear();
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it('runs auto-upgrade check before printing JSON load context', async () => {
+    const cmd = createLoadCommand();
+    await cmd.parseAsync(['node', 'load'], { from: 'node' });
+
+    expect(runAutoUpgradeOnLoad).toHaveBeenCalledOnce();
+    expect(logSpy).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(logSpy.mock.calls[0][0]))).toEqual({
+      persona: { exists: true },
+      memory: { exists: false },
+    });
+  });
+
+  it('routes auto-upgrade notifications to stderr', async () => {
+    vi.mocked(runAutoUpgradeOnLoad).mockImplementation(({ notify }: any) => {
+      notify('[clawclaw-cli] auto-upgrade installed 0.6.39');
+    });
+
+    const cmd = createLoadCommand();
+    await cmd.parseAsync(['node', 'load'], { from: 'node' });
+
+    expect(errorSpy).toHaveBeenCalledWith('[clawclaw-cli] auto-upgrade installed 0.6.39');
+  });
+});

package/src/commands/load.ts

@@ -1,13 +1,13 @@
-import { Command } from 'commander';
-import { loadContext } from '../lib/load-context.js';
-import { runAutoUpgradeOnLoad } from '../runtime/auto-upgrade.js';
-
-export function createLoadCommand(): Command {
-  return new Command('load')
-    .description('Read active account persona and memory files')
-    .action(() => {
-      runAutoUpgradeOnLoad({ notify: (message) => console.error(message) });
-      const snapshot = loadContext();
-      console.log(JSON.stringify(snapshot, null, 2));
-    });
-}
+import { Command } from 'commander';
+import { loadContext } from '../lib/load-context.js';
+import { runAutoUpgradeOnLoad } from '../runtime/auto-upgrade.js';
+
+export function createLoadCommand(): Command {
+  return new Command('load')
+    .description('Read active account persona and memory files')
+    .action(() => {
+      runAutoUpgradeOnLoad({ notify: (message) => console.error(message) });
+      const snapshot = loadContext();
+      console.log(JSON.stringify(snapshot, null, 2));
+    });
+}

package/src/commands/meeting-history.test.ts

@@ -1,106 +1,106 @@
-import { describe, expect, it } from 'vitest';
-import { meetingHistoryCommandInternals } from './history.js';
-
-const allSeats = [
-  { name: 'A', seat: 1 },
-  { name: 'B', seat: 2 },
-  { name: 'C', seat: 3 },
-];
-
-describe('meeting history builder', () => {
-  it('outputs the compact meeting shape with found-in-meeting deaths and ordered speeches', () => {
-    const records = meetingHistoryCommandInternals.buildMeetingRecords([
-      { type: 'meeting_start', tick: 10, actor_name: 'A' },
-      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
-      {
-        type: 'meeting_state',
-        round: 1,
-        tick: 10,
-        sub_phase: 'entry',
-        speech_order: ['A', 'B'],
-        alive_players: ['A', 'B'],
-      },
-      {
-        type: 'meeting_state',
-        round: 1,
-        tick: 20,
-        sub_phase: 'vote',
-        speech_order: ['A', 'B'],
-        speeches: { B: '我没问题', A: '' },
-        speech_skipped: ['A'],
-        votes_submitted: ['A'],
-        alive_players: ['A', 'B'],
-      },
-      { type: 'no_exile', tick: 30, votes: { A: 'skip', B: 'skip' } },
-      { type: 'meeting_ended', tick: 31, result: 'skip', result_target: null },
-    ]);
-    const [meeting] = meetingHistoryCommandInternals.allMeetingOutputs(records);
-    expect(Object.keys(meeting)).toEqual([
-      'round',
-      'tick',
-      'caller',
-      'corpses_found',
-      'state',
-      'exiled_player',
-      'players',
-      'votes',
-      'speeches',
-    ]);
-    expect(meeting.corpses_found).toBeNull();
-    expect(meeting.state).toBe('ended');
-    expect(meeting.players).toEqual([
-      { name: 'A', seat: 1, status: 'alive', death: null },
-      { name: 'B', seat: 2, status: 'alive', death: null },
-      { name: 'C', seat: 3, status: 'dead', death: { type: 'found_in_meeting', round: 1 } },
-    ]);
-    expect(meeting.votes).toEqual({ A: 'skip', B: 'skip' });
-    expect(meeting.speeches).toEqual([
-      { speaker: 'A', text: '', skipped: true },
-      { speaker: 'B', text: '我没问题', skipped: false },
-    ]);
-  });
-
-  it('marks exiled players and carries death status into later meetings', () => {
-    const records = meetingHistoryCommandInternals.buildMeetingRecords([
-      { type: 'meeting_start', tick: 10, actor_name: 'A' },
-      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
-      { type: 'meeting_state', round: 1, tick: 10, sub_phase: 'vote', alive_players: ['A', 'B', 'C'] },
-      { type: 'exile', tick: 20, actor_name: 'B', votes: { A: 'B', C: 'B' } },
-      { type: 'meeting_ended', tick: 21, result: 'exiled', result_target: 'B' },
-      { type: 'meeting_start', tick: 100, actor_name: 'A' },
-      { type: 'meeting_briefing', tick: 100, all_seats: allSeats },
-      { type: 'meeting_state', round: 2, tick: 100, sub_phase: 'entry', alive_players: ['A', 'C'] },
-    ]);
-    const meetings = meetingHistoryCommandInternals.allMeetingOutputs(records);
-    expect(meetings[0].players.find((player: any) => player.name === 'B')).toEqual({
-      name: 'B',
-      seat: 2,
-      status: 'dead',
-      death: { type: 'exiled', round: 1 },
-    });
-    expect(meetings[1].players.find((player: any) => player.name === 'B')?.death).toEqual({ type: 'exiled', round: 1 });
-  });
-
-  it('keeps current unfinished meeting state from meeting_state', () => {
-    const records = meetingHistoryCommandInternals.buildMeetingRecords([
-      { type: 'meeting_start', tick: 10, actor_name: 'A' },
-      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
-      { type: 'meeting_state', round: 1, tick: 11, sub_phase: 'speech', current_speaker: 'B', alive_players: ['A', 'B', 'C'] },
-    ]);
-    const [meeting] = meetingHistoryCommandInternals.allMeetingOutputs(records);
-    expect(meeting.state).toBe('speech');
-    expect(meeting.speeches).toEqual([]);
-  });
-
-  it('marks an unfinished previous meeting interrupted when a new meeting starts', () => {
-    const records = meetingHistoryCommandInternals.buildMeetingRecords([
-      { type: 'meeting_start', tick: 10, actor_name: 'A' },
-      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
-      { type: 'meeting_start', tick: 100, actor_name: 'C' },
-      { type: 'meeting_briefing', tick: 100, all_seats: allSeats },
-    ]);
-    const meetings = meetingHistoryCommandInternals.allMeetingOutputs(records);
-    expect(meetings[0].state).toBe('interrupted_or_missing_end');
-    expect(meetings[1].state).toBe('interrupted_or_missing_end');
-  });
-});
+import { describe, expect, it } from 'vitest';
+import { meetingHistoryCommandInternals } from './history.js';
+
+const allSeats = [
+  { name: 'A', seat: 1 },
+  { name: 'B', seat: 2 },
+  { name: 'C', seat: 3 },
+];
+
+describe('meeting history builder', () => {
+  it('outputs the compact meeting shape with found-in-meeting deaths and ordered speeches', () => {
+    const records = meetingHistoryCommandInternals.buildMeetingRecords([
+      { type: 'meeting_start', tick: 10, actor_name: 'A' },
+      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
+      {
+        type: 'meeting_state',
+        round: 1,
+        tick: 10,
+        sub_phase: 'entry',
+        speech_order: ['A', 'B'],
+        alive_players: ['A', 'B'],
+      },
+      {
+        type: 'meeting_state',
+        round: 1,
+        tick: 20,
+        sub_phase: 'vote',
+        speech_order: ['A', 'B'],
+        speeches: { B: '我没问题', A: '' },
+        speech_skipped: ['A'],
+        votes_submitted: ['A'],
+        alive_players: ['A', 'B'],
+      },
+      { type: 'no_exile', tick: 30, votes: { A: 'skip', B: 'skip' } },
+      { type: 'meeting_ended', tick: 31, result: 'skip', result_target: null },
+    ]);
+    const [meeting] = meetingHistoryCommandInternals.allMeetingOutputs(records);
+    expect(Object.keys(meeting)).toEqual([
+      'round',
+      'tick',
+      'caller',
+      'corpses_found',
+      'state',
+      'exiled_player',
+      'players',
+      'votes',
+      'speeches',
+    ]);
+    expect(meeting.corpses_found).toBeNull();
+    expect(meeting.state).toBe('ended');
+    expect(meeting.players).toEqual([
+      { name: 'A', seat: 1, status: 'alive', death: null },
+      { name: 'B', seat: 2, status: 'alive', death: null },
+      { name: 'C', seat: 3, status: 'dead', death: { type: 'found_in_meeting', round: 1 } },
+    ]);
+    expect(meeting.votes).toEqual({ A: 'skip', B: 'skip' });
+    expect(meeting.speeches).toEqual([
+      { speaker: 'A', text: '', skipped: true },
+      { speaker: 'B', text: '我没问题', skipped: false },
+    ]);
+  });
+
+  it('marks exiled players and carries death status into later meetings', () => {
+    const records = meetingHistoryCommandInternals.buildMeetingRecords([
+      { type: 'meeting_start', tick: 10, actor_name: 'A' },
+      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
+      { type: 'meeting_state', round: 1, tick: 10, sub_phase: 'vote', alive_players: ['A', 'B', 'C'] },
+      { type: 'exile', tick: 20, actor_name: 'B', votes: { A: 'B', C: 'B' } },
+      { type: 'meeting_ended', tick: 21, result: 'exiled', result_target: 'B' },
+      { type: 'meeting_start', tick: 100, actor_name: 'A' },
+      { type: 'meeting_briefing', tick: 100, all_seats: allSeats },
+      { type: 'meeting_state', round: 2, tick: 100, sub_phase: 'entry', alive_players: ['A', 'C'] },
+    ]);
+    const meetings = meetingHistoryCommandInternals.allMeetingOutputs(records);
+    expect(meetings[0].players.find((player: any) => player.name === 'B')).toEqual({
+      name: 'B',
+      seat: 2,
+      status: 'dead',
+      death: { type: 'exiled', round: 1 },
+    });
+    expect(meetings[1].players.find((player: any) => player.name === 'B')?.death).toEqual({ type: 'exiled', round: 1 });
+  });
+
+  it('keeps current unfinished meeting state from meeting_state', () => {
+    const records = meetingHistoryCommandInternals.buildMeetingRecords([
+      { type: 'meeting_start', tick: 10, actor_name: 'A' },
+      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
+      { type: 'meeting_state', round: 1, tick: 11, sub_phase: 'speech', current_speaker: 'B', alive_players: ['A', 'B', 'C'] },
+    ]);
+    const [meeting] = meetingHistoryCommandInternals.allMeetingOutputs(records);
+    expect(meeting.state).toBe('speech');
+    expect(meeting.speeches).toEqual([]);
+  });
+
+  it('marks an unfinished previous meeting interrupted when a new meeting starts', () => {
+    const records = meetingHistoryCommandInternals.buildMeetingRecords([
+      { type: 'meeting_start', tick: 10, actor_name: 'A' },
+      { type: 'meeting_briefing', tick: 10, all_seats: allSeats },
+      { type: 'meeting_start', tick: 100, actor_name: 'C' },
+      { type: 'meeting_briefing', tick: 100, all_seats: allSeats },
+    ]);
+    const meetings = meetingHistoryCommandInternals.allMeetingOutputs(records);
+    expect(meetings[0].state).toBe('interrupted_or_missing_end');
+    expect(meetings[1].state).toBe('interrupted_or_missing_end');
+  });
+});