@myclaw163/clawclaw-cli 0.6.54

package/src/runtime/event-daemon.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { buildMeetingStateProjection } from './event-daemon.js';
+
+describe('buildMeetingStateProjection', () => {
+  it('keeps meeting state fields without historical speech text', () => {
+    expect(buildMeetingStateProjection({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speeches_so_far: { A: 'hello' },
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+      countdown: 12,
+    })).toEqual({
+      caller: 'A',
+      sub_phase: 'speech',
+      first_speaker: 'A',
+      speech_order: ['A', 'B'],
+      current_speaker: 'B',
+      speech_skipped: ['C'],
+      votes_submitted: ['A'],
+      alive_players: ['A', 'B'],
+    });
+  });
+});

package/src/runtime/event-daemon.ts

@@ -0,0 +1,371 @@
+import { existsSync, readFileSync, unlinkSync, 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';
+
+const log = new RuntimeLogger();
+
+let feedSerial = 0;
+const MAX_RECENT_EVENTS = 50;
+const recentEvents: Record<string, any>[] = [];
+
+function pushRecentEvent(evt: Record<string, any>): void {
+  recentEvents.push(evt);
+  if (recentEvents.length > MAX_RECENT_EVENTS) recentEvents.shift();
+}
+
+export function buildMeetingStateProjection(meeting: any): Record<string, any> {
+  return {
+    caller: meeting?.caller ?? null,
+    sub_phase: meeting?.sub_phase ?? null,
+    first_speaker: meeting?.first_speaker ?? null,
+    speech_order: Array.isArray(meeting?.speech_order) ? meeting.speech_order : undefined,
+    current_speaker: meeting?.current_speaker ?? null,
+    speech_skipped: Array.isArray(meeting?.speech_skipped) ? meeting.speech_skipped : undefined,
+    votes_submitted: Array.isArray(meeting?.votes_submitted) ? meeting.votes_submitted : undefined,
+    alive_players: Array.isArray(meeting?.alive_players) ? meeting.alive_players : undefined,
+  };
+}
+
+/** Build feed.json consumed by the `ccl game start` stream — tracks phase, current_speaker, urgent conditions. */
+function buildFeed(
+  youName: string,
+  phase: string,
+  urgent: Record<string, any>,
+  meeting: any,
+  you?: Record<string, any>,
+  game?: Record<string, any>,
+): any {
+  return {
+    ts: new Date().toISOString(),
+    serial: ++feedSerial,
+    phase,
+    you: { name: youName, ...(you ?? {}) },
+    game,
+    urgent,
+    meeting,
+    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() });
+  }
+  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 { }
+
+  events.append({ type: 'daemon_started' });
+  log.info('DAEMON', `started pid=${process.pid}`);
+
+  let reconnecting = false;
+  const ensureWsConnected = async () => {
+    if (reconnecting || client.wsConnected) return;
+    reconnecting = true;
+    try {
+      await client.discoverGameServer();
+      if (!client.wsConnected) {
+        await client.connectWs();
+      }
+      if (client.wsConnected) {
+        log.info('DAEMON', `ws connected, game_server=${client._gameServerUrl}`);
+      } else {
+        log.info('DAEMON', 'waiting for game server / event websocket...');
+      }
+    } finally {
+      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);
+
+  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;
+    }
+
+    // _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();
+
+      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;
+      }
+
+      // 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) };
+          }
+        }
+      }
+
+      currentUrgent = {
+        meeting_started: currentPhase === 'meeting',
+        emergency_active: false, // server doesn't expose via WS state
+        corpse_nearby: corpseNearby,
+        game_over: currentPhase === 'game_over',
+      };
+
+      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);
+      }
+      return; // _state is synthetic, don't log to events.jsonl
+    }
+
+    events.append(data);
+    pushRecentEvent(data);
+    if (data.type === 'player_spotted') {
+      refreshPlayerHistoryMapCache();
+      playerHistory.recordPlayerSpotted(data);
+    }
+
+    // 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';
+    }
+
+    // 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',
+    };
+    try {
+      writeFileSync(
+        feedPath,
+        JSON.stringify(
+          buildFeed(profile.agentName, currentPhase, urgent, currentMeeting, currentYou, currentGame),
+          null, 2,
+        ),
+      );
+    } catch { }
+
+    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 === '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();
+}

package/src/runtime/opening-mover.ts

