@myclaw163/clawclaw-cli 0.6.56 → 0.6.58

package/src/commands/game.ts

@@ -1,16 +1,25 @@
 import { Command } from 'commander';
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { spawnSync, type ChildProcess } from 'child_process';
 import { AuthStore } from '../lib/auth.js';
 import { ApiError, GameClient } from '../lib/game-client.js';
 import { getProfileStateDir } from '../lib/init-command.js';
-import { spawnDaemon, getRunningDaemonPid, waitDaemonExit } from '../runtime/daemon.js';
 import { EventStore } from '../pipeline/event-store.js';
-import { spawnOpeningMover, stopOpeningMoverIfRunning } from '../runtime/opening-mover.js';
 import { spawnStrategyLoop } from '../strategies/spawn.js';
+import { stopStrategyIfRunning } from '../strategies/strategy-loop.js';
 import { setMeta } from '../lib/command-meta.js';
-import { runStreaming, buildErrorLine, readFeedSummary, nextStepFor } from './watch.js';
+import { runStreaming, buildErrorLine, summarizeFeed, nextStepFor } from './watch.js';
 import { hubReminder, readCachedGamesPlayed } from '../lib/hub-reminder.js';
+import { EventRuntime } from '../runtime/event-daemon.js';
+import {
+  gameStartRuntimePath,
+  readGameStartRuntime,
+  sendOwnerControlRequest,
+  startOwnerControlServer,
+  type OwnerControlInfo,
+  type OwnerControlServer,
+} from '../runtime/owner-control.js';
 import {
   startMatch,
   endMatch,
@@ -21,10 +30,6 @@ import {
   hasMatchTimedOut,
 } from '../lib/match-state.js';
 
-function writeControl(stateDir: string, command: 'stop'): void {
-  writeFileSync(join(stateDir, 'control.json'), JSON.stringify({ command }));
-}
-
 function sleep(ms: number): Promise<void> {
   return new Promise(r => setTimeout(r, ms));
 }
@@ -39,52 +44,141 @@ function queueStatus(result: any): string | undefined {
 }
 
 const DEFAULT_QUEUE_WAIT_TIMEOUT_SECS = 30;
-const GAME_START_RUNTIME_FILE = 'game-start.json';
 
 function isPidAlive(pid: number): boolean {
   if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return false;
   try { process.kill(pid, 0); return true; } catch { return false; }
 }
 
-function gameStartRuntimePath(stateDir: string): string {
-  return join(stateDir, GAME_START_RUNTIME_FILE);
-}
-
 function getRunningGameStartPid(stateDir: string): number | null {
-  const runtimePath = gameStartRuntimePath(stateDir);
-  if (!existsSync(runtimePath)) return null;
-  try {
-    const info = JSON.parse(readFileSync(runtimePath, 'utf8'));
-    const pid = Number(info?.pid);
-    if (isPidAlive(pid)) return pid;
-  } catch {}
-  try { unlinkSync(runtimePath); } catch {}
+  const info = readGameStartRuntime(stateDir);
+  if (!info) return null;
+  const pid = Number(info?.owner_pid ?? info?.pid);
+  if (isPidAlive(pid)) return pid;
+  try { unlinkSync(gameStartRuntimePath(stateDir)); } catch {}
   return null;
 }
 
-function writeGameStartRuntime(stateDir: string, mode: GameStartPlanKind): void {
+function writeGameStartRuntime(
+  stateDir: string,
+  mode: GameStartPlanKind,
+  phase?: string,
+  controlOverride?: { control: OwnerControlInfo; token: string },
+): void {
   mkdirSync(stateDir, { recursive: true });
+  let startedAt = new Date().toISOString();
+  let existingControl: OwnerControlInfo | undefined;
+  let existingToken: string | undefined;
+  try {
+    const existing = JSON.parse(readFileSync(gameStartRuntimePath(stateDir), 'utf8'));
+    const existingPid = Number(existing?.owner_pid ?? existing?.pid);
+    if (existingPid === process.pid && typeof existing?.started_at === 'string') {
+      startedAt = existing.started_at;
+      if (existing?.control?.path) existingControl = existing.control;
+      if (typeof existing?.control_token === 'string') existingToken = existing.control_token;
+    }
+  } catch {}
+  const control = controlOverride?.control ?? existingControl;
+  const controlToken = controlOverride?.token ?? existingToken;
   writeFileSync(gameStartRuntimePath(stateDir), JSON.stringify({
+    schema: 3,
+    owner_pid: process.pid,
     pid: process.pid,
-    started_at: new Date().toISOString(),
+    started_at: startedAt,
+    heartbeat_at: new Date().toISOString(),
     mode,
-  }));
+    ...(control ? { control } : {}),
+    ...(controlToken ? { control_token: controlToken } : {}),
+    ...(phase ? { phase } : {}),
+  }, null, 2));
 }
 
