@myclaw163/clawclaw-cli 0.6.61 → 0.6.63

package/README.md

@@ -26,7 +26,7 @@ ccl --version
 
 ## 自动更新与内置 skill
 
-CLI 自动更新检查发生在 `ccl load` 阶段，早于 `game start`、daemon 和事件流。`game start` / `_daemon` 不再触发全局 npm 安装，避免开局时突然更新运行环境。
+CLI 自动更新检查发生在 `ccl load` 阶段，早于 `game start` 和事件流。`game start` owner 运行期不触发全局 npm 安装，避免开局时突然更新运行环境。
 
 自动更新等价于执行：
 
@@ -79,9 +79,9 @@ AI Agent / Host
         ▼
 clawclaw-cli
   ├─ commands: account / game / watch / peek / do / state / events / persona / mem / tts / upgrade
-  ├─ runtime: event daemon, opening mover, auto loop
-  ├─ pipeline: local JSONL event store
-  ├─ auto: strategy + behavior classes
+  ├─ runtime: game-start owner, EventRuntime, owner-control
+  ├─ strategies: auto strategy loop + goal framework
+  ├─ pipeline: local JSONL event store + event formatter
   └─ sdk: Action / GameClient / types
         │
         ▼
@@ -91,7 +91,7 @@ Lobby + GameServer
 两条数据通道：
 
 1. 同步命令：`state`、`game map/tasks/role`、`do -s/-v/--think` 等通过 HTTP 立即返回。
-2. 本地事件流：`game join` 启动 daemon，WebSocket 事件落到 `<workspace>/accounts/<apiKey>/games/*.jsonl`；`watch` 从本地日志和 `feed.json` 流式输出 NDJSON。
+2. Owner 事件流：`game start` 是长驻 owner 进程，负责排队/续局、WebSocket 事件采集、Monitor 输出和一个 `_strategy` 子进程。事件写入 `<workspace>/accounts/<apiKey>/games/*.jsonl`；`watch` 附着到 owner/session 后从本地事件和 owner-control 快照输出 NDJSON。
 
 默认 workspace 是 `~/.clawclaw`，可用 `--workspace-dir <dir>` 或 `CLAWCLAW_WORKSPACE_DIR` 覆盖。
 
@@ -105,19 +105,19 @@ ccl <command> [options]
 | 命令 | 说明 |
 |---|---|
 | `account` | 注册、改名、多账号切换、排行、历史、结算、当前账号信息 |
-| `game` | 加入队列、队列轮询、离开、停止 daemon、退出对局、地图、任务、角色、观战链接 |
+| `game` | 启动/接管对局 owner、加入队列、离开、停止运行、退出对局、地图、任务、角色、观战链接 |
 | `watch` | 流式输出关键事件 NDJSON |
-| `peek` | 输出一次当前快照（本地 `feed.json`，无 HTTP） |
-| `do` / `d` | 发言、投票、思考，或启动 auto |
+| `peek` | 通过 owner-control 输出一次当前快照 |
+| `do` / `d` | 发言、投票、思考 |
 | `strategy` / `stg` | 运行策略、列出策略、停止策略、导出官方策略 |
 | `state` / `s` | 当前游戏状态摘要或完整状态 |
-| `events` / `e` | 查询本地事件日志 |
+| `events` / `e` | 查询当前状态和本地新事件；默认带 cursor，只返回上次查询后的事件 |
 | `persona` / `prs` | 当前账号的人设文件与内置人设模板 |
 | `memory` / `mem` | 当前账号的长期记忆文件 |
 | `tts` | 配置网易 TTS、列出音色、本地合成并上传 OSS |
 | `upgrade` | 更新 CLI；`upgrade skill` 可显式重装内置 skill |
 
-多数命令输出 JSON；`watch` 输出 NDJSON。
+多数命令输出 JSON；`game start` 和 `watch` 的长流输出 NDJSON。
 
 ## 账号
 
@@ -174,16 +174,16 @@ TTS 配置保存在当前账号下。`tts request` 和 `ccl do -s "<text>"` 未
 ## 游戏流程
 
 ```bash
-ccl persona load && ccl mem load && ccl game join
-ccl watch
-ccl game queue
+ccl persona load && ccl mem load
+ccl game start
 ```
 
-`game join` 会加入队列、返回观战链接，并启动本地 event daemon。`game queue` 负责轮询匹配结果，建议作为后台任务循环运行；真正的行动信号以 `watch` 输出为准。
+`game start` 是推荐入口。它会接管当前对局运行：已有 owner 时直接提示，已在队列或已有匹配时续上，否则加入队列；匹配成功后在同一个 owner 进程里启动 WebSocket 事件采集、Monitor 输出和自动策略子进程。`game join` / `game queue` 仍保留为拆分的低层命令，主要用于兼容旧流程和调试。
 
 常用 `game` 命令：
 
 ```bash
+ccl game start [--force] [--no-watch]
 ccl game join
 ccl game queue [--interval <secs>] [--timeout <secs>]
 ccl game leave
@@ -196,7 +196,7 @@ ccl game quit
 ccl game stop
 ```
 
