@myclaw163/clawclaw-cli 0.6.56 → 0.6.58

package/src/runtime/event-daemon.ts

@@ -1,12 +1,10 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { existsSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { GameClient } from '../lib/game-client.js';
 import { EventStore } from '../pipeline/event-store.js';
 import { getProfileStateDir } from '../lib/init-command.js';
 import { AuthStore } from '../lib/auth.js';
 import { RuntimeLogger } from './runtime-logger.js';
-import { spawnOpeningMover } from './opening-mover.js';
-import { isStrategyRunning as isAutoRunning } from '../strategies/strategy-loop.js';
 import { isCclTestEnabled, rawWsLogPathForSession } from './raw-ws-log.js';
 import { PlayerHistoryStore } from '../perception/player-history-store.js';
 
@@ -14,13 +12,35 @@ const log = new RuntimeLogger();
 
 let feedSerial = 0;
 const MAX_RECENT_EVENTS = 50;
-const recentEvents: Record<string, any>[] = [];
 
-function pushRecentEvent(evt: Record<string, any>): void {
+function isTrue(value: string | undefined): boolean {
+  return typeof value === 'string' && value.trim().toLowerCase() === 'true';
+}
+
+function shouldWriteFeedFile(): boolean {
+  return isCclTestEnabled() || isTrue(process.env.CCL_DEBUG_RUNTIME);
+}
+
+function pushRecentEvent(recentEvents: Record<string, any>[], evt: Record<string, any>): void {
   recentEvents.push(evt);
   if (recentEvents.length > MAX_RECENT_EVENTS) recentEvents.shift();
 }
 
+function cleanObject<T extends Record<string, any>>(obj: T): T {
+  for (const key of Object.keys(obj)) {
+    if (obj[key] === undefined) delete obj[key];
+  }
+  return obj;
+}
+
+function isGameOverState(data: Record<string, any>): boolean {
+  return data.phase === 'game_over';
+}
+
+function isGameOverEvent(data: Record<string, any>): boolean {
+  return data.type === 'game_over';
+}
+
 export function buildMeetingStateProjection(meeting: any): Record<string, any> {
   return {
     caller: meeting?.caller ?? null,
@@ -34,14 +54,16 @@ export function buildMeetingStateProjection(meeting: any): Record<string, any> {
   };
 }
 
-/** Build feed.json consumed by the `ccl game start` stream — tracks phase, current_speaker, urgent conditions. */
+/** Build the in-memory owner snapshot consumed by Monitor and owner-control snapshot requests. */
 function buildFeed(
   youName: string,
   phase: string,
   urgent: Record<string, any>,
   meeting: any,
+  recentEvents: Record<string, any>[],
   you?: Record<string, any>,
   game?: Record<string, any>,
+  automation?: Record<string, any>,
 ): any {
   return {
     ts: new Date().toISOString(),
@@ -51,321 +73,337 @@ function buildFeed(
     game,
     urgent,
     meeting,
+    automation,
     recent_events: recentEvents.slice(-10),
   };
 }
 
-export async function startEventDaemon(authStore?: AuthStore): Promise<void> {
-  const store = authStore ?? new AuthStore();
-  const profile = store.getActive();
-  if (!profile) throw new Error('Not logged in.');
-
-  const events = EventStore.forActiveAccount();
-  const playerHistory = PlayerHistoryStore.forSession(events.path);
-  playerHistory.reset();
-  const stateDir = getProfileStateDir(profile);
-  const cclTest = isCclTestEnabled();
-  const rawWsLogPath = cclTest ? rawWsLogPathForSession(events.path) : undefined;
-  const client = GameClient.fromAuth({ ws: true, authStore: store, rawWsLogPath });
-  const controlPath = join(stateDir, 'control.json');
-  const runtimePath = join(stateDir, 'runtime.json');
-  const feedPath = join(stateDir, 'feed.json');
-
-  let currentPhase = 'lobby';
-  if (existsSync(join(stateDir, 'match-state.json'))) {
-    currentPhase = 'matching';
-    pushRecentEvent({ type: 'match_start', ts: new Date().toISOString() });
-    events.append({ type: 'match_start', ts: new Date().toISOString() });
+export type EventRuntimeStopReason = 'game_over' | 'manual' | 'SIGINT' | 'SIGTERM' | 'error';
+
+export interface EventRuntimeStop {
+  reason: EventRuntimeStopReason;
+  error?: unknown;
+}
+
+export interface EventRuntimeOptions {
+  authStore?: AuthStore;
+  onStop?: (stop: EventRuntimeStop) => void;
+  getAutomation?: () => Record<string, any> | undefined;
+}
+
+export class EventRuntime {
+  private readonly store: AuthStore;
+  private readonly onStop?: (stop: EventRuntimeStop) => void;
+  private readonly getAutomation?: () => Record<string, any> | undefined;
+  private events: EventStore | null = null;
+  private playerHistory: PlayerHistoryStore | null = null;
+  private client: GameClient | null = null;
+  private reconnectPoll: ReturnType<typeof setInterval> | null = null;
+  private reconnecting = false;
+  private stopped = false;
+  private notifyStop = false;
+  private gameOverEmitted = false;
+  private recentEvents: Record<string, any>[] = [];
+
+  private profileName = '';
+  private feedPath = '';
+  private currentPhase = 'lobby';
+  private currentMeeting: any = null;
+  private currentYou: Record<string, any> = {};
+  private currentGame: Record<string, any> = {};
+  private currentUrgent: Record<string, any> = {};
+  private mapCacheLoaded = false;
+  private mapCachePromise: Promise<void> | null = null;
+  private currentMeetingRound = 0;
+  private lastMeetingProjectionJson: string | null = null;
+  private lastSpeechYourTurnTick: number | null = null;
+  private prevCurrentSpeaker: string | null = null;
+  private latestFeed: any = null;
+
+  constructor(opts: EventRuntimeOptions = {}) {
+    this.store = opts.authStore ?? new AuthStore();
+    this.onStop = opts.onStop;
+    this.getAutomation = opts.getAutomation;
   }
-  let currentMeeting: any = null;
-  let currentYou: Record<string, any> = {};
-  let currentGame: Record<string, any> = {};
-  let currentUrgent: Record<string, any> = {};
-  let mapCacheLoaded = false;
-  let mapCachePromise: Promise<void> | null = null;
-  let currentMeetingRound = 0;
-  let lastMeetingProjectionJson: string | null = null;
-  /** Track last speech_your_turn tick (server-sent or synthetic) so we don't
-   *  double-emit when the server already shipped one in new_events. */
-  let lastSpeechYourTurnTick: number | null = null;
-  /** Track previous current_speaker so we only synthesize on real transitions. */
-  let prevCurrentSpeaker: string | null = null;
-
-  const refreshPlayerHistoryMapCache = () => {
-    if (mapCacheLoaded || mapCachePromise) return;
-    mapCachePromise = client.getMap()
-      .then((mapData) => {
-        if (!mapData || typeof mapData !== 'object') return;
-        playerHistory.updateMapCache(mapData);
-        mapCacheLoaded = true;
-      })
-      .catch(() => { })
-      .finally(() => {
-        mapCachePromise = null;
-      });
-  };
 
-  writeFileSync(runtimePath, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
-
-  // Seed feed.json synchronously on daemon startup so a watcher attached
-  // during the matchmaking phase (before the WS connects and pushes _state)
-  // does NOT immediately fail its `existsSync(feedPath)` precondition.
-  // The real WS-driven write further down overwrites this minimal record as
-  // soon as the first _state arrives.
-  try {
-    writeFileSync(
-      feedPath,
-      JSON.stringify(
-        buildFeed(profile.agentName, currentPhase, currentUrgent, currentMeeting, currentYou, currentGame),
-        null, 2,
-      ),
-    );
-  } catch { }
+  snapshot(): any | null {
+    return this.latestFeed;
+  }
+
+  refreshFeed(): void {
+    this.writeFeed();
+  }
+
+  async start(): Promise<void> {
+    const profile = this.store.getActive();
+    if (!profile) throw new Error('Not logged in.');
+
+    this.profileName = profile.agentName;
+    this.events = EventStore.forActiveAccount();
+    this.playerHistory = PlayerHistoryStore.forSession(this.events.path);
+    this.playerHistory.reset();
+
+    const stateDir = getProfileStateDir(profile);
+    const cclTest = isCclTestEnabled();
+    const rawWsLogPath = cclTest ? rawWsLogPathForSession(this.events.path) : undefined;
+    this.client = GameClient.fromAuth({ ws: true, authStore: this.store, rawWsLogPath });
+    this.feedPath = join(stateDir, 'feed.json');
+
+    if (existsSync(join(stateDir, 'match-state.json'))) {
+      this.currentPhase = 'matching';
+      const matchStart = { type: 'match_start', ts: new Date().toISOString() };
+      pushRecentEvent(this.recentEvents, matchStart);
+      this.events.append(matchStart);
+    }
+
+    this.writeFeed();
+    this.events.append({ type: 'event_runtime_started', pid: process.pid });
+    log.info('EVENT_RUNTIME', `started pid=${process.pid}`);
+
+    this.client.on('*', (data) => this.handleEvent(data));
+
+    await this.ensureWsConnected();
+    this.reconnectPoll = setInterval(() => {
+      void this.ensureWsConnected();
+    }, 3000);
+  }
 
-  events.append({ type: 'daemon_started' });
-  log.info('DAEMON', `started pid=${process.pid}`);
+  stop(reason: EventRuntimeStopReason = 'manual'): void {
+    this.finish({ reason }, false);
+  }
+
+  private finish(stop: EventRuntimeStop, notify: boolean): void {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.notifyStop = notify;
+    if (this.reconnectPoll) clearInterval(this.reconnectPoll);
+    this.reconnectPoll = null;
+    this.client?.disconnectWs();
+    this.client = null;
+    try {
+      this.events?.append({ type: 'event_runtime_stopped', reason: stop.reason });
+    } catch {}
+    if (this.notifyStop) this.onStop?.(stop);
+  }
+
+  private requestStop(reason: EventRuntimeStopReason, error?: unknown): void {
+    this.finish({ reason, error }, true);
+  }
 
-  let reconnecting = false;
-  const ensureWsConnected = async () => {
-    if (reconnecting || client.wsConnected) return;
-    reconnecting = true;
+  private async ensureWsConnected(): Promise<void> {
+    const client = this.client;
+    if (!client || this.stopped || this.reconnecting || client.wsConnected) return;
+    this.reconnecting = true;
     try {
       await client.discoverGameServer();
       if (!client.wsConnected) {
         await client.connectWs();
       }
       if (client.wsConnected) {
-        log.info('DAEMON', `ws connected, game_server=${client._gameServerUrl}`);
+        log.info('EVENT_RUNTIME', `ws connected, game_server=${client._gameServerUrl}`);
       } else {
-        log.info('DAEMON', 'waiting for game server / event websocket...');
+        log.info('EVENT_RUNTIME', 'waiting for game server / event websocket...');
       }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.warn('EVENT_RUNTIME', `ws connection attempt failed: ${message}`);
     } finally {
-      reconnecting = false;
+      this.reconnecting = false;
     }
-  };
+  }
 
-  let reconnectPoll: ReturnType<typeof setInterval> | null = null;
-  const controlPoll = setInterval(() => {
-    if (existsSync(controlPath)) {
-      try {
-        const cmd = JSON.parse(readFileSync(controlPath, 'utf8'));
-        unlinkSync(controlPath);
-        if (cmd.command === 'stop') {
-          events.append({ type: 'daemon_stopped' });
-          log.info('DAEMON', 'stopping (control)');
-          client.disconnectWs();
-          clearInterval(controlPoll);
-          if (reconnectPoll) clearInterval(reconnectPoll);
-          cleanup(runtimePath, feedPath, playerHistory, cclTest);
-          process.exit(0);
-        }
-      } catch { }
-    }
-  }, 1000);
+  private refreshPlayerHistoryMapCache(): void {
+    if (this.mapCacheLoaded || this.mapCachePromise || !this.client || !this.playerHistory) return;
+    this.mapCachePromise = this.client.getMap()
+      .then((mapData) => {
+        if (!mapData || typeof mapData !== 'object') return;
+        this.playerHistory?.updateMapCache(mapData);
+        this.mapCacheLoaded = true;
+      })
+      .catch(() => {})
+      .finally(() => {
+        this.mapCachePromise = null;
+      });
+  }
 
-  client.on('*', (data) => {
-    // Track server-sent speech_your_turn tick so _state synthesis can dedup.
-    if (data.type === 'speech_your_turn' && data.tick != null) {
-      lastSpeechYourTurnTick = data.tick;
-    }
+  private writeFeed(): void {
+    this.latestFeed = buildFeed(
+      this.profileName,
+      this.currentPhase,
+      this.currentUrgent,
+      this.currentMeeting,
+      this.recentEvents,
+      this.currentYou,
+      this.currentGame,
+      this.getAutomation?.(),
+    );
+    if (!shouldWriteFeedFile()) return;
+    try {
+      writeFileSync(
+        this.feedPath,
+        JSON.stringify(this.latestFeed, null, 2),
+      );
+    } catch {}
+  }
 
-    // _state is a synthetic event with full game state from WS — not a real game event
-    if (data.type === '_state') {
-      const s = data as any;
-      currentPhase = s.phase ?? currentPhase;
-      currentYou = s.you ? { ...s.you } : currentYou;
-      currentGame = {
-        game_id: s.game_id,
-        alive_count: s.alive_count,
-        task_progress: s.task_progress,
-      };
-      if (currentPhase !== 'lobby') refreshPlayerHistoryMapCache();
+  private appendGameOverFromState(state: any): void {
+    if (this.gameOverEmitted || !this.events) return;
+    const event = cleanObject({
+      type: 'game_over',
+      synthetic: true,
+      source: '_state',
+      tick: state.tick,
+      winner: state.winner,
+      winning_faction: state.winning_faction,
+      result: state.result,
+      reason: state.reason,
+    });
+    this.events.append(event);
+    pushRecentEvent(this.recentEvents, event);
+    this.gameOverEmitted = true;
+  }
 
-      if (s.meeting) {
-        if (currentMeetingRound === 0) {
-          currentMeetingRound = 1;
-          prevCurrentSpeaker = null; // new meeting, reset speaker tracking
-        }
-        const meetingProjection = buildMeetingStateProjection(s.meeting);
-        const meetingProjectionJson = JSON.stringify(meetingProjection);
-        if (meetingProjectionJson !== lastMeetingProjectionJson) {
-          events.append({
-            type: 'meeting_state',
-            synthetic: true,
-            tick: s.tick,
-            round: currentMeetingRound,
-            ...meetingProjection,
-          });
-          lastMeetingProjectionJson = meetingProjectionJson;
-        }
-        currentMeeting = {
-          caller: s.meeting.caller,
-          sub_phase: s.meeting.sub_phase,
-          current_speaker: s.meeting.current_speaker,
-          is_my_turn: s.meeting.current_speaker === (s.you?.name ?? currentYou.name),
-          alive_players: s.meeting.alive_players,
-          speech_order: s.meeting.speech_order,
-        };
-        // Synthesize speech_your_turn when current_speaker transitions to the
-        // current player but the server didn't ship one in new_events.
-        // Dedup: skip when server already emitted one at the same tick.
-        const myName = s.you?.name ?? currentYou.name;
-        const newSpeaker = s.meeting.current_speaker;
-        if (
-          typeof newSpeaker === 'string' &&
-          newSpeaker === myName &&
-          newSpeaker !== prevCurrentSpeaker &&
-          (s.tick == null || s.tick !== lastSpeechYourTurnTick)
-        ) {
-          events.append({
-            type: 'speech_your_turn',
-            synthetic: true,
-            tick: s.tick,
-            actor_name: myName,
-          });
-          pushRecentEvent({ type: 'speech_your_turn', synthetic: true, tick: s.tick, actor_name: myName });
-          lastSpeechYourTurnTick = s.tick;
-        }
-        prevCurrentSpeaker = typeof newSpeaker === 'string' ? newSpeaker : prevCurrentSpeaker;
-        if (s.meeting.sub_phase === 'vote') {
-          currentMeeting.votes_submitted = s.meeting.votes_submitted;
-        }
-      } else if (currentPhase !== 'meeting') {
-        currentMeeting = null;
-      }
+  private handleState(data: Record<string, any>): void {
+    const s = data as any;
+    const stateSaysGameOver = isGameOverState(s);
+    this.currentPhase = s.phase ?? this.currentPhase;
+    this.currentYou = s.you ? { ...s.you } : this.currentYou;
+    this.currentGame = {
+      game_id: s.game_id,
+      alive_count: s.alive_count,
+      task_progress: s.task_progress,
+    };
+    if (this.currentPhase !== 'lobby') this.refreshPlayerHistoryMapCache();
 
-      // Detect corpses nearby
-      const corpses: any[] = s.corpses ?? [];
-      let corpseNearby: any = null;
-      if (corpses.length > 0 && s.you?.x != null && s.you?.y != null) {
-        let bestDist = Infinity;
-        for (const c of corpses) {
-          if (c.x == null || c.y == null) continue;
-          const d = Math.sqrt((c.x - s.you.x) ** 2 + (c.y - s.you.y) ** 2);
-          if (d < bestDist) {
-            bestDist = d;
-            corpseNearby = { name: c.name, x: c.x, y: c.y, distance: Math.round(d) };
-          }
-        }
+    if (s.meeting) {
+      if (this.currentMeetingRound === 0) {
+        this.currentMeetingRound = 1;
+        this.prevCurrentSpeaker = null;
       }
-
-      currentUrgent = {
-        meeting_started: currentPhase === 'meeting',
-        emergency_active: false, // server doesn't expose via WS state
-        corpse_nearby: corpseNearby,
-        game_over: currentPhase === 'game_over',
+      const meetingProjection = buildMeetingStateProjection(s.meeting);
+      const meetingProjectionJson = JSON.stringify(meetingProjection);
+      if (meetingProjectionJson !== this.lastMeetingProjectionJson) {
+        this.events?.append({
+          type: 'meeting_state',
+          synthetic: true,
+          tick: s.tick,
+          round: this.currentMeetingRound,
+          ...meetingProjection,
+        });
+        this.lastMeetingProjectionJson = meetingProjectionJson;
+      }
+      this.currentMeeting = {
+        caller: s.meeting.caller,
+        sub_phase: s.meeting.sub_phase,
+        current_speaker: s.meeting.current_speaker,
+        is_my_turn: s.meeting.current_speaker === (s.you?.name ?? this.currentYou.name),
+        alive_players: s.meeting.alive_players,
+        speech_order: s.meeting.speech_order,
       };
-
-      try {
-        writeFileSync(
-          feedPath,
-          JSON.stringify(
-            buildFeed(profile.agentName, currentPhase, currentUrgent, currentMeeting, currentYou, currentGame),
-            null, 2,
-          ),
-        );
-      } catch { }
-      if (currentPhase === 'game_over') {
-        events.append({ type: 'daemon_stopped', reason: 'game_over' });
-        log.info('DAEMON', 'stopping (game_over via _state)');
-        client.disconnectWs();
-        clearInterval(controlPoll);
-        if (reconnectPoll) clearInterval(reconnectPoll);
-        cleanup(runtimePath, feedPath, playerHistory, cclTest);
-        process.exit(0);
+      const myName = s.you?.name ?? this.currentYou.name;
+      const newSpeaker = s.meeting.current_speaker;
+      if (
+        typeof newSpeaker === 'string' &&
+        newSpeaker === myName &&
+        newSpeaker !== this.prevCurrentSpeaker &&
+        (s.tick == null || s.tick !== this.lastSpeechYourTurnTick)
+      ) {
+        const event = {
+          type: 'speech_your_turn',
+          synthetic: true,
+          tick: s.tick,
+          actor_name: myName,
+        };
+        this.events?.append(event);
+        pushRecentEvent(this.recentEvents, event);
+        this.lastSpeechYourTurnTick = s.tick;
       }
-      return; // _state is synthetic, don't log to events.jsonl
+      this.prevCurrentSpeaker = typeof newSpeaker === 'string' ? newSpeaker : this.prevCurrentSpeaker;
+      if (s.meeting.sub_phase === 'vote') {
+        this.currentMeeting.votes_submitted = s.meeting.votes_submitted;
+      }
+    } else if (this.currentPhase !== 'meeting') {
+      this.currentMeeting = null;
     }
 
-    events.append(data);
-    pushRecentEvent(data);
-    if (data.type === 'player_spotted') {
-      refreshPlayerHistoryMapCache();
-      playerHistory.recordPlayerSpotted(data);
+    const corpses: any[] = s.corpses ?? [];
+    let corpseNearby: any = null;
+    if (corpses.length > 0 && s.you?.x != null && s.you?.y != null) {
+      let bestDist = Infinity;
+      for (const c of corpses) {
+        if (c.x == null || c.y == null) continue;
+        const d = Math.sqrt((c.x - s.you.x) ** 2 + (c.y - s.you.y) ** 2);
+        if (d < bestDist) {
+          bestDist = d;
+          corpseNearby = { name: c.name, x: c.x, y: c.y, distance: Math.round(d) };
+        }
+      }
     }
 
-    // Track phase from event types (fallback when _state isn't available yet)
-    if (data.type === 'meeting_start' || data.type === 'meeting_started') {
-      currentMeetingRound += 1;
-      lastMeetingProjectionJson = null;
-      prevCurrentSpeaker = null; // new meeting, reset speaker tracking
-      currentPhase = 'meeting';
-      currentMeeting = { sub_phase: 'speech' };
-    } else if (data.type === 'meeting_ended' || data.type === 'meeting_result_pending') {
-      currentPhase = 'wandering';
-      currentMeeting = null;
-    } else if (data.type === 'game_over') {
-      currentPhase = 'game_over';
-      currentMeeting = null;
-    } else if (data.type === 'game_started') {
-      currentPhase = 'wandering';
+    this.currentUrgent = {
+      meeting_started: this.currentPhase === 'meeting',
+      emergency_active: false,
+      corpse_nearby: corpseNearby,
+      game_over: this.currentPhase === 'game_over',
+    };
+
+    if (stateSaysGameOver || this.currentPhase === 'game_over') {
+      this.appendGameOverFromState(s);
+    }
+    this.writeFeed();
+    if (stateSaysGameOver || this.currentPhase === 'game_over') {
+      this.requestStop('game_over');
     }
+  }
 
-    // Write feed.json for the game start stream (also written by _state, but this is a fallback)
-    const urgent: Record<string, any> = {
-      meeting_started: currentPhase === 'meeting',
-      game_over: currentPhase === 'game_over',
-    };
+  private handleEvent(data: Record<string, any>): void {
+    if (this.stopped) return;
     try {
-      writeFileSync(
-        feedPath,
-        JSON.stringify(
-          buildFeed(profile.agentName, currentPhase, urgent, currentMeeting, currentYou, currentGame),
-          null, 2,
-        ),
-      );
-    } catch { }
+      const eventSaysGameOver = isGameOverEvent(data);
+      if (data.type === 'speech_your_turn' && data.tick != null) {
+        this.lastSpeechYourTurnTick = data.tick;
+      }
 
-    if (data.type === 'meeting_ended') {
-      if (isAutoRunning()) {
-        events.append({ type: 'opening_mover_skipped', source: 'meeting_ended', reason: 'auto_running' });
-      } else {
-        const { pid, logFile } = spawnOpeningMover();
-        events.append({ type: 'opening_mover_started', source: 'meeting_ended', pid, logFile });
+      if (data.type === '_state') {
+        this.handleState(data);
+        return;
       }
-    }
-    if (data.type === 'game_over') {
-      log.info('DAEMON', 'game over, stopping');
-      client.disconnectWs();
-      clearInterval(controlPoll);
-      if (reconnectPoll) clearInterval(reconnectPoll);
-      cleanup(runtimePath, feedPath, playerHistory, cclTest);
-      process.exit(0);
-    }
-  });
-
-  await ensureWsConnected();
-  reconnectPoll = setInterval(() => {
-    void ensureWsConnected();
-  }, 3000);
-
-  process.on('SIGINT', () => {
-    events.append({ type: 'daemon_stopped', reason: 'SIGINT' });
-    log.info('DAEMON', 'stopping (SIGINT)');
-    client.disconnectWs();
-    clearInterval(controlPoll);
-    if (reconnectPoll) clearInterval(reconnectPoll);
-    cleanup(runtimePath, feedPath, playerHistory, cclTest);
-    process.exit(0);
-  });
-
-  process.on('SIGTERM', () => {
-    events.append({ type: 'daemon_stopped', reason: 'SIGTERM' });
-    client.disconnectWs();
-    clearInterval(controlPoll);
-    if (reconnectPoll) clearInterval(reconnectPoll);
-    cleanup(runtimePath, feedPath, playerHistory, cclTest);
-    process.exit(0);
-  });
-}
 
-function cleanup(
-  runtimePath: string,
-  feedPath?: string,
-  playerHistory?: PlayerHistoryStore,
-  preservePlayerHistory = false,
-): void {
-  try { unlinkSync(runtimePath); } catch { }
-  if (feedPath) try { unlinkSync(feedPath); } catch { }
-  if (playerHistory && !preservePlayerHistory) playerHistory.delete();
+      this.events?.append(data);
+      pushRecentEvent(this.recentEvents, data);
+      if (data.type === 'player_spotted') {
+        this.refreshPlayerHistoryMapCache();
+        this.playerHistory?.recordPlayerSpotted(data);
+      }
+
+      if (data.type === 'meeting_start' || data.type === 'meeting_started') {
+        this.currentMeetingRound += 1;
+        this.lastMeetingProjectionJson = null;
+        this.prevCurrentSpeaker = null;
+        this.currentPhase = 'meeting';
+        this.currentMeeting = { sub_phase: 'speech' };
+      } else if (data.type === 'meeting_ended' || data.type === 'meeting_result_pending') {
+        this.currentPhase = 'wandering';
+        this.currentMeeting = null;
+      } else if (eventSaysGameOver) {
+        this.currentPhase = 'game_over';
+        this.currentMeeting = null;
+        this.gameOverEmitted = true;
+      } else if (data.type === 'game_started') {
+        this.currentPhase = 'wandering';
+      }
+
+      this.currentUrgent = {
+        meeting_started: this.currentPhase === 'meeting',
+        game_over: this.currentPhase === 'game_over',
+      };
+      this.writeFeed();
+
+      if (eventSaysGameOver) {
+        this.requestStop('game_over');
+      }
+    } catch (err) {
+      this.requestStop('error', err);
+    }
+  }
 }