@@ -0,0 +1,303 @@
+import { spawn } from 'child_process';
+import { appendFileSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { delimiter, dirname, join, resolve } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { Action } from '../sdk/action.js';
+import { AuthStore } from '../lib/auth.js';
+import { GameClient } from '../lib/game-client.js';
+import { getProfileLogsDir, getProfileStateDir } from '../lib/init-command.js';
+import { isStrategyRunning as isAutoRunning } from '../strategies/strategy-loop.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const WANDERING_WINDOW_MS = 30_000;
+const STARTUP_WAIT_MS = 10 * 60_000;
+const POLL_MS = 1000;
+const CANCEL_TTL_MS = 45_000;
+
+interface Point {
+  x: number;
+  y: number;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function debug(message: string): void {
+  if (process.env.CLAWCLAW_LOG_FILE) {
+    try {
+      appendFileSync(process.env.CLAWCLAW_LOG_FILE, `[${new Date().toISOString()}] ${message}\n`);
+    } catch {}
+  }
+}
+
+function isPidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function activeProfile() {
+  const profile = new AuthStore().getActive();
+  if (!profile) throw new Error('Not logged in.');
+  return profile;
+}
+
+function pidPath(): string {
+  return join(getProfileStateDir(activeProfile()), 'opening-mover.pid');
+}
+
+function cancelPath(): string {
+  return join(getProfileStateDir(activeProfile()), 'opening-mover.cancel');
+}
+
+function readCancelToken(path: string): number {
+  try {
+    const token = Number(readFileSync(path, 'utf8').trim());
+    return Number.isFinite(token) ? token : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function cleanupPid(path: string): void {
+  try {
+    const current = Number(readFileSync(path, 'utf8').trim());
+    if (current === process.pid) unlinkSync(path);
+  } catch {}
+}
+
+export function stopOpeningMoverIfRunning(): void {
+  try {
+    const path = pidPath();
+    if (!existsSync(path)) return;
+    const pid = Number(readFileSync(path, 'utf8').trim());
+    if (pid > 0 && isPidAlive(pid)) {
+      try { process.kill(pid, 'SIGTERM'); } catch {}
+    }
+    try { unlinkSync(path); } catch {}
+  } catch {}
+}
+
+export function cancelOpeningMoverWindow(): void {
+  try {
+    const path = cancelPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, String(Date.now()));
+  } catch {}
+}
+
+function roomAnchor(r: any): Point | null {
+  const taskLocations = Array.isArray(r?.task_locations) ? r.task_locations : [];
+  const candidates = taskLocations
+    .map((tl: any) => ({ x: Number(tl?.x ?? tl?.[0]), y: Number(tl?.y ?? tl?.[1]) }))
+    .filter((p: Point) => Number.isFinite(p.x) && Number.isFinite(p.y));
+  if (candidates.length > 0) return candidates[Math.floor(Math.random() * candidates.length)];
+
+  const poly: number[][] = Array.isArray(r?.polygon) ? r.polygon : [];
+  if (poly.length === 0) return null;
+
+  let area = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < poly.length; i += 1) {
+    const [x1, y1] = poly[i];
+    const [x2, y2] = poly[(i + 1) % poly.length];
+    const cross = x1 * y2 - x2 * y1;
+    area += cross;
+    cx += (x1 + x2) * cross;
+    cy += (y1 + y2) * cross;
+  }
+  area *= 0.5;
+  if (Math.abs(area) < 1e-6) {
+    return {
+      x: poly.reduce((sum, p) => sum + p[0], 0) / poly.length,
+      y: poly.reduce((sum, p) => sum + p[1], 0) / poly.length,
+    };
+  }
+  return { x: cx / (6 * area), y: cy / (6 * area) };
+}
+
+function randomTarget(mapData: any): Point | null {
+  const rooms = Array.isArray(mapData?.rooms) ? mapData.rooms : [];
+  const anchors = rooms.map(roomAnchor).filter((p: Point | null): p is Point => p !== null);
+  if (anchors.length === 0) return null;
+  return anchors[Math.floor(Math.random() * anchors.length)];
+}
+
+export async function runOpeningMover(): Promise<void> {
+  const path = pidPath();
+  const cancelFile = cancelPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, String(process.pid));
+
+  let running = true;
+  process.on('SIGINT', () => { running = false; });
+  process.on('SIGTERM', () => { running = false; });
+
+  const client = GameClient.fromAuth();
+  const startupDeadline = Date.now() + STARTUP_WAIT_MS;
+  let wanderingDeadline = 0;
+  let helperMovingUntil = 0;
+  let lastPhase: string | null = null;
+  let lastCancelToken = 0;
+  let windowActive = false;
+
+  try {
+    debug('opening mover started');
+    try { await client.discoverGameServer(); } catch {}
+    while (running) {
+      let state: any = null;
+      try {
+        state = await client.getGameState();
+      } catch {
+        await sleep(1500);
+        continue;
+      }
+
+      if (!state) {
+        if (Date.now() >= startupDeadline) break;
+        await sleep(1500);
+        continue;
+      }
+      if (state.phase === 'game_over') break;
+
+      const cancelToken = readCancelToken(cancelFile);
+      if (cancelToken > lastCancelToken) {
+        lastCancelToken = cancelToken;
+        if (Date.now() - cancelToken <= CANCEL_TTL_MS) {
+          windowActive = false;
+          wanderingDeadline = 0;
+          helperMovingUntil = 0;
+          if (state.phase === 'wandering') lastPhase = 'wandering';
+          debug('movement helper window cancelled by manual action');
+        }
+      }
+
+      if (state.phase !== 'wandering') {
+        lastPhase = state.phase;
+        windowActive = false;
+        wanderingDeadline = 0;
+        helperMovingUntil = 0;
+        await sleep(POLL_MS);
+        continue;
+      }
+
+      if (lastPhase !== 'wandering') {
+        lastPhase = 'wandering';
+        helperMovingUntil = 0;
+        if (isAutoRunning()) {
+          windowActive = false;
+          wanderingDeadline = 0;
+          debug('wandering detected; auto running, movement helper skipped');
+        } else if (state.you?.currently_moving || state.you?.doing_task) {
+          windowActive = false;
+          wanderingDeadline = 0;
+          debug('wandering detected; player already active, movement helper skipped');
+        } else {
+          windowActive = true;
+          wanderingDeadline = Date.now() + WANDERING_WINDOW_MS;
+          debug('wandering detected; movement helper window started');
+        }
+      }
+
+      if (!windowActive) {
+        await sleep(POLL_MS);
+        continue;
+      }
+      if (Date.now() >= wanderingDeadline) {
+        windowActive = false;
+        wanderingDeadline = 0;
+        debug('movement helper window expired');
+        await sleep(POLL_MS);
+        continue;
+      }
+
+      if (isAutoRunning()) {
+        windowActive = false;
+        wanderingDeadline = 0;
+        debug('auto started; movement helper window stopped');
+        await sleep(POLL_MS);
+        continue;
+      }
+
+      if (state.you?.currently_moving || state.you?.doing_task || Date.now() < helperMovingUntil) {
+        await sleep(POLL_MS);
+        continue;
+      }
+
+      let mapData: any = null;
+      try {
+        mapData = await client.getMap();
+      } catch {
+        await sleep(POLL_MS);
+        continue;
+      }
+      const target = randomTarget(mapData);
+      if (!target) {
+        await sleep(POLL_MS);
+        continue;
+      }
+
+      let result: any;
+      try {
+        result = await client.submitAction(Action.move(target).toJSON() as any);
+      } catch {
+        await sleep(POLL_MS);
+        continue;
+      }
+      const actionResult = result?.data ?? result;
+      const durationSecs = Number(actionResult?.duration_secs ?? result?.duration_secs ?? 2);
+      debug(`opening move submitted target=(${target.x},${target.y}) duration=${durationSecs}`);
+      helperMovingUntil = Date.now() + Math.max(0.5, durationSecs) * 1000 + 500;
+    }
+  } finally {
+    debug('opening mover stopped');
+    cleanupPid(path);
+  }
+}
+
+export function spawnOpeningMover(): { pid: number; logFile: string } {
+  const profile = activeProfile();
+  const stateDir = getProfileStateDir(profile);
+  mkdirSync(stateDir, { recursive: true });
+
+  const path = join(stateDir, 'opening-mover.pid');
+  if (existsSync(path)) {
+    try {
+      const pid = Number(readFileSync(path, 'utf8').trim());
+      if (pid > 0 && isPidAlive(pid)) return { pid, logFile: '' };
+    } catch {}
+    try { unlinkSync(path); } catch {}
+  }
+
+  const logsDir = getProfileLogsDir(profile);
+  mkdirSync(logsDir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const logFile = join(logsDir, `opening-mover-${timestamp}.log`);
+  const logFd = openSync(logFile, 'a');
+
+  const binEntry = resolve(__dirname, '..', '..', 'bin', 'clawclaw-cli.mjs').replace(/\\/g, '/');
+  if (!existsSync(binEntry)) throw new Error('clawclaw-cli bin entry not found');
+
+  let npmGlobalModules = '';
+  try { npmGlobalModules = execSync('npm root -g', { encoding: 'utf8', windowsHide: true }).trim(); } catch {}
+  const nodePath = [npmGlobalModules, process.env.NODE_PATH ?? ''].filter(Boolean).join(delimiter);
+  const isWin = process.platform === 'win32';
+
+  const child = spawn(process.execPath, [binEntry, '_opener'], {
+    detached: true,
+    stdio: isWin ? ['ignore', 'ignore', 'ignore'] : ['ignore', logFd, logFd],
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      NODE_PATH: nodePath,
+      ...(isWin ? { CLAWCLAW_LOG_FILE: logFile } : {}),
+    },
+    windowsHide: true,
+  });
+  child.unref();
+  if (child.pid) writeFileSync(path, String(child.pid));
+  return { pid: child.pid!, logFile };
+}