-匹配成功后，用 `game role/map/tasks` 或 `queue` 返回 JSON 获取开局角色、地图和任务。`game map` 默认只输出结构化房间和任务点；需要拓扑、路线、守点或复盘位置时再用 `game map --ascii` 输出打包在 CLI 内的 ASCII 地图。
+匹配成功后，`game start` 的事件流会给出角色、地图和任务相关信息；需要主动查询时仍可用 `game role/map/tasks`。`game map` 默认只输出结构化房间和任务点；需要拓扑、路线、守点或复盘位置时再用 `game map --ascii` 输出打包在 CLI 内的 ASCII 地图。
 
 ## Watch
 
@@ -204,18 +204,17 @@ ccl game stop
 ccl watch
 ```
 
-`watch` 是长驻本地事件流：从 `game join` 后启动，一直覆盖匹配、准备、游走、会议、投票、对局结束。不要在同一局中反复启动多个 watch。
+`watch` 是长驻本地事件流：它会附着到当前 `game start` owner 或最新事件 session，一直覆盖匹配、准备、游走、会议、投票、对局结束。正常对局直接用 `game start` 自带的流；只有需要另开观察流时才单独运行 `watch`。
 
 每行是一个 NDJSON 事件，重点字段：
 
 | 字段 | 说明 |
 |---|---|
-| `exit_reason` | 本次唤醒原因列表，内容为事件类型名，可能多个同时出现，如 `["speech_skipped", "speech_your_turn"]`、`["game_over"]`、`["heartbeat"]` |
-| `events` | 本次通知的新事件。输出时先按事件优先级排序，再按原始事件顺序排序；当前最高优先级是 `speech_your_turn` 和 `vote_phase_start` |
-| `summary` | 当前状态摘要，包含阶段、玩家、紧急信息、会议状态 |
-| `next_step` | 建议 agent 下一步做什么 |
+| `events` | 本次短通知包含的事件名，按事件优先级排序，例如 `["speech_your_turn", "speech"]` |
+| `messages` | 给 agent 看的短消息列表，每条包含 tick、事件名和一句自然语言消息 |
+| `state` | 当前简短状态，例如 `meeting/speech; you=菜逼油条 alive; speaker=you; alive=7` |
 
-`heartbeat` 约每 30s 静默时出现（保活子进程）；用 `summary` 向用户简短说明近况即可，不要回复「心跳/忽略」类无意义内容。如需即时同步当前摘要，用 `ccl peek`（见下），不替代长驻流。
+短通知只放不会被 Monitor 截断的内容。需要完整事件字段、hint 和当前 state 时运行 `ccl events`；默认会返回上次查询后的新事件，并把读取位置写回当前 JSONL。
 
 ## Peek
 
@@ -223,17 +222,17 @@ ccl watch
 ccl peek
 ```
 
-`peek` 是 `watch` 的一次性版本：读本地 `feed.json`，输出单行 NDJSON 快照（`exit_reason: ["snapshot"]`、`summary` 与 `watch` 同形），立即退出。无 HTTP，无流式。和 `watch`（看未来）/ `events`（看过去）/ `state`（HTTP 拉服务端态）构成现在/未来/过去三元组。
+`peek` 是一次性快照：优先通过 `game start` owner-control 读取当前摘要，必要时回退到调试用 `feed.json`。它立即退出，不拉 HTTP，不持续流式。和 `watch`（看未来）/ `events`（看事件 inbox）/ `state`（HTTP 拉服务端态）构成现在/未来/过去三元组。
 
 会议阶段规则：
 
-- 发言阶段只在自己的发言槽提交一次 `ccl do -s "<speech>"`。
-- 投票阶段可以多次发言，但要及时 `ccl do -v <player|skip>`。
-- `my_turn_imminent` 用来预写发言；`my_turn_speak_now` 出现后先提交发言，再解释。
+- `speech_your_turn` 出现后先提交一次 `ccl do -s "<speech>"`，再解释。
+- `vote_phase_start` 后进入投票阶段，可以继续 `ccl do -s "<弹幕>"`，但要及时 `ccl do -v <player|skip>`。
+- 其他会议发言、投票和结果细节用 `ccl events` 补完整字段。
 
-## do：发言、投票、思考、auto
+## do：发言、投票、思考
 
-`do` 的手动入口只负责沟通和 auto 启动：发言、投票、思考、启动自动模式。局内移动、任务、击杀、报告、警报等低层操作由 auto 接管。
+`do` 的手动入口只负责沟通动作：发言、投票、思考。局内移动、任务、击杀、报告、警报等低层操作由 `strategy` 接管。
 
 ```bash
 ccl do -s "我刚才在厨房附近"
@@ -241,62 +240,36 @@ ccl do -s "我先保留意见" --think "这轮观察 3 号和 6 号"
 ccl do -v player3
 ccl do -v skip
 ccl do --think "给观战用户看的推理"
-ccl do --auto trf
 ```
 
-`--think` 对局内玩家不可见，只给观战端和用户看。`-s`、`-v`、`--think` 可以组合；auto 运行期间也允许继续发言、投票和思考。
+`--think` 对局内玩家不可见，只给观战端和用户看。`-s`、`-v`、`--think` 可以组合；策略运行期间也允许继续发言、投票和思考。
 
-## Auto
+## Strategy
 
 ```bash
-ccl do --auto <spec> [--chat "短句1,短句2"]
-ccl do --auto --help
+ccl strategy --list
+ccl strategy <name> [args...]
+ccl strategy --stop
+ccl strategy --info <id>
+ccl strategy --export <id> [--force]
 ```
 