-function cleanupGameStartRuntime(stateDir: string): void {
+function startGameStartHeartbeat(stateDir: string, mode: GameStartPlanKind): ReturnType<typeof setInterval> {
+  return setInterval(() => {
+    try {
+      writeGameStartRuntime(stateDir, mode);
+    } catch {}
+  }, 5000);
+}
+
+function cleanupGameStartRuntime(stateDir: string, opts: { removeFeed?: boolean; controlPath?: string } = {}): void {
   const runtimePath = gameStartRuntimePath(stateDir);
   try {
     const info = JSON.parse(readFileSync(runtimePath, 'utf8'));
-    if (Number(info?.pid) !== process.pid) return;
+    const pid = Number(info?.owner_pid ?? info?.pid);
+    if (pid !== process.pid) return;
   } catch {}
   try { unlinkSync(runtimePath); } catch {}
+  if (opts.removeFeed) {
+    try { unlinkSync(join(stateDir, 'feed.json')); } catch {}
+  }
+  if (opts.controlPath && process.platform !== 'win32') {
+    try { unlinkSync(opts.controlPath); } catch {}
+  }
+}
+
+function terminateProcessTree(pid: number, signal: NodeJS.Signals = 'SIGTERM'): boolean {
+  if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return false;
+  if (process.platform === 'win32') {
+    const result = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+    return result.status === 0;
+  }
+  const pkillSignal = signal === 'SIGKILL' ? '-KILL' : '-TERM';
+  try { spawnSync('pkill', [pkillSignal, '-P', String(pid)], { stdio: 'ignore' }); } catch {}
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitPidExit(pid: number, timeoutMs = 5000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) return true;
+    await sleep(200);
+  }
+  return !isPidAlive(pid);
+}
+
+async function stopOwnerIfRunning(stateDir: string, timeoutMs = 5000): Promise<{ pid: number | null; stopped: boolean }> {
+  return stopOwnerWithCommand(stateDir, 'stop', timeoutMs);
+}
+
+async function stopOwnerWithCommand(
+  stateDir: string,
+  command: 'stop' | 'quit' | 'leave',
+  timeoutMs = 5000,
+): Promise<{ pid: number | null; stopped: boolean }> {
+  const pid = getRunningGameStartPid(stateDir);
+  if (!pid) {
+    try { unlinkSync(gameStartRuntimePath(stateDir)); } catch {}
+    try { unlinkSync(join(stateDir, 'feed.json')); } catch {}
+    return { pid: null, stopped: false };
+  }
+  try {
+    const response = await sendOwnerControlRequest(stateDir, command);
+    if (response?.ok) {
+      const exited = await waitPidExit(pid, timeoutMs);
+      if (exited) return { pid, stopped: true };
+    }
+  } catch {}
+  terminateProcessTree(pid, 'SIGTERM');
+  const exited = await waitPidExit(pid, timeoutMs);
+  if (!exited) {
+    terminateProcessTree(pid, 'SIGKILL');
+    await waitPidExit(pid, 2000);
+  }
+  try { unlinkSync(gameStartRuntimePath(stateDir)); } catch {}
+  try { unlinkSync(join(stateDir, 'feed.json')); } catch {}
+  return { pid, stopped: true };
 }
 
 type QueueStatus = 'allocated' | 'queued' | 'not_in_queue' | string | undefined;
 
 export type GameStartPlan =
   | { kind: 'already_running'; pid: number }
