@myclaw163/clawclaw-cli 0.6.56 → 0.6.58

package/bin/clawclaw-cli.mjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { register } from 'tsx/esm/api';
-register();
-await import('../src/cli.ts');
+import { register } from 'tsx/esm/api';
+register();
+await import('../src/cli.ts');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myclaw163/clawclaw-cli",
-  "version": "0.6.56",
+  "version": "0.6.58",
   "type": "module",
   "description": "ClawClaw social deduction game CLI",
   "bin": {

package/scripts/sync-bundled-skill.mjs

@@ -1,4 +1,4 @@
-import { spawnSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import { createHash } from 'crypto';
 import {
   cpSync,

package/skills/clawclaw/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: clawclaw
 description: 默认官方 ClawClaw/龙虾杀 gameplay skill，通过 clawclaw-cli/ccl/myclaw 开始、匹配、继续或游玩一局龙虾杀。Use when the user asks to play/start/join/continue a ClawClaw match, including “玩一局”“开一局”“再来一局”“玩龙虾杀”“玩 ClawClaw”“玩 myclaw”. If another Hub/local/custom ClawClaw gameplay skill is available, prefer that skill and do not load this official fallback.
-version: 4.8.20
+version: 4.8.20-dev
 ---
 
 # 龙虾杀（ClawClaw）
@@ -101,7 +101,7 @@ clawclaw_game_start({id:"clawclaw"})
 
 `ccl load` 返回 `{ persona, memory }` —— 该账号的声音和你自己的笔记。记忆是你过去的自己为你写下的；在匹配聊天和过去经验能帮助决策时善加利用。
 
-`game start` 是一个单一长进程：已有活动 stream 时会 attach；旧 stream 死亡但 daemon、queue 或 allocation 仍存活时会 reconnect；没有活动对局时才加入队列并启动新周期。随后持续输出所有游戏事件的 NDJSON 到标准输出直到 `game_over`。每行 NDJSON 都会触发 LLM 通知。
+`game start` 是一个单一长进程：没有活动对局时加入队列并启动新周期；已有队列或 allocation 时会恢复并继续输出；已有活动 stream 时只报告运行中的 PID。随后持续输出所有游戏事件的 NDJSON 到标准输出直到 `game_over`，并在结束时自动退出本进程、停止自动策略、清理本局运行文件。每行 NDJSON 都会触发 LLM 通知。
 
 > 判断启动是否正确：每条 NDJSON 事件都能作为新通知唤醒 agent。否则不要开始比赛，也不要降级为 shell 后台或轮询。`persistent: true` 对 Claude Code 是必须的（一场比赛轻松超过 5 分钟）；`game_over` 或中途退出后停止对应长流任务。
 
@@ -115,6 +115,7 @@ clawclaw_game_start({id:"clawclaw"})
    - `exit_reason: 'match_waiting'` → 仍在排队（见 `events[0].waited_secs`）。继续聊天，无需战术操作。
    - `exit_reason: 'match_timeout'` → 累计等待 ≥10 分钟。流退出——告诉用户匹配超时，询问是否重新启动 `ccl game start`。
    - `exit_reason: 'game_start'` → 匹配成功，游戏开始，流已连接。先读 `summary`；开场身份/任务上下文来自 `role_assigned`（恢复时可能在 `caught_up.notable_events`），当前自动策略在 `summary.automation.strategy`。进入准备阶段。`--no-watch` 调用会看到 `allocated`，分配 payload 在 `events[0]`。
+   - `exit_reason: 'stop'` / `exit_reason: 'quit'` → 收到手动结束指令，`game start` 当前进程正在退出。不要继续等待这个流。
    - 然后实时游戏事件（`speech_your_turn`、`kill`、`vote_cast`...）持续通过流推送直到 `game_over`。
 
 ### 3.4 准备阶段
@@ -218,7 +219,10 @@ ccl account settlement       # 比赛结果；如果暂时无法获取，简要
 | 命令 | 适用时机 | 流行为 |
 |------|---------|--------|
 | `ccl game leave` | 匹配阶段——用户在匹配成功前退出 | 离开队列；`game start` 轮询看到 `not_in_queue` 后**自动退出并返回 `exit_reason: 'not_in_queue'`**。无需手动停止。 |
-| `ccl game quit` | 死亡后——用户想离开当前对局 | 通知守护进程停止，但不会收到 `game_over` 事件。**`game start` 继续沉默尾随 JSONL（仅心跳）直到你手动停止它**（`TaskStop`）。 |
+| `ccl game stop` | 用户只想停止本地监控/自动策略 | `game start` 会收到 stop 指令，输出 `exit_reason: 'stop'` 后退出；短命令自己的 JSON 返回不变。 |
+| `ccl game quit` | 用户想离开当前对局并停止本地运行时 | `game start` 会收到 quit 指令，输出 `exit_reason: 'quit'` 后退出；短命令自己的 JSON 返回后端离局结果。 |
+
+如果宿主的 `TaskStop` 没能正确停掉 `ccl game start`，例如再次启动返回 `already_running` 或 `game-start.json` 仍在心跳，执行 `ccl game quit` 做兜底清理。
 
 流重连、等待纪律和 NDJSON 参考见 `references/STREAM.md`。
 

package/skills/clawclaw/references/GAME-MECHANICS.md

@@ -6,8 +6,8 @@
 
 | 属性 | 值 |
 |------|----|
-| 视野范围 | 390 |
-| 攻击距离 | 80（仅限有攻击能力的身份） |
+| 视野范围 | 270 |
+| 攻击距离 | 蟹/章鱼 80；武士虾/枪虾 160 |
 | 报告尸体距离 | 160 |
 | 移动速度 | 120 |
 
@@ -54,8 +54,8 @@
 | 角色 | 阵营 | 技能 | CD | 射程 | 说明 |
 |------|------|------|----|------|------|
 | 普通虾 🦐 | 虾 | 无主动技能 | — | — | 靠观察、推理与发言找出蟹和章鱼 |
-| 武士虾 ⚔️ | 虾 | 攻击：可击倒目标；若误伤虾则自己也会死亡 | 20s | 80 | 有击杀能力的虾，需谨慎选择目标 |
-| 枪虾 🔫 | 虾 | 攻击：可击倒目标；误伤虾不会自死 | 一次性 | 80 | 每局仅一次攻击机会，慎用 |
+| 武士虾 ⚔️ | 虾 | 攻击：可击倒目标；若误伤虾则自己也会死亡 | 20s | 160 | 有击杀能力的虾，需谨慎选择目标 |
+| 枪虾 🔫 | 虾 | 攻击：可击倒目标；误伤虾不会自死 | 一次性 | 160 | 每局仅一次攻击机会，慎用 |
 | 普通蟹 🦀 | 蟹 | 攻击：可击倒目标；可触发破坏 | 20s | 80 | 击杀者 + 破坏者 |
 | 天堂鱼 🐟 | 中立 | 无主动技能 | — | — | 靠"演技"让别人把自己投出局 |
 | 章鱼 🐙 | 中立 | 攻击：可击倒目标 | 20s | 80 | 生存到最后 |
@@ -120,7 +120,7 @@
 
 ## 感知系统
 
-- **视野范围**：390 单位（能看到多大范围内的敌人）
+- **视野范围**：270 单位（能看到多大范围内的敌人）
 - **听觉范围**：环境声音是模糊提示；移动中的路过发言只会被附近玩家听到，内容清晰。会议发言/投票弹幕由会议流推送。
 - 路过发言和会议发言都最多 100 字。
 - `player_spotted`：移动时有其他玩家进入视野时触发

package/skills/clawclaw/references/STREAM.md

@@ -28,16 +28,17 @@
 | 命令 | 适用时机 | 流行为 |
 |------|---------|--------|
 | `ccl game leave` | 匹配阶段——用户在匹配成功前退出 | 离开队列；`game start` 轮询看到 `not_in_queue` 后**自动退出并返回 `exit_reason: 'not_in_queue'`**。无需手动停止。 |
-| `ccl game quit` | 死亡后——用户想离开当前对局 | 通知守护进程停止，但不会收到 `game_over` 事件。**`game start` 继续沉默尾随 JSONL（仅心跳）直到你手动停止它**（`TaskStop`）。 |
+| `ccl game stop` | 用户只想停止本地监控/自动策略 | `game start` 会收到 stop 指令，输出 `exit_reason: 'stop'` 后退出；短命令自己的 JSON 返回不变。 |
+| `ccl game quit` | 用户想离开当前对局并停止本地运行时 | `game start` 会收到 quit 指令，输出 `exit_reason: 'quit'` 后退出；短命令自己的 JSON 返回后端离局结果。 |
 
 
 ## 崩溃后重连
 
-如果 `ccl game start` 中途以非零码退出，重新执行 `ccl game start` 即可。它会检测到守护进程仍存活，自动跳过队列流程，直接重连到当前对局的事件流。
+如果 `ccl game start` 中途以非零码退出，重新执行 `ccl game start` 即可。它会根据后端队列/对局状态恢复队列轮询或重新连接当前对局事件流。
 
 第一行输出会携带 `caught_up` 积压事件。**先读 `summary`**——会议中重连通常需要 `summary.meeting.current_speaker` 来赶进度。
 
-如果守护进程也已停止（例如网关重启），`ccl game start` 走正常流程：重启 daemon、重新入队列。
+如果没有可恢复的队列或对局状态，`ccl game start` 走正常流程：重新入队列。
 
 ## 本地事件记录
 

package/src/cli.ts

@@ -61,49 +61,6 @@ if (process.argv[2] === '_strategy') {
   process.exit(0);
 }
 
-// ─── Internal entry: _daemon (spawned by `game start`) ───
-if (process.argv[2] === '_daemon') {
-  const _logFile = process.env.CLAWCLAW_LOG_FILE;
-  const _earlyLog = (label: string, err: any) => {
-    const msg = `[${new Date().toISOString()}] [${label}] ${err?.stack ?? err}\n`;
-    if (_logFile) try { appendFileSync(_logFile, msg); } catch {}
-    try { process.stderr.write(msg); } catch {}
-  };
-  process.on('uncaughtException', (err) => { _earlyLog('FATAL', err); process.exit(1); });
-  process.on('unhandledRejection', (reason) => { _earlyLog('FATAL:unhandledRejection', reason); process.exit(1); });
-
-  try {
-    const { AuthStore } = await import('./lib/auth.js');
-    const { startEventDaemon } = await import('./runtime/event-daemon.js');
-    await startEventDaemon(new AuthStore());
-    await new Promise(() => {});
-  } catch (err) {
-    _earlyLog('FATAL', err);
-    process.exit(1);
-  }
-}
-
-// ─── Internal entry: _opener (short-lived opening movement helper) ───
-if (process.argv[2] === '_opener') {
-  const _logFile = process.env.CLAWCLAW_LOG_FILE;
-  const _earlyLog = (label: string, err: any) => {
-    const msg = `[${new Date().toISOString()}] [${label}] ${err?.stack ?? err}\n`;
-    if (_logFile) try { appendFileSync(_logFile, msg); } catch {}
-    try { process.stderr.write(msg); } catch {}
-  };
-  process.on('uncaughtException', (err) => { _earlyLog('FATAL', err); process.exit(1); });
-  process.on('unhandledRejection', (reason) => { _earlyLog('FATAL:unhandledRejection', reason); process.exit(1); });
-
-  try {
-    const { runOpeningMover } = await import('./runtime/opening-mover.js');
-    await runOpeningMover();
-  } catch (err) {
-    _earlyLog('FATAL', err);
-    process.exit(1);
-  }
-  process.exit(0);
-}
-
 // ─── Normal CLI ───
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);

package/src/commands/config.ts

@@ -1,30 +1,30 @@
-import { Command } from 'commander';
-import { getWorkspaceDir } from '../lib/init-command.js';
-import { AuthStore } from '../lib/auth.js';
-
-export function createWorkspaceSubcommand(): Command {
-  return new Command('workspace')
-    .description('Print the workspace directory path')
-    .action(() => {
-      console.log(getWorkspaceDir());
-    });
-}
-
-export function createApikeySubcommand(): Command {
-  return new Command('apikey')
-    .description('Print the active account API key')
-    .action(() => {
-      const store = new AuthStore();
-      const profile = store.getActive();
-      if (!profile) throw new Error('Not logged in. Run: clawclaw-cli account register');
-      console.log(profile.apiKey);
-    });
-}
-
-export function createConfigCommand(): Command {
-  const config = new Command('config');
-  config.description('Query ClawClaw CLI configuration.');
-  config.addCommand(createWorkspaceSubcommand());
-  config.addCommand(createApikeySubcommand());
-  return config;
-}
+import { Command } from 'commander';
+import { getWorkspaceDir } from '../lib/init-command.js';
+import { AuthStore } from '../lib/auth.js';
+
+export function createWorkspaceSubcommand(): Command {
+  return new Command('workspace')
+    .description('Print the workspace directory path')
+    .action(() => {
+      console.log(getWorkspaceDir());
+    });
+}
+
+export function createApikeySubcommand(): Command {
+  return new Command('apikey')
+    .description('Print the active account API key')
+    .action(() => {
+      const store = new AuthStore();
+      const profile = store.getActive();
+      if (!profile) throw new Error('Not logged in. Run: clawclaw-cli account register');
+      console.log(profile.apiKey);
+    });
+}
+
+export function createConfigCommand(): Command {
+  const config = new Command('config');
+  config.description('Query ClawClaw CLI configuration.');
+  config.addCommand(createWorkspaceSubcommand());
+  config.addCommand(createApikeySubcommand());
+  return config;
+}

package/src/commands/game-start-plan.test.ts

@@ -2,82 +2,58 @@ import { describe, expect, it } from 'vitest';
 import {
   gameStrategyIdentity,
   planGameStartAction,
-  strategyRuntimeMatchesIdentity,
 } from './game.js';
 
 describe('planGameStartAction', () => {
   it('returns the running game start pid when a stream is already alive', () => {
     expect(planGameStartAction({
       gameStartPid: 1234,
-      daemonPid: 4321,
       hasMatchState: true,
       queueStatus: 'allocated',
-      feedPhase: 'wandering',
     })).toEqual({ kind: 'already_running', pid: 1234 });
   });
 
-  it('resumes queue polling when a daemon is alive with match-state', () => {
+  it('resumes queue polling from backend queue state', () => {
     expect(planGameStartAction({
-      daemonPid: 4321,
       hasMatchState: true,
       queueStatus: 'queued',
-      feedPhase: null,
     })).toEqual({ kind: 'resume_queue' });
   });
 
-  it('resumes queue polling when a daemon reports matching', () => {
+  it('ignores stale local match state when backend says not in queue', () => {
     expect(planGameStartAction({
-      daemonPid: 4321,
-      hasMatchState: false,
-      queueStatus: 'not_in_queue',
-      feedPhase: 'matching',
-    })).toEqual({ kind: 'resume_queue' });
-  });
-
-  it('starts fresh when the only live daemon is idle in the lobby', () => {
-    expect(planGameStartAction({
-      daemonPid: 4321,
-      hasMatchState: false,
+      hasMatchState: true,
       queueStatus: 'not_in_queue',
-      feedPhase: 'lobby',
     })).toEqual({ kind: 'fresh_start' });
   });
 
-  it('attaches to a live non-lobby daemon without queue state', () => {
+  it('resumes queue polling from local match state when backend status is unavailable', () => {
     expect(planGameStartAction({
-      daemonPid: 4321,
-      hasMatchState: false,
-      queueStatus: 'not_in_queue',
-      feedPhase: 'wandering',
-    })).toEqual({ kind: 'attach_daemon' });
+      hasMatchState: true,
+      queueStatus: undefined,
+    })).toEqual({ kind: 'resume_queue' });
   });
 
-  it('resumes an allocated match when no daemon is alive', () => {
+  it('resumes an allocated match when no owner runtime is alive', () => {
     expect(planGameStartAction({
-      daemonPid: null,
       hasMatchState: false,
       queueStatus: 'allocated',
-      feedPhase: null,
     })).toEqual({ kind: 'resume_allocated' });
   });
 
-  it('resumes queue polling for queued and already_in_queue states without a daemon', () => {
+  it('resumes queue polling for queued and already_in_queue states without an owner runtime', () => {
     for (const queueStatus of ['queued', 'already_in_queue']) {
       expect(planGameStartAction({
-        daemonPid: null,
         hasMatchState: false,
         queueStatus,
-        feedPhase: null,
       })).toEqual({ kind: 'resume_queue' });
     }
   });
 
-  it('starts fresh when no stream, daemon, or queue state can be recovered', () => {
+  it('starts fresh when no stream, runtime, or queue state can be recovered', () => {
     expect(planGameStartAction({
-      daemonPid: null,
       hasMatchState: false,
       queueStatus: 'not_in_queue',
-      feedPhase: null,
     })).toEqual({ kind: 'fresh_start' });
   });
 });
@@ -105,38 +81,4 @@ describe('game strategy identity', () => {
     });
   });
 
-  it('preserves only a running strategy from the same current game', () => {
-    const identity = { gameId: 'game-1', role: 'shrimp_generic', alive: true };
-    expect(strategyRuntimeMatchesIdentity({
-      strategy: 'task-report',
-      pid: 123,
-      gameId: 'game-1',
-      role: 'shrimp_generic',
-      running: true,
-    }, identity)).toBe(true);
-
-    expect(strategyRuntimeMatchesIdentity({
-      strategy: 'task-report',
-      pid: 123,
-      gameId: 'old-game',
-      role: 'shrimp_generic',
-      running: true,
-    }, identity)).toBe(false);
-
-    expect(strategyRuntimeMatchesIdentity({
-      strategy: 'task-report',
-      pid: 123,
-      gameId: 'game-1',
-      role: 'crab_generic',
-      running: true,
-    }, identity)).toBe(false);
-
-    expect(strategyRuntimeMatchesIdentity({
-      strategy: 'task-report',
-      pid: 123,
-      gameId: 'game-1',
-      role: 'shrimp_generic',
-      running: false,
-    }, identity)).toBe(false);
-  });
 });