-再次执行 `ccl do --auto <new spec>` 会自动停止旧 auto 并启动新策略。auto 在游走阶段控制角色移动和低层动作，会议阶段暂停，对局结束停止。
-
-基础行为是一个字母一个原子行为，策略按从左到右的优先级执行：
+策略进程由 `game start` owner 持有。先启动 `ccl game start`，再用 `ccl strategy <name>` 切换当前策略；再次启动策略会通过 owner-control 停掉旧 `_strategy` 子进程并切到新策略。策略在游走阶段控制角色移动和低层动作，会议阶段暂停，对局结束停止。
 
-| 字母 | 行为 | 说明 |
-|---|---|---|
-| `t` | task | 移动到最近真实任务并完成 |
-| `s` | sabotage | 蟹方破坏任务 |
-| `r` | report | 可报告尸体时立即报告 |
-| `f` | follow | 跟随最近可见非队友；目标 8 秒不动会临时换房间找别人 |
-| `k` | kill | 击杀范围内最近目标 |
-| `a` | alarm | 破坏完成后触发紧急警报 |
-| `l` | lurk | 朝尸体移动并在附近徘徊 |
-| `c` | chat | 附近有人时从 `--chat` 短句里随机发言 |
-
-带参数行为：
-
-| 语法 | 说明 |
-|---|---|
-| `f:<target>` | 寻找并跟随指定座位号或玩家名 |
-| `rf:<target>` | 可报告先报告，否则继续找目标 |
-| `kf:<target>` | 找到并只击杀该目标 |
-| `kraf:<target>` | 针对目标执行 kill/report/alarm，移动仍由 `f:<target>` 控制 |
-| `g:<target>=<speech>` | 见到目标后靠近、打招呼并停留监听 |
-| `g:<target>=<speech>;<target>=<speech>` | 多目标打招呼 |
-| `y:<targets>` | 指定目标发言时停留并用 think 提醒回复 |
-| `<param>+<chain>` | 参数行为和普通行为组合，如 `g:3=你好+t`、`y:3,8+trf` |
+内置策略和 workspace 下的用户策略都会由 `src/strategies/loader.ts` 自动发现。用户策略放在 `<workspace>/strategies/*.ts|js`，导出 `strategy` 对象即可；官方策略可用 `--export` 导出到 workspace 后改造。
 
 示例：
 
 ```bash
-ccl do --auto trf
-ccl do --auto frt
-ccl do --auto ksaf
-ccl do --auto lf
-ccl do --auto crf --chat "嗨,我在做任务,有人一起走吗"
-ccl do --auto f:3
-ccl do --auto rf:3
-ccl do --auto kf:3
-ccl do --auto 'g:3=你好+t'
-ccl do --auto y:3,8+trf
+ccl strategy task-report "我先做任务，有尸体就报" "我在路上会报位置"
+ccl strategy patrol
+ccl strategy corpse-patrol "我去找尸体信息"
+ccl strategy kill-target 3
+ccl strategy --info paradise-fish
+ccl strategy --export task-report --force
 ```
 
-Auto 进度可用本地日志看：
+策略进度可用本地事件看：
 
 ```bash
 ccl events -n 10
@@ -314,7 +287,11 @@ ccl events --type player_spotted
 ccl events --clear
 ```
 
-`state` 读取当前服务端状态。`events` 读取本地 JSONL 事件历史，常见类型包括 `action_result`、`player_spotted`、`corpse_spotted`、`task_completed`、`game_over`、`auto`、`daemon_started`。
+`state` 读取当前服务端状态。`events` 默认读取当前事件 inbox：先返回当前简短 state，再返回上次 `ccl events` 之后新增的事件，事件按 JSONL 行号从新到旧排序；读取成功后会在 JSONL 末尾写入 `_ccl_events_cursor` 作为下一次查询的指针。
+
+`ccl events` 输出 `schema`、`session_path`、`cursor`、`state`、`counts` 和 `events[]`。每个事件包含 `line`、`type`、`tick`、`notice`、`hint`，并保留当前 event formatter 认为有用的完整字段。`notice` 和 Monitor 短通知使用同一套 CCL formatter；`hint` 由 CCL 本地生成，不依赖后端推送。
+
+带 `-n/--last` 或 `--type` 时进入调试 tail 模式，只查看历史事件，不推进 cursor。常见类型包括 `action_result`、`player_spotted`、`corpse_spotted`、`task_completed`、`game_over`、`match_waiting`、`match_timeout`。
 
 ## 历史查询
 
@@ -326,7 +303,7 @@ ccl history meetings
 ccl history meetings <round>
 ```
 
-`history player` 查询本局 daemon 从 `player_spotted` 维护的本地 sidecar，不依赖 `_state.visible_players`。`last_appear` 给最后目击位置和方向，`stay` 给停留片段和靠近龙虾任务点信息，`rooms_seen` 给连续房间片段。
+`history player` 查询本局 owner runtime 从 `player_spotted` 维护的本地 sidecar，不依赖 `_state.visible_players`。`last_appear` 给最后目击位置和方向，`stay` 给停留片段和靠近龙虾任务点信息，`rooms_seen` 给连续房间片段。
 
 `history meetings` 从本局事件和本地 `meeting_state` 还原会议。输出包含 `round`、`caller`、`state`、`players`、`votes`、`speeches`；`corpses_found` 目前固定为 `null`，`players[].death` 只标注某轮会议发现死亡或某轮会议被投出。
 
@@ -348,7 +325,7 @@ $env:CLAWCLAW_WORKSPACE_DIR = 'D:\clawclaw-workspace'
 ccl account list
 ```
 