-  | { kind: 'attach_daemon' }
   | { kind: 'resume_queue' }
   | { kind: 'resume_allocated' }
   | { kind: 'fresh_start' };
@@ -93,21 +187,14 @@ type GameStartPlanKind = GameStartPlan['kind'];
 
 export function planGameStartAction(input: {
   gameStartPid?: number | null;
-  daemonPid?: number | null;
   hasMatchState: boolean;
   queueStatus?: QueueStatus;
-  feedPhase?: string | null;
 }): GameStartPlan {
   if (input.gameStartPid) return { kind: 'already_running', pid: input.gameStartPid };
 
-  if (input.daemonPid) {
-    if (input.hasMatchState || input.feedPhase === 'matching') return { kind: 'resume_queue' };
-    if (input.feedPhase === 'lobby') return { kind: 'fresh_start' };
-    return { kind: 'attach_daemon' };
-  }
-
   if (input.queueStatus === 'allocated') return { kind: 'resume_allocated' };
   if (input.queueStatus === 'queued' || input.queueStatus === 'already_in_queue') return { kind: 'resume_queue' };
+  if (input.hasMatchState && input.queueStatus !== 'not_in_queue') return { kind: 'resume_queue' };
   return { kind: 'fresh_start' };
 }
 
@@ -127,15 +214,6 @@ function ensureEventSession(source: string): EventStore {
   return events;
 }
 
-function readFeedPhase(feedPath: string): string | null {
-  try {
-    const phase = JSON.parse(readFileSync(feedPath, 'utf8'))?.phase;
-    return typeof phase === 'string' ? phase : null;
-  } catch {
-    return null;
-  }
-}
-
 function nonEmptyString(value: unknown): string | undefined {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
@@ -150,15 +228,6 @@ export interface GameStrategyIdentity {
   alive: boolean | null;
 }
 
-export interface StrategyRuntimeInfo {
-  strategy?: string;
-  pid?: number;
-  source?: string;
-  gameId?: string;
-  role?: string;
-  running: boolean;
-}
-
 export function gameStrategyIdentity(stateData: any, roleData: any): GameStrategyIdentity {
   const state = unwrapData(stateData);
   const role = unwrapData(roleData);
@@ -171,33 +240,6 @@ export function gameStrategyIdentity(stateData: any, roleData: any): GameStrateg
   };
 }
 