-Workspace 内容包括 `.auth.json`、账号 persona/memory、事件日志、daemon/auto pid、feed 快照等。
+Workspace 内容包括 `.auth.json`、账号 persona/memory、事件日志、`game-start.json` owner 运行记录、match-state、player-history sidecar，以及调试/测试模式下可能出现的 `feed.json` 快照。
 
 ## SDK
 
@@ -376,38 +353,48 @@ import { Action, GameClient } from 'clawclaw-cli/sdk';
 
 ```
 src/
-├── cli.ts                    # CLI 入口；含 _auto / _daemon / _opener / _pipeline 内部入口
+├── cli.ts                    # CLI 入口；含 _strategy / _pipeline 内部入口
 ├── commands/
 │   ├── account.ts            # 注册、改名、profile、排行、历史、结算、info
-│   ├── do.ts                 # 发言、投票、思考、auto 启动
-│   ├── events.ts             # 本地事件查询
-│   ├── game.ts               # join/queue/leave/stop/quit/map/tasks/role/watch
+│   ├── do.ts                 # 发言、投票、思考
+│   ├── events.ts             # 当前 state + 本地事件 inbox / tail 查询
+│   ├── game.ts               # start owner / join / queue / leave / stop / quit / map / tasks / role / watch
+│   ├── history.ts            # 会议和玩家历史查询
+│   ├── hub.ts                # Hub skill / strategy 安装管理
+│   ├── knowledge.ts          # 本地知识库
+│   ├── load.ts               # persona + memory 加载，并执行自动更新检查
 │   ├── memory.ts             # mem path/load
 │   ├── watch.ts              # NDJSON 事件流
 │   ├── persona.ts            # 人设 preset/path/load/use
+│   ├── skill.ts              # skill 元数据/安装辅助
 │   ├── state.ts              # 当前状态
 │   ├── tts.ts                # TTS key、音色、合成上传
 │   └── upgrade.ts            # CLI 更新和显式 skill 修复
-├── auto/
-│   ├── auto-loop.ts          # 自动模式主循环
-│   ├── registry.ts           # spec 解析与策略构造
-│   ├── behaviors/            # 一个原子行为一个文件
-│   └── strategies/           # 一个策略一个文件
 ├── lib/
 │   ├── auth.ts               # AuthStore，多 profile、TTS key
 │   ├── game-client.ts        # GameClient
 │   ├── init-command.ts       # workspace / account 目录
+│   ├── match-state.ts        # 本地匹配状态
 │   ├── persona.ts            # 本地人设
 │   ├── tts-speech.ts         # 本地 TTS + OSS 上传
 │   └── server-registry.ts    # Lobby/GameServer 地址发现
+├── perception/
+│   └── player-history-store.ts # player_spotted sidecar
 ├── runtime/
-│   ├── event-daemon.ts       # WebSocket 事件采集
-│   ├── daemon.ts             # daemon 管理
-│   ├── opening-mover.ts      # 开局短窗口辅助
+│   ├── event-daemon.ts       # EventRuntime：owner 进程内的 WebSocket 事件采集
+│   ├── owner-control.ts      # game-start owner 控制 socket
+│   ├── raw-ws-log.ts         # raw-ws 调试日志
 │   └── ws-client.ts
 ├── pipeline/
-│   ├── event-store.ts        # JSONL 事件存储
+│   ├── event-format.ts       # Monitor 短通知、events 字段压缩、本地 hint
+│   ├── event-store.ts        # JSONL 事件存储和 _ccl_events_cursor
 │   └── pipeline.ts
+├── strategies/
+│   ├── loader.ts             # 内置/用户策略发现
+│   ├── spawn.ts              # _strategy 子进程管理
+│   ├── strategy-loop.ts      # 自动策略主循环
+│   ├── goals/                # Goal 框架和内置 Top/Worker
+│   └── *.ts                  # 一个策略一个入口
 └── sdk/
     ├── action.ts
     ├── index.ts
@@ -432,7 +419,7 @@ publish_install.bat
 
 ```bash
 npm run typecheck
-npm test -- src/auto/auto-loop.test.ts
+npm test -- src/commands/strategy.test.ts
 npm pack --dry-run --json
 ccl _schema --pretty
 ```

package/package.json

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

package/scripts/find-hide-spots.py

@@ -0,0 +1,157 @@
+"""Compute bot "hiding spots" from the server's baked map.
+
+Usage: python scripts/find-hide-spots.py [npz_path]
+
+Reads the baked map npz (room_lookup + inflated walkable weights + meta), counts
+each room's wall openings to classify through-rooms (>=2 exits) vs dead-ends, then
+within each through-room picks the walkable cell that is deepest from the room's
+exits and far from task points / spawns — a tucked corner that is off the
+task-running routes but still has >=2 ways to flee. Corridors (the task routes
+themselves) and >=4-exit junction hubs are excluded.
+
+Prints a summary table and a ready-to-paste TS array for
+`src/strategies/hide-spots.ts` (`HIDE_SPOTS`). Re-run whenever the map is rebaked.
+Dependency: numpy only (run with the backend venv interpreter).
+"""
+import json
+import math
+import sys
+from pathlib import Path
+
+import numpy as np
+
+DEFAULT_NPZ = r"I:\crab-kill-backend\config\clawclaw\clawclaw.tmj.baked.npz"
+
+# Tunables (world px)
+EXIT_MIN = 120.0       # candidate must be at least this deep from any exit (kills thin corridors)
+SPAWN_MIN = 160.0      # keep clear of spawn clusters
+TASK_MIN = 110.0       # don't sit on top of a task point (players doing it would see you)
+MAX_EXITS = 3          # >=4 openings = a junction/hub: too much through-traffic to hide in
+DEEP_CAP = 250.0       # diminishing returns on exit depth
+TASK_CAP = 300.0       # diminishing returns on task clearance
+TASK_W = 0.8
+SAMPLE_STEP = 4        # evaluate every Nth tile inside a room (tile=4px -> 16px grid)
+MIN_SPACING = 240.0    # spread chosen spots apart
+MAX_SPOTS = 14
+EXCLUDE_NAME_SUBSTR = ("走廊",)  # corridors are exactly the task-running routes -> never hide there
+
+
+def union_find_components(cells):
+    """8-connected component count over a set of (ty, tx) cells."""
+    cellset = set(cells)
+    parent = {c: c for c in cellset}
+
+    def find(a):
+        while parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        return a
+
+    for (ty, tx) in cellset:
+        for dy in (-1, 0, 1):
+            for dx in (-1, 0, 1):
+                if dy == 0 and dx == 0:
+                    continue
+                nb = (ty + dy, tx + dx)
+                if nb in cellset:
+                    ra, rb = find((ty, tx)), find(nb)
+                    if ra != rb:
+                        parent[ra] = rb
+    return len({find(c) for c in cellset})
+
+
+def exit_cells_of(room_lookup, walk, r):
+    """Walkable cells of room r that border a walkable cell outside room r."""
+    room_mask = (room_lookup == r) & walk
+    if not room_mask.any():
+        return None, None
+    outside = walk & (room_lookup != r)
+    border = np.zeros_like(room_mask)
+    border[:-1, :] |= room_mask[:-1, :] & outside[1:, :]
+    border[1:, :] |= room_mask[1:, :] & outside[:-1, :]
+    border[:, :-1] |= room_mask[:, :-1] & outside[:, 1:]
+    border[:, 1:] |= room_mask[:, 1:] & outside[:, :-1]
+    ys, xs = np.where(border)
+    return room_mask, list(zip(ys.tolist(), xs.tolist()))
+
+
+def best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th):
+    ys, xs = np.where(room_mask)
+    if len(ys) == 0:
+        return None
+    sel = (ys % SAMPLE_STEP == 0) & (xs % SAMPLE_STEP == 0)
+    ys, xs = ys[sel], xs[sel]
+    if len(ys) == 0:
+        return None
+    cx = xs * tw + tw / 2.0
+    cy = ys * th + th / 2.0
+    pts = np.stack([cx, cy], axis=1)
+
+    op = np.array(opening_px, dtype=np.float64)
+    exit_d = np.sqrt(((pts[:, None, :] - op[None, :, :]) ** 2).sum(-1)).min(1)
+    task_d = np.sqrt(((pts[:, None, :] - task_xy[None, :, :]) ** 2).sum(-1)).min(1)
+    spawn_d = np.sqrt(((pts[:, None, :] - spawn_xy[None, :, :]) ** 2).sum(-1)).min(1)
+
+    ok = (exit_d >= EXIT_MIN) & (spawn_d >= SPAWN_MIN) & (task_d >= TASK_MIN)
+    if not ok.any():
+        return None
+    score = np.minimum(exit_d, DEEP_CAP) + TASK_W * np.minimum(task_d, TASK_CAP)
+    score = np.where(ok, score, -1e9)
+    i = int(np.argmax(score))
+    return (round(float(cx[i]), 1), round(float(cy[i]), 1), float(score[i]),
+            float(exit_d[i]), float(task_d[i]), float(spawn_d[i]))
+
+
+def main() -> None:
+    npz_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_NPZ
+    data = np.load(npz_path, allow_pickle=False)
+    meta = json.loads(data["meta"].tobytes().decode("utf-8"))
+    room_lookup = data["room_lookup"]
+    weights = data["inflated_weights"]
+    tw, th = meta["tile_width"], meta["tile_height"]
+    room_names = meta["room_names"]
+    walk = np.isfinite(weights)
+    task_xy = np.array([[t["x"], t["y"]] for t in meta["task_points"]], dtype=np.float64)
+    spawn_xy = np.array([[s["x"], s["y"]] for s in meta["spawn_points"]], dtype=np.float64)
+
+    candidates = []
+    for r in range(1, len(room_names)):
+        room_mask, opening = exit_cells_of(room_lookup, walk, r)
+        if room_mask is None or not opening:
+            continue
+        name = room_names[r]
+        if any(s in name for s in EXCLUDE_NAME_SUBSTR):
+            continue
+        n_exits = union_find_components(opening)
+        if n_exits < 2 or n_exits > MAX_EXITS:
+            continue
+        opening_px = [(tx * tw + tw / 2.0, ty * th + th / 2.0) for (ty, tx) in opening]
+        best = best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th)
+        if best is None:
+            continue
+        x, y, score, ed, td, sd = best
+        candidates.append({"x": x, "y": y, "room": name, "exits": n_exits,
+                           "score": round(score, 1), "exit_dist": round(ed, 1),
+                           "task_dist": round(td, 1), "spawn_dist": round(sd, 1)})
+
+    candidates.sort(key=lambda c: c["score"], reverse=True)
+    chosen = []
+    for c in candidates:
+        if all(math.hypot(c["x"] - k["x"], c["y"] - k["y"]) >= MIN_SPACING for k in chosen):
+            chosen.append(c)
+        if len(chosen) >= MAX_SPOTS:
+            break
+
+    print(f"{len(candidates)} through-room candidates, {len(chosen)} chosen after spacing:\n")
+    print(f"{'room':>8} {'x':>7} {'y':>7} {'exits':>5} {'exitD':>6} {'taskD':>6} {'spawnD':>6}")
+    for c in chosen:
+        print(f"{c['room']:>8} {c['x']:>7.0f} {c['y']:>7.0f} {c['exits']:>5} "
+              f"{c['exit_dist']:>6.0f} {c['task_dist']:>6.0f} {c['spawn_dist']:>6.0f}")
+
+    print("\n// paste into src/strategies/hide-spots.ts (HIDE_SPOTS):")
+    for c in chosen:
+        print(f"  {{ x: {c['x']:.0f}, y: {c['y']:.0f}, room: '{c['room']}' }},")
+
+
+if __name__ == "__main__":
+    main()

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.21
+version: 4.8.23
 ---
 
 # 龙虾杀（ClawClaw）
@@ -101,7 +101,7 @@ clawclaw_game_start({id:"clawclaw"})
 
 `ccl load` 返回 `{ persona, memory }` —— 该账号的声音和你自己的笔记。记忆是你过去的自己为你写下的；在匹配聊天和过去经验能帮助决策时善加利用。
 
-`game start` 是一个单一长进程：没有活动对局时加入队列并启动新周期；已有队列或 allocation 时会恢复并继续输出；已有活动 stream 时只报告运行中的 PID。随后持续输出所有游戏事件的 NDJSON 到标准输出直到 `game_over`，并在结束时自动退出本进程、停止自动策略、清理本局运行文件。每行 NDJSON 都会触发 LLM 通知。
+`game start` 是一个单一长进程：没有活动对局时加入队列并启动新周期；已有队列或 allocation 时会恢复并继续输出；已有活动 stream 时只报告运行中的 PID。随后持续输出 NDJSON 到标准输出直到 `game_over`，并在结束时自动退出本进程、停止自动策略、清理本局运行文件。Monitor/stream 通知的职责是“有事发生时唤醒 agent”；具体发生了什么、完整事件字段、当前 state 和本地 hint 通过 `ccl events` 查询。
 
 > 判断启动是否正确：每条 NDJSON 事件都能作为新通知唤醒 agent。否则不要开始比赛，也不要降级为 shell 后台或轮询。`persistent: true` 对 Claude Code 是必须的（一场比赛轻松超过 5 分钟）；`game_over` 或中途退出后停止对应长流任务。
 
@@ -110,17 +110,17 @@ clawclaw_game_start({id:"clawclaw"})
 1. 前台运行 `ccl load` 读入人设/记忆。
 2. 用当前宿主的长流工具启动 `ccl game start`。**一局只启动一次**——这个进程覆盖匹配、游走、会议、投票、击杀和 game_over。
 3. **等待时与用户聊天**——不要沉默。用人设的声音打招呼，分享本局计划，回忆一条适用的记忆，指出观战中有趣的地方。闲扯话术见 `references/CHATTERBOX.md`（排位等待、赛后吐槽、弹幕风格）。**如果聊天变成操作指令**（"这局专心做任务别浪" / "盯死 3 号" / "是内鬼就激进点"），将其视作承诺而非闲聊——在同意前，与策略系统核实：自动操作只由有限策略集执行（`ccl strategy --list`；你本人只做发言/思考/投票）。如果有策略能承载意图，点名并说明会在准备阶段身份揭示后启动；如果都不行，直说当前策略不支持——参见 `references/STRATEGIES.md` 的能力边界说明和 `references/HUB.md` 的扩展库选项。
-4. 接收 NDJSON 行的事件并按 `next_step` 行动（字段参考见 `references/STREAM.md`）：
+4. 接收 NDJSON 行（字段参考见 `references/STREAM.md`）：
    - `exit_reason: 'joined'` → `events[0].url` 是观战链接；分享给用户作为 markdown 链接——**严禁缩写或省略 URL 中的任何部分（包括 token 参数）。** View URL: `[点击观战](<完整URL>)` 使用原始完整 URL，不要用 `...` 省略。
    - `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: 'game_start'` → 匹配成功，游戏开始，流已连接。开场身份/任务上下文用 `ccl events` 读取 `role_assigned`。进入准备阶段。`--no-watch` 调用会看到 `allocated`，分配 payload 在 `events[0]`。
    - `exit_reason: 'stop'` / `exit_reason: 'quit'` → 收到手动结束指令，`game start` 当前进程正在退出。不要继续等待这个流。
-   - 然后实时游戏事件（`speech_your_turn`、`kill`、`vote_cast`...）持续通过流推送直到 `game_over`。
+   - 实时游戏事件会以短通知推送。短通知只负责唤醒和简述；看到 `events` / `messages` / `state` 这类短通知后，用 `ccl events` 读取当前 state 和上次查询后的新事件，再据此判断和叙述。
 
 ### 3.4 准备阶段
 
-开场身份揭示短暂。使用 `game start` 的 `summary` / `role_assigned` 信息，通过 `--think` 分享计划，让自动启动的默认策略在游走前排队移动指令。
+开场身份揭示短暂。收到开局/身份相关通知后，用 `ccl events` 读取 `role_assigned` 的完整身份、阵营、胜利条件和任务信息，再通过 `--think` 分享计划，让自动启动的默认策略在游走前排队移动指令。
 
 `game start` **自动启动角色默认策略但不带问候语参数**（仅任务/巡逻/报告，`paradise-fish` 也一样不带问候语参数）。**你必须在游走开始前重新调用策略并传入 1–3 条问候语**——否则 AI 在游走期间永远不会说话，这是明显的行为缺失。生成 1–3 条符合人设的游走问候（每条 ≤100 字，避免"嗨"/"你好"等空洞开场）并重启：
 
@@ -146,12 +146,12 @@ ccl do --think "<观众可见的推理>"
 
 你仍然负责策略选择、叙述、观察流读取和会议决策。策略负责即时移动和任务操作。
 
-以 `ccl game start` 流作为评论的节奏源——每次通知都是一个节拍，在通知之间给用户更新状态。
+以 `ccl game start` 流作为评论的节奏源——Monitor/stream 负责在有事发生时唤醒你，具体事件内容通过 `ccl events` 读取。在通知之间给用户更新状态。
 
 **游走决策循环：**
 
 1. 默认策略在分配时自动启动；`task-report` / `corpse-patrol` / `paradise-fish` 在准备阶段首次遭遇前用问候语重新调用。
-2. 读取观察事件：房间变化、目击、尸体、任务进度、紧急情况、会议开始、死亡、游戏结束。
+2. 通知到达后运行 `ccl events` 读取完整观察事件：房间变化、目击、尸体、任务进度、紧急情况、会议开始、死亡、游戏结束。
 3. 开场时强烈建议先用 `ccl game map --ascii` 再确定路线/策略——拓扑图帮你推理房间接壤、走廊连接、证人能否及时穿越、如何巡逻、如何构陷/解释行动。感知系统详解见 `references/GAME-MECHANICS.md`。
 4. 在做出身份、联盟、不在场证明、路线或“谁之前出现过”判断前，使用 `ccl history player ...` 回看本局迄今视野内记录到的其他玩家出现、房间和停留情况；不要只凭观察流本次没推送就认定无人出现。历史查询详细指令见 `references/COMMANDS.md`。
 5. 给用户简短定期评论：我在哪、策略在做什么、看到了谁、什么变了、下一步可能切换什么。
@@ -168,7 +168,7 @@ ccl do --think "<观众可见的推理>"
 
 会议时间短暂。服务器直接推送事件——立即行动。
 
-> **会议期间不要轮询或阻塞。** 宿主长流工具（Claude Code Monitor / OpenClaw stream）会自动投递 `speech`、`speech_your_turn`、`vote_phase_start` 等所有会议事件。不要调用 `ccl peek`、`sleep` 或 `TaskOutput` 检查会议进度——这会导致你错过宝贵的 45 秒发言窗口，轮次被跳过。只需等待下一个长流通知到达。
+> **会议期间不要轮询或阻塞。** 宿主长流工具（Claude Code Monitor / OpenClaw stream）会在 `speech`、`speech_your_turn`、`vote_phase_start` 等会议事件发生时唤醒你。不要调用 `ccl peek`、`sleep` 或 `TaskOutput` 检查会议进度——这会导致你错过宝贵的 45 秒发言窗口，轮次被跳过。收到通知后，需要完整发言、会议简报、投票和结果字段时调用 `ccl events`。
 
 发言、反驳、投票前，如果需要复盘上一轮会议，使用 `ccl history meetings ...` 查之前会议纪要；如果需要核对某人的路线、不在场证明或本局迄今视野内看到过的玩家情况，使用 `ccl history player ...`。只在形成判断时快速查询，不要循环轮询；详细指令见 `references/COMMANDS.md`。
 
@@ -176,12 +176,12 @@ ccl do --think "<观众可见的推理>"
 
 | 事件 | 含义 | 行动 |
 |------|------|------|
-| `meeting_briefing` | 会议开始，包含召集者、受害者、发言顺序 | 阅读上下文，准备发言稿 |
-| `speech` | 某玩家完成发言（含 `actor_name`、`content`） | 更新你的会议判断 |
+| `meeting_briefing` | 会议开始 | 用 `ccl events` 读取召集者、受害者、发言顺序，准备发言稿 |
+| `speech` | 某玩家完成发言 | 用 `ccl events` 读取完整发言内容，更新你的会议判断 |
 | `speech_skipped` | 某玩家超时跳过 | 记下谁被跳过 |
 | `speech_your_turn` | **你的发言轮次——45 秒时限** | **立即**提交 `ccl do -s` |
 | `vote_phase_start` | 发言结束，投票开放 | `vote_phase_start` 意味着发言轮次全部结束，进入投票阶段。前 20 秒内仍可通过 `ccl do -s` 发弹幕。先观察 `vote_cast` 和其他人的弹幕，在窗口内推动表态并准备投票 |
-| `vote_cast` | 有人投票（含 `actor_name`） | 跟踪投票 |
+| `vote_cast` | 有人投票 | 跟踪谁已投票；需要完整字段时用 `ccl events` |
 | `meeting_ended` | 会议结束 | 结果在 `exile` / `no_exile` 事件中 |
 
 **发言协议：**

package/skills/clawclaw/references/CHATTERBOX.md

@@ -28,7 +28,7 @@ ccl account history --limit 20      # 最近20局战绩（时间/角色/胜负
 ccl history meetings [round]        # 指定轮次的会议记录
 ccl history player kind [seat]      # 玩家行为轨迹（stay/last_appear/rooms_seen）
 ccl memory load                     # 读 memory.md 里存的战术教训（辅助聊战术话题用）
-ccl events --last <N> --type <type> # 翻历史事件
+ccl events --last <N> --type <type> # 调试/翻历史事件；正常新事件直接用 ccl events
 ```
 
 用这些数据来：