-export function strategyRuntimeMatchesIdentity(
-  runtime: StrategyRuntimeInfo | null,
-  identity: GameStrategyIdentity,
-): boolean {
-  if (!runtime?.running) return false;
-  if (!runtime.gameId || !identity.gameId || runtime.gameId !== identity.gameId) return false;
-  if (runtime.role && identity.role && runtime.role !== identity.role) return false;
-  return true;
-}
-
-function readStrategyRuntimeInfo(stateDir: string): StrategyRuntimeInfo | null {
-  try {
-    const raw = JSON.parse(readFileSync(join(stateDir, 'auto.json'), 'utf8'));
-    const pid = Number(raw?.pid);
-    return {
-      strategy: nonEmptyString(raw?.strategy),
-      pid: Number.isFinite(pid) ? pid : undefined,
-      source: nonEmptyString(raw?.source),
-      gameId: nonEmptyString(raw?.game_id) ?? nonEmptyString(raw?.gameId),
-      role: nonEmptyString(raw?.role),
-      running: Number.isFinite(pid) && pid > 0 ? isPidAlive(pid) : false,
-    };
-  } catch {
-    return null;
-  }
-}
-
 function commandError(command: string, err: unknown): { command: string; error: string } {
   const message = err instanceof ApiError
     ? `${err.status}: ${err.body}`
@@ -294,7 +336,7 @@ const ROLE_DEFAULT_STRATEGY: Record<string, string> = {
   'neutral_octopus': 'lone-kill-task',
 };
 
-function autoStartStrategy(roleData: any, stateData?: any, gameId?: string): { strategy: string; pid: number | undefined } | null {
+function autoStartStrategy(roleData: any, stateData?: any, gameId?: string): { strategy: string; pid: number | undefined; child: ChildProcess } | null {
   const roleId: string | undefined = roleData?.data?.role ?? roleData?.role;
   if (!roleId) return null;
   const strategyId = ROLE_DEFAULT_STRATEGY[roleId];
@@ -303,8 +345,10 @@ function autoStartStrategy(roleData: any, stateData?: any, gameId?: string): { s
     source: 'auto_start',
     gameId: gameId ?? gameStrategyIdentity(stateData, roleData).gameId,
     role: roleId,
+    detached: false,
+    writeRuntimeFiles: false,
   });
-  return { strategy: strategyId, pid: child.pid };
+  return { strategy: strategyId, pid: child.pid, child };
 }
 
 async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<void> {
@@ -323,6 +367,58 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
   const stateDir = getProfileStateDir(profile);
   const feedPath = join(stateDir, 'feed.json');
   const client = GameClient.fromAuth();
+  let eventRuntime: EventRuntime | undefined;
+  let streamAbortController: AbortController | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  let ownerControl: OwnerControlServer | null = null;
+  let ownerFeed: any = {
+    ts: new Date().toISOString(),
+    phase: 'matching',
+    terminal: false,
+    you: { name: profile.agentName },
+    game: {},
+    urgent: {},
+    meeting: null,
+    recent_events: [],
+  };
+  let strategyChild: ChildProcess | null = null;
+  let currentStrategy: string | null = null;
+  const currentAutomationSummary = (): Record<string, any> | undefined => {
+    if (!currentStrategy) return undefined;
+    const pid = strategyChild?.pid;
+    return { strategy: currentStrategy, running: !!(pid && isPidAlive(pid)) };
+  };
+  const currentSummary = (): any | null => {
+    const runtimeFeed = eventRuntime?.snapshot();
+    const feed = runtimeFeed && runtimeFeed.phase !== 'lobby' ? runtimeFeed : ownerFeed;
+    const automation = currentAutomationSummary();
+    return summarizeFeed(automation ? { ...feed, automation } : feed);
+  };
+  let manualExitEmitted = false;
+  let ownerExitRequested = false;
+  const stopOwnedStrategy = (): void => {
+    const child = strategyChild;
+    strategyChild = null;
+    currentStrategy = null;
+    if (child?.pid && isPidAlive(child.pid)) {
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => {
+        if (child.pid && isPidAlive(child.pid)) {
+          try { child.kill('SIGKILL'); } catch {}
+        }
+      }, 1000).unref();
+    }
+    eventRuntime?.refreshFeed();
+  };
+  const onOwnerSignal = (): void => {
+    streamAbortController?.abort();
+    eventRuntime?.stop('SIGTERM');
+    stopOwnedStrategy();
+    cleanupGameStartRuntime(stateDir, { removeFeed: true, controlPath: ownerControl?.control.path });
+    process.exit(130);
+  };
+  process.on('SIGINT', onOwnerSignal);
+  process.on('SIGTERM', onOwnerSignal);
   const emit = (obj: Record<string, any>): void => {
     process.stdout.write(JSON.stringify(obj) + '\n');
   };
@@ -336,28 +432,53 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
       exit_reason: [reason],
       next_step: nextStepOverride ?? nextStepFor(reason),
       events: [event],
-      summary: readFeedSummary(feedPath),
+      summary: currentSummary(),
+    });
+  };
+  const emitOwnerExit = (kind: 'stop' | 'quit' | 'leave', command: string): void => {
+    if (manualExitEmitted) return;
+    manualExitEmitted = true;
+    const eventType = kind === 'leave' ? 'stop' : kind;
+    emit({
+      exit_reason: [eventType],
+      next_step: `Received ${command}. The current ccl game start process is exiting now.`,
+      events: [{ type: eventType, command }],
+      summary: { phase: 'stopped' },
     });
   };