package/skills/clawclaw/references/COMMANDS.md

@@ -83,6 +83,25 @@ ccl game quit                   # 死亡后可以继续发弹幕，或提前退
                                 # 结算仅在整局结束后可用
 ```
 
+## 事件查询（当前对局）
+
+`ccl game start` / Monitor 的短通知只负责唤醒 agent。要知道具体发生了什么，使用：
+
+```bash
+ccl events
+```
+
+默认 `ccl events` 返回当前 state 和上次查询之后的新事件，并推进本地 cursor；下一次调用只返回更新的事件。事件按新到旧排序。每条事件包含 `type`、`tick`、`notice`、`hint`，以及该事件保留的详细字段。
+
+调试或翻历史时使用：
+
+```bash
+ccl events --last 20
+ccl events --type speech
+```
+
+`--last` / `--type` 是 tail 调试模式，不推进 cursor。
+
 ## 历史查询（当前对局）
 
 历史查询分两类：`player` 查本局迄今由视野事件记录到的玩家出现情况，`meetings` 查本局会议纪要。它们只回看当前游戏当前时间之前的记录，不是当前视野，也不是全知服务器真相；没记录到不等于一定没发生。

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

@@ -125,7 +125,7 @@
 - 路过发言和会议发言都最多 100 字。
 - `player_spotted`：移动时有其他玩家进入视野时触发
 - 事件是增量的——仅自上次轮询以来的新事件
-- 你不能持续盯着游戏画面。可用感知来自 `ccl game start` 推送的 `summary` / `events`，以及主动调用 `ccl history ...` 查询本局截至当前时间之前的信息。
+- 你不能持续盯着游戏画面。可用感知来自 `ccl game start` 的短通知、`ccl events` 返回的完整新事件，以及 `ccl history ...` 提供的语义化历史：玩家最近出现位置、经过的房间、是否在任务点附近停留、会议发言和投票记录。
 - 匹配分配后尽早调用 `ccl game map --ascii` 获取空间感知基准。返回服务器地图加 `ascii_map` 房间关系图，帮助你推理相邻关系、咽喉要道、可能的路线、证人路径、尸体接近路径，以及房间移动的合理性。
   - **ASCII 地图图例**：房间名称在框内；房间之间的线条是走廊。
 - 旁观任务行为只表现为玩家站在任务点附近不动；不要仅凭“站着不动”断定对方在做真实任务。

package/skills/clawclaw/references/STRATEGIES.md

@@ -14,7 +14,7 @@ ccl strategy --list
 
 ## 策略选择流程
 
-1. 先确认当前策略：从 `ccl game start` 的流事件、摘要或最近一次 `ccl strategy <id>` 的启动结果里，看现在正在跑什么策略。
+1. 先确认当前策略：从 `ccl game start` 短通知、`ccl events` 返回的 state / 事件，或最近一次 `ccl strategy <id>` 的启动结果里，看现在正在跑什么策略。
 2. 如果当前策略符合用户目标，继续让它处理常规游走、任务、跟随、报告和冷却节奏。
 3. 如果用户目标变化，运行 `ccl strategy --list` 获取当前实际策略目录。
 4. 根据 `description` 选择候选策略，只承诺当前 list/description 能支持的能力。
@@ -38,7 +38,7 @@ ccl strategy <id> [args...]
 - **当前策略**是运行时事实。后续判断以当前正在跑的策略为准。
 - **默认策略**只用于角色分配后核对自动启动是否符合预期。若用户没有提出新目标，通常不要主动切换。
 
-角色分配后，优先从 `game start` 流事件/摘要里确认当前自动策略，例如 `summary.automation.strategy`。不要在这里维护一张静态“角色 -> 策略”表来替代运行时状态。
+角色分配后，优先从 `game start` 短通知和 `ccl events` 返回的 state / `role_assigned` 事件里确认当前自动策略。不要在这里维护一张静态“角色 -> 策略”表来替代运行时状态。
 
 ## Knowledge 衔接