+  const requestOwnerExit = (kind: 'stop' | 'quit' | 'leave', command: string): void => {
+    ownerExitRequested = true;
+    emitOwnerExit(kind, command);
+    streamAbortController?.abort();
+    eventRuntime?.stop('manual');
+    stopOwnedStrategy();
+  };
   const emitMatchEvent = (evt: Record<string, any>): void => {
     try {
       const store = EventStore.forActiveAccount();
       store.append({ ts: new Date().toISOString(), ...evt });
     } catch {}
   };
-  const ensureDaemonRunning = (): void => {
-    if (getRunningDaemonPid(stateDir)) return;
-    try {
-      spawnDaemon();
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (!msg.includes('Daemon already running')) throw err;
-    }
+  const ensureEventRuntime = async (): Promise<void> => {
+    if (eventRuntime) return;
+    eventRuntime = new EventRuntime({
+      authStore,
+      getAutomation: currentAutomationSummary,
+      onStop: (stop) => {
+        if (stop.reason === 'game_over') return;
+        streamAbortController?.abort();
+      },
+    });
+    await eventRuntime.start();
   };
   const streamGame = async (): Promise<void> => {
     const sessionPath = EventStore.latestSessionPath();
     const ctrl = new AbortController();
-    const onSignal = (): void => ctrl.abort();
+    streamAbortController = ctrl;
+    const onSignal = (): void => {
+      ctrl.abort();
+      eventRuntime?.stop('SIGTERM');
+    };
     process.on('SIGINT', onSignal);
     process.on('SIGTERM', onSignal);
     try {
@@ -367,6 +488,8 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
         getSessionPath: () => EventStore.latestSessionPath(),
         stdout: (s) => process.stdout.write(s),
         signal: ctrl.signal,
+        skipFeedWait: true,
+        readSummary: currentSummary,
         skipBacklogTypes: ['match_waiting', 'match_timeout'],
         emitGameStart: true,
         hubReminder: hubReminder(readCachedGamesPlayed()),
@@ -377,6 +500,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
     } finally {
       process.off('SIGINT', onSignal);
       process.off('SIGTERM', onSignal);
+      streamAbortController = null;
     }
   };
   const handleAllocated = async (queue: any, preserveStrategy: boolean): Promise<void> => {
@@ -390,21 +514,31 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
     if (!identity.gameId && queueGameId) {
       identity.gameId = queueGameId;
     }
+    const role = unwrapData(context.role);
+    ownerFeed = {
+      ...ownerFeed,
+      ts: new Date().toISOString(),
+      phase: 'allocated',
+      you: {
+        ...ownerFeed.you,
+        role: nonEmptyString(role?.role) ?? identity.role,
+        role_display: nonEmptyString(role?.role_display_name) ?? nonEmptyString(role?.role_display),
+        faction: nonEmptyString(role?.faction),
+        alive: identity.alive,
+      },
+      game: {
+        ...ownerFeed.game,
+        game_id: identity.gameId,
+      },
+    };
     let strategyInfo: { strategy: string; pid: number | undefined } | null = null;
-    if (identity.alive !== false) {
-      if (preserveStrategy) {
-        const { isStrategyRunning, stopStrategyIfRunning } = await import('../strategies/strategy-loop.js');
-        if (isStrategyRunning()) {
-          const runtime = readStrategyRuntimeInfo(stateDir);
-          if (identity.gameId && !strategyRuntimeMatchesIdentity(runtime, identity)) {
-            stopStrategyIfRunning();
-            strategyInfo = autoStartStrategy(context.role, context.state, identity.gameId);
-          }
-        } else {
-          strategyInfo = autoStartStrategy(context.role, context.state, identity.gameId);
-        }
-      } else {
-        strategyInfo = autoStartStrategy(context.role, context.state, identity.gameId);
+    if (opts.watch && identity.alive !== false) {
+      stopOwnedStrategy();
+      const started = autoStartStrategy(context.role, context.state, identity.gameId);
+      if (started) {
+        strategyChild = started.child;
+        currentStrategy = started.strategy;
+        strategyInfo = { strategy: started.strategy, pid: started.pid };
       }
     }
     const allocationPayload = {
@@ -416,9 +550,10 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
     };
     if (!opts.watch) {
       emitLifecycle('allocated', allocationPayload,
-        'Match secured. Read role/map/tasks from `events[0]`. Default strategy is active when `default_strategy` is present or summary.automation shows one. Move into Preparing phase.');
+        'Match secured. Read role/map/tasks from `events[0]`, then launch `ccl game start` without --no-watch to attach the owner stream and automation.');
       return;
     }
+    await ensureEventRuntime();
     await streamGame();
   };
   const pollQueue = async (preserveStrategy: boolean): Promise<void> => {
@@ -428,7 +563,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
     let lastHeartbeat = Date.now();
     let consecutiveFailures = 0;
 
-    while (true) {
+    while (!ownerExitRequested) {
       let queue: any;
       try {
         queue = await client.getQueueStatus('clawclaw');
@@ -496,8 +631,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
   const resumeQueue = async (source: string): Promise<void> => {
     ensureEventSession(source);
     if (!readMatchState(stateDir)) startMatch(stateDir);
-    ensureDaemonRunning();
-    spawnOpeningMover();
+    await ensureEventRuntime();
     await pollQueue(true);
   };
   const recoverAlreadyInGame = async (): Promise<boolean> => {
@@ -510,8 +644,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
     const status = queueStatus(queue);
     if (status === 'allocated') {
       ensureEventSession('game_start_already_in_game');
-      ensureDaemonRunning();
-      spawnOpeningMover();
+      await ensureEventRuntime();
       await handleAllocated(queue, true);
       return true;
     }
@@ -525,40 +658,71 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
   const runningGameStartPid = getRunningGameStartPid(stateDir);
   if (runningGameStartPid) {
     if (opts.force) {
-      try { process.kill(runningGameStartPid, 'SIGKILL'); } catch {}
+      terminateProcessTree(runningGameStartPid, 'SIGKILL');
       try { unlinkSync(gameStartRuntimePath(stateDir)); } catch {}
+      try { unlinkSync(feedPath); } catch {}
     } else {
       emitLifecycle('already_running', { pid: runningGameStartPid },
         `A ccl game start stream is already running (pid ${runningGameStartPid}). To replace it, re-run with --force or stop it manually: taskkill /F /PID ${runningGameStartPid}`);
       return;
     }
   }
-
   let initialQueue: any;
   try {
     initialQueue = await client.getQueueStatus('clawclaw');
   } catch {}
   const plan = planGameStartAction({
     gameStartPid: null,
-    daemonPid: getRunningDaemonPid(stateDir),
     hasMatchState: readMatchState(stateDir) !== null,
     queueStatus: queueStatus(initialQueue),
-    feedPhase: readFeedPhase(feedPath),
   });
 
-  writeGameStartRuntime(stateDir, plan.kind);
-  try {
-    if (plan.kind === 'attach_daemon') {
-      ensureEventSession('game_start_attach_daemon');
-      if (!opts.watch) {
-        emitLifecycle('game_start', { mode: plan.kind },
-          'Game stream is active. Read summary; no additional events will follow from this --no-watch invocation.');
-        return;
-      }
-      await streamGame();
-      return;
+  ownerFeed = {
+    ...ownerFeed,
+    ts: new Date().toISOString(),
+    phase: plan.kind === 'resume_allocated' ? 'allocated' : 'matching',
+  };
+  ownerControl = await startOwnerControlServer(stateDir, async (request) => {
+    if (request.type === 'snapshot') {
+      return { ok: true, type: 'snapshot', summary: currentSummary() };
     }
-
+    if (request.type === 'stop') {
+      requestOwnerExit('stop', 'ccl game stop');
+      return { ok: true, type: 'stop' };
+    }
+    if (request.type === 'quit') {
+      requestOwnerExit('quit', 'ccl game quit');
+      return { ok: true, type: 'quit' };
+    }
+    if (request.type === 'leave') {
+      requestOwnerExit('leave', 'ccl game leave');
+      return { ok: true, type: 'leave' };
+    }
+    if (request.type === 'stop_strategy') {
+      stopOwnedStrategy();
+      return { ok: true, type: 'stop_strategy' };
+    }
+    if (request.type === 'switch_strategy') {
+      if (!request.strategy) return { ok: false, error: 'missing_strategy' };
+      stopOwnedStrategy();
+      const child = spawnStrategyLoop(request.strategy, request.args, {
+        source: 'manual',
+        detached: false,
+        writeRuntimeFiles: false,
+      });
+      strategyChild = child;
+      currentStrategy = request.strategy;
+      eventRuntime?.refreshFeed();
+      return { ok: true, type: 'switch_strategy', strategy: request.strategy, pid: child.pid };
+    }
+    return { ok: false, error: 'unsupported_owner_control_request' };
+  });
+  writeGameStartRuntime(stateDir, plan.kind, undefined, {
+    control: ownerControl.control,
+    token: ownerControl.token,
+  });
+  heartbeatTimer = startGameStartHeartbeat(stateDir, plan.kind);
+  try {
     if (plan.kind === 'resume_queue') {
       await resumeQueue('game_start_resume_queue');
       return;
@@ -566,8 +730,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
 
     if (plan.kind === 'resume_allocated') {
       ensureEventSession('game_start_resume_allocated');
-      ensureDaemonRunning();
-      spawnOpeningMover();
+      await ensureEventRuntime();
       await handleAllocated(initialQueue, true);
       return;
     }
@@ -590,24 +753,23 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
       return;
     }
 
-    const { stopStrategyIfRunning } = await import('../strategies/strategy-loop.js');
-    stopStrategyIfRunning();
-    stopOpeningMoverIfRunning();
+    stopOwnedStrategy();
 
     const events = EventStore.createSessionForActiveAccount();
     events.append({ type: 'session_started', source: 'game_start' });
     emitLifecycle('joined', joinResult,
-      'Match join request acknowledged. Spectate URL is in `events[0].url`; share it with the user. Daemon spawns next.');
+      'Match join request acknowledged. Spectate URL is in `events[0].url`; share it with the user. Game runtime is attached.');
     startMatch(stateDir);
-    if (getRunningDaemonPid(stateDir)) {
-      writeControl(stateDir, 'stop');
-      await waitDaemonExit(stateDir);
-    }
-    spawnDaemon();
-    spawnOpeningMover();
+    await ensureEventRuntime();
     await pollQueue(false);
   } finally {
-    cleanupGameStartRuntime(stateDir);
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    process.off('SIGINT', onOwnerSignal);
+    process.off('SIGTERM', onOwnerSignal);
+    eventRuntime?.stop('manual');
+    stopOwnedStrategy();
+    if (ownerControl) await ownerControl.close();
+    cleanupGameStartRuntime(stateDir, { removeFeed: true, controlPath: ownerControl?.control.path });
   }
 }
 
@@ -623,9 +785,7 @@ export function createGameCommand(): Command {
       const authStore = new AuthStore();
       const profile = authStore.getActive();
       if (!profile) throw new Error('Not logged in.');
-      const { stopStrategyIfRunning } = await import('../strategies/strategy-loop.js');
       stopStrategyIfRunning();
-      stopOpeningMoverIfRunning();
 
       const client = GameClient.fromAuth();
       const result = await client.joinQueue('clawclaw');
@@ -637,19 +797,12 @@ export function createGameCommand(): Command {
       // can compute `waited_secs` from a known anchor and emit the
       // match_waiting / match_timeout synthetic events.
       startMatch(stateDir);
-      if (getRunningDaemonPid(stateDir)) {
-        writeControl(stateDir, 'stop');
-        await waitDaemonExit(stateDir);
-      }
-      const { pid } = spawnDaemon();
-      console.log(JSON.stringify({ message: 'Event daemon started', pid }, null, 2));
-      spawnOpeningMover();
     });
 
   game
     .command('start')
     .alias('s')
-    .description('Attach to an active game stream or join queue, then stream events as NDJSON until game_over. Pass --no-watch to exit after allocation. Pass --force to replace an orphaned game-start stream.')
+    .description('Start or resume the owner game runtime, then stream events as NDJSON until game_over. Pass --no-watch to exit after allocation. Pass --force to replace an orphaned game-start runtime.')
     .option('--no-watch', 'exit after allocation instead of streaming events through game_over')
     .option('--force', 'force restart: kill any lingering game-start stream process and start fresh')
     .action(runGameStart);
@@ -711,7 +864,7 @@ export function createGameCommand(): Command {
             queue,
             waited_secs: waitedSecs,
             ...context,
-            next_step: 'Game allocated. Stop the queue loop. The game start stream (already running since `game join`) will surface subsequent gameplay events. Narrate the role / map / opening plan to the user.',
+            next_step: 'Game allocated. Launch `ccl game start` to attach the owner stream if it is not already running, then narrate the role / map / opening plan to the user.',
           }, null, 2));
           return;
         }
@@ -755,18 +908,13 @@ export function createGameCommand(): Command {
     .alias('l')
     .description('Leave queue')
     .action(async () => {
-      stopOpeningMoverIfRunning();
       const authStore = new AuthStore();
       const profile = authStore.getActive();
       if (profile) {
         const stateDir = getProfileStateDir(profile);
         endMatch(stateDir);
-        if (getRunningDaemonPid(stateDir)) {
-          writeControl(stateDir, 'stop');
-          await waitDaemonExit(stateDir);
-        }
+        await stopOwnerWithCommand(stateDir, 'leave');
       }
-      const { stopStrategyIfRunning } = await import('../strategies/strategy-loop.js');
       stopStrategyIfRunning();
       const client = GameClient.fromAuth();
       const result = await client.leaveQueue('clawclaw');
@@ -777,26 +925,27 @@ export function createGameCommand(): Command {
   game
     .command('stop')
     .alias('x')
-    .description('Stop event daemon')
+    .description('Stop local game runtime')
     .action(async () => {
       const authStore = new AuthStore();
       const profile = authStore.getActive();
       if (!profile) throw new Error('Not logged in.');
       const stateDir = getProfileStateDir(profile);
-      const pid = getRunningDaemonPid(stateDir);
-      stopOpeningMoverIfRunning();
-      if (!pid) {
-        console.log(JSON.stringify({ message: 'No daemon running.' }, null, 2));
+      const owner = await stopOwnerIfRunning(stateDir);
+      stopStrategyIfRunning();
+      if (!owner.stopped) {
+        console.log(JSON.stringify({ message: 'No game runtime running.' }, null, 2));
         return;
       }
-      writeControl(stateDir, 'stop');
-      await waitDaemonExit(stateDir);
-      console.log(JSON.stringify({ message: 'Daemon stopped.' }, null, 2));
+      console.log(JSON.stringify({
+        message: 'Game runtime stopped.',
+        ...(owner.pid ? { owner_pid: owner.pid } : {}),
+      }, null, 2));
     });
 
   game
     .command('quit')
-    .description('Leave active game and stop daemon')
+    .description('Leave active game and stop local runtime')
     .action(async () => {
       const authStore = new AuthStore();
       const profile = authStore.getActive();
@@ -806,16 +955,11 @@ export function createGameCommand(): Command {
       try {
         result = await client.leaveGame();
       } catch (err: any) {
-        throw new Error(err?.message ?? String(err));
+        result = { error: err?.message ?? String(err) };
       }
       const stateDir = getProfileStateDir(profile);
       endMatch(stateDir);
-      if (getRunningDaemonPid(stateDir)) {
-        writeControl(stateDir, 'stop');
-        await waitDaemonExit(stateDir);
-      }
-      stopOpeningMoverIfRunning();
-      const { stopStrategyIfRunning } = await import('../strategies/strategy-loop.js');
+      const owner = await stopOwnerWithCommand(stateDir, 'quit');
       stopStrategyIfRunning();
       const reminder = hubReminder(readCachedGamesPlayed());
       const out: Record<string, any> = (result && typeof result === 'object' && !Array.isArray(result))
@@ -825,6 +969,7 @@ export function createGameCommand(): Command {
         out.hub_reminder = reminder;
         out.next_step = `Left the game. ${reminder}`;
       }
+      if (owner.pid) out.owner_pid = owner.pid;
       console.log(JSON.stringify(out, null, 2));
     });