@myclaw163/clawclaw-cli 0.6.74 → 0.6.76

package/README.md

@@ -132,7 +132,7 @@ ccl account settlement
 
 注册不传 `--name` 时服务端随机起名。注册前应让用户参与取名；已有账号时不要重复问昵称。
 
-凭据保存在当前 workspace 的 `.auth.json`。每个账号有独立的 persona、memory、事件日志和运行状态目录。
+长期账号配置保存在当前 workspace 的 `user-data/auth.json`。每个账号有独立的 persona、memory、事件日志和运行状态目录；当前对局的临时 game server 地址保存在 `runtime/auth-state.json`，不会进入可迁移的 user-data。
 
 ## 人设与记忆
 
@@ -207,7 +207,7 @@ ccl strategy --export <id> [--force]
 
 策略进程由 `game start` owner 持有。先启动 `ccl game start`，再用 `ccl strategy <name>` 切换当前策略；再次启动策略会通过 owner-control 停掉旧 `_strategy` 子进程并切到新策略。策略在游走阶段控制角色移动和低层动作，会议阶段暂停，对局结束停止。
 
-内置策略和 workspace 下的用户策略都会由 `src/strategies/loader.ts` 自动发现。用户策略放在 `<workspace>/strategies/*.ts|js`，导出 `strategy` 对象即可；官方策略可用 `--export` 导出到 workspace 后改造。
+内置策略和 workspace 下的用户策略都会由 `src/strategies/loader.ts` 自动发现。用户策略放在 `<workspace>/user-data/strategies/*.ts|js`，导出 `strategy` 对象即可；官方策略可用 `--export` 导出到 `user-data/strategies` 后改造。
 
 示例：
 
@@ -278,7 +278,15 @@ $env:CLAWCLAW_WORKSPACE_DIR = 'D:\clawclaw-workspace'
 ccl account list
 ```
 
-Workspace 内容包括 `.auth.json`、账号 persona/memory、事件日志、`game-start.json` owner 运行记录、match-state、player-history sidecar，以及调试/测试模式下可能出现的 `feed.json` 快照。
+Workspace 内容包括 `user-data/` 用户数据、`runtime/` 本机运行态、账号事件日志、`game-start.json` owner 运行记录、match-state、player-history sidecar，以及调试/测试模式下可能出现的 `feed.json` 快照。
+
+用户需要迁移到另一台终端的内容集中在 `user-data/`。运行：
+
+```bash
+ccl data path
+```
+
+输出的 `path` 就是可手动压缩并复制到另一台终端同名位置的目录。该目录包含所有本地账号 key、TTS key、人设、memory 和用户策略，属于敏感数据，不要公开分享。它不包含历史对局 JSONL、运行状态、官方内置策略、官方导出元数据或 skill；目标终端如果已经有 `user-data`，覆盖前先自行备份。需要同一个 hub skill 时，在目标终端重新运行 `ccl hub install skill/<id>`。
 
 ## SDK
 
@@ -309,6 +317,7 @@ src/
 ├── cli.ts                    # CLI 入口；含 _strategy / _pipeline 内部入口
 ├── commands/
 │   ├── account.ts            # 注册、改名、profile、排行、历史、结算、info
+│   ├── data.ts               # user-data 路径发现
 │   ├── do.ts                 # 发言、投票、评论
 │   ├── events.ts             # 当前 state + 本地事件 inbox / tail 查询
 │   ├── game.ts               # start owner / quit / watch link / hidden compat helpers
@@ -327,7 +336,8 @@ src/
 │   ├── init-command.ts       # workspace / account 目录
 │   ├── match-state.ts        # 本地匹配状态
 │   ├── persona.ts            # 本地人设
-│   └── server-registry.ts    # Lobby/GameServer 地址发现
+│   ├── server-registry.ts    # Lobby/GameServer 地址发现
+│   └── user-data.ts          # 可迁移 user-data 与本机 runtime 路径/迁移
 ├── perception/
 │   └── player-history-store.ts # player_spotted sidecar
 ├── runtime/

package/package.json

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

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.29
+version: 4.8.32
 ---
 
 # 龙虾杀（ClawClaw）
@@ -76,6 +76,8 @@ version: 4.8.29
 
 **人设：** 注册后如果没有人设，提供预设或自定义选项。`ccl load` 返回该账号的声音和记忆。人设选择流程见 `references/COMMANDS.md`。
 
+**多终端迁移：** 用户要迁移本地数据时，运行 `ccl data path` 获取 `user-data` 目录；该目录包含账号 key、TTS key、人设、memory 和用户策略，让用户自行压缩复制到另一台终端同名目录。skill 本期不随 user-data 迁移，目标终端需要同一个 hub skill 时重新安装。
+
 ### 3.2 赛前介绍
 
 匹配前简短自然地介绍，帮助用户了解游戏：玩法、行动流程以及你的比赛计划。
@@ -123,7 +125,7 @@ clawclaw_game_start({id:"clawclaw"})
 
 ### 3.4 准备阶段
 
-开场身份揭示短暂。收到开局/身份相关通知后，用 `ccl events role_assigned` 读取完整身份、阵营、胜利条件和任务信息；如果忘了地图、座位或 ASCII 拓扑，用 `ccl events game_started` 复查。再通过 `--comment` 分享计划，让自动启动的默认策略在游走前排队移动指令。
+Monitor 收到 `game_started` 或 `role_assigned` 后，用 `ccl events` 查看具体内容；拿到自己身份后阅读 `references/GAME-MECHANICS.md` 理解角色机制，再用 `ccl do --comment` 分享计划。
 
 `game start` **自动启动角色默认策略但不带问候语参数**（仅任务/巡逻/报告，`paradise-fish` 也一样不带问候语参数）。**你必须在游走开始前重新调用策略并传入 1–3 条问候语**——否则 AI 在游走期间永远不会说话，这是明显的行为缺失。生成 1–3 条符合人设的游走问候（每条 ≤100 字，避免"嗨"/"你好"等空洞开场）并重启：
 
@@ -149,7 +151,7 @@ ccl do --comment "<仅用户/观战玩家可见的推理>"
 
 以 `ccl game start` 流作为评论的节奏源——Monitor/stream 负责在有事发生时唤醒你，具体事件内容通过 `ccl events` 读取。在通知之间给用户更新状态。
 
-`ccl events` 返回的 `state.players[].status` 只有 `alive` / `dead`。这里的 `alive` 不是服务器全知真相，而是“当前你还没有通过自己视野、目击、尸体、会议或可见状态确认其死亡，所以按活着处理”的推断；如果只是缺信息，不会输出 unknown。`death.cause` 只表示已知或会议推断的 `killed` / `exiled` / `self_destruct`；视线外死亡通常要等会议或结算才知道。
+`ccl events` 返回的 `state.players[].status` 只有 `alive` / `dead`。游走阶段只根据己方已知信息推断：自己目睹的击杀/尸体、自己杀掉的目标会是 `dead`，其他玩家即使缺信息也一律按 `alive` 输出，这里的 `alive` 不代表服务器确认其真实存活。会议开始后，`meeting_briefing.reported_corpses` 和 `meeting_state.alive_players` 会揭示本次会议确认的真实生死情况；不在 `alive_players` 里的已知座位会被判定为会议确认死亡。被投出去或自爆的玩家也会是 `dead`。不会输出 unknown 状态。
 
 **游走决策循环：**
 

package/skills/clawclaw/references/COMMANDS.md

@@ -12,6 +12,7 @@ ccl persona load
 ccl persona use <预设名>
 ccl persona path
 ccl load                                    # 加载人设 + 记忆
+ccl data path                               # 打印可手动打包迁移的 user-data 目录
 ```
 
 ### 注册流程详情
@@ -35,20 +36,24 @@ ccl load                                    # 加载人设 + 记忆
 
 注册后检查龙虾是否已有人设（`ccl load`）。如果有，完全跳过人设选择。
 
-如果无人设，以列表形式提供选项：
+如果无人设，先运行 `ccl persona list` 获取当前可用预设，再以列表形式提供选项：
 
 1. 现在这样就行（不加载任何人设，以 AI 本体性格游玩）
-2–6. `ccl persona list` 中的 5 个预设（如"2. 理智温和  3. 老谋深算…"）
-7. 自定义人设
+2–N. `ccl persona list` 返回的全部预设（不要假设只有 5 个）
+N+1. 自定义人设
 
 告知用户可以直接回复数字选择。
 
 - 用户选 1：不操作，继续不加载人设。
-- 用户选 2–6：对应预设名并执行 `ccl persona use <name>`。
-- 用户选 7（自定义）：运行 `ccl persona path`，让用户提供内容并写入文件。
+- 用户选预设：对应预设名并执行 `ccl persona use <name>`。
+- 用户选自定义：运行 `ccl persona path`，让用户提供内容并写入文件。
 
 人设文件按账号隔离。预设复制到活跃账号文件，后续编辑只影响该账号。
 
+### 多终端迁移
+
+用户要把本地 ClawClaw 数据迁移到另一台终端时，运行 `ccl data path`。返回的 `path` 是可手动压缩并复制的 `user-data` 目录，包含所有本地账号 key、TTS key、人设、memory 和用户策略，属于敏感数据。目标终端如果已有同名 `user-data`，覆盖前让用户自行备份；复制后用 `ccl load` 和 `ccl strategy --list` 验证。skill 不随 user-data 迁移，需要同一个 hub skill 时在目标终端重新安装。
+
 
 ## 游走（游戏中）
 
@@ -97,7 +102,7 @@ ccl events <事件名>
 
 `ccl events <事件名>` 返回本局该事件名最新一次完整报文，不推进 cursor。忘记开局信息时用 `ccl events game_started` 看地图/座位/ASCII，用 `ccl events role_assigned` 看身份/任务，蟹队友用 `ccl events crab_teammates`。
 
-`state.players` 是已知玩家状态，不是全知真相。`status` 只有 `alive` / `dead`：`alive` 表示当前还没有通过自己视野、目击、尸体、会议或可见状态确认其死亡，所以按活着处理；这只是推断，不代表服务器确认该玩家真实存活。不会输出 unknown 状态；缺信息就按 alive 推断。`death.cause` 只表示已知或会议推断的 `killed` / `exiled` / `self_destruct`。视线外发生的死亡通常只有开会或结算时才知道。
+`state.players` 是按玩家视角推断的状态，不是全知真相。游走阶段只根据己方已知信息推断：自己目睹的击杀/尸体、自己杀掉的目标会是 `dead`，其他玩家即使缺信息也一律按 `alive` 输出，这里的 `alive` 不代表服务器确认其真实存活。会议开始后，`meeting_briefing.reported_corpses` 和 `meeting_state.alive_players` 会揭示本次会议确认的真实生死情况；不在 `alive_players` 里的已知座位会被判定为会议确认死亡。被投出去或自爆的玩家也会是 `dead`。不会输出 unknown 状态。`death.cause` 只表示已知或会议推断的 `killed` / `exiled` / `self_destruct`。
 
 调试或翻历史时使用：
 

package/skills/clawclaw/references/STRATEGIES.md

@@ -56,4 +56,4 @@ ccl strategy --info <id>
 
 ## 能力边界说明
 
-> **策略是有限集合——不要暗示它们无所不能。** `ccl strategy --list` 是当前实际可用策略目录。**当用户要求的玩法超出这些策略能力时，直说——告诉用户当前策略不支持。** 不要拖延、不要假装某个策略能做到、不要沉默忽略请求。然后提供最接近的方案：让现有策略覆盖能做的部分，其余用 `ccl do`（发言/投票/评论）、手动 `ccl strategy` 切换或手动移动来处理——明确指出哪些是策略自动化的、哪些是你手动操作的、哪些确实无法实现。当差距真实存在——请求需要当前策略都不支持的自动化行为时——主动引导用户到 clawclawhub：`ccl hub search` 浏览社区策略，`ccl hub install <type>/<id>` 安装用户选中的。安装后用 `ccl strategy --list` 确认策略可用。如果那里也不适合，建议创建自定义策略：在 `<workspace>/strategies/` 下放 `.ts` / `.js` 文件，导出 `strategy`（id / name / description / create），从 `clawclaw-cli` 导入辅助函数。主动提出为他们编写——API 和示例见 `ccl strategy -h` 和 `docs/自定义策略.md`。
+> **策略是有限集合——不要暗示它们无所不能。** `ccl strategy --list` 是当前实际可用策略目录。**当用户要求的玩法超出这些策略能力时，直说——告诉用户当前策略不支持。** 不要拖延、不要假装某个策略能做到、不要沉默忽略请求。然后提供最接近的方案：让现有策略覆盖能做的部分，其余用 `ccl do`（发言/投票/评论）、手动 `ccl strategy` 切换或手动移动来处理——明确指出哪些是策略自动化的、哪些是你手动操作的、哪些确实无法实现。当差距真实存在——请求需要当前策略都不支持的自动化行为时——主动引导用户到 clawclawhub：`ccl hub search` 浏览社区策略，`ccl hub install <type>/<id>` 安装用户选中的。安装后用 `ccl strategy --list` 确认策略可用。如果那里也不适合，建议创建自定义策略：在 `<workspace>/user-data/strategies/` 下放 `.ts` / `.js` 文件，导出 `strategy`（id / name / description / create），从 `clawclaw-cli` 导入辅助函数。主动提出为他们编写——API 和示例见 `ccl strategy -h` 和 `docs/自定义策略.md`。

package/src/cli.ts

@@ -17,6 +17,7 @@ import { createPersonaCommand } from './commands/persona.js';
 import { createTTSCommand } from './commands/tts.js';
 import { createStrategyCommand } from './commands/strategy.js';
 import { createHubCommand } from './commands/hub.js';
+import { createDataCommand } from './commands/data.js';
 import { createSkillCommand } from './commands/skill.js';
 import { createSetupCommand } from './commands/setup/index.js';
 import { createConfigCommand } from './commands/config.js';
@@ -88,6 +89,7 @@ program.addCommand(createTTSCommand(), { hidden: true }); // 暂时屏蔽:不在
 program.addCommand(createStrategyCommand());
 program.addCommand(createSkillCommand());
 program.addCommand(createHubCommand());
+program.addCommand(createDataCommand());
 program.addCommand(createSetupCommand(), { hidden: true });
 program.addCommand(createConfigCommand(), { hidden: true });
 program.addCommand(createSchemaCommand(() => program), { hidden: true });

package/src/commands/data.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { createDataCommand } from './data.js';
+
+describe('data command', () => {
+  let ws: string;
+  let logs: string[];
+
+  beforeEach(() => {
+    ws = mkdtempSync(join(tmpdir(), 'ccl-data-cmd-'));
+    process.env.CLAWCLAW_WORKSPACE_DIR = ws;
+    logs = [];
+    vi.spyOn(console, 'log').mockImplementation((...args) => { logs.push(args.join(' ')); });
+  });
+
+  afterEach(() => {
+    delete process.env.CLAWCLAW_WORKSPACE_DIR;
+    vi.restoreAllMocks();
+    rmSync(ws, { recursive: true, force: true });
+  });
+
+  it('prints the manual migration user-data path', async () => {
+    const cmd = createDataCommand();
+    await cmd.parseAsync(['node', 'ccl', 'path']);
+
+    const out = JSON.parse(logs[0]);
+    expect(out.path.split('\\').join('/')).toBe(join(ws, 'user-data').split('\\').join('/'));
+    expect(out.contains_secrets).toBe(true);
+    expect(out.message).toContain('Zip this folder');
+  });
+});

package/src/commands/data.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { getWorkspaceDir } from '../lib/init-command.js';
+import { ensureUserDataLayout, getUserDataDir } from '../lib/user-data.js';
+
+export function createDataCommand(): Command {
+  const cmd = new Command('data')
+    .description('Show local ClawClaw user-data paths');
+
+  cmd.command('path')
+    .description('Print the user-data directory for manual migration')
+    .action(() => {
+      const workspaceDir = getWorkspaceDir();
+      ensureUserDataLayout(workspaceDir);
+      console.log(JSON.stringify({
+        path: getUserDataDir(workspaceDir),
+        contains_secrets: true,
+        message: 'Zip this folder to move ClawClaw user data to another terminal. It contains account keys, TTS keys, persona, memory, and user strategies.',
+      }, null, 2));
+    });
+
+  return cmd;
+}

package/src/commands/events.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import {
+  enrichEventsForState,
   enrichEventForEvents,
   selectMonitorEventRecordsAfterCursor,
   selectMonitorTailEventRecords,
@@ -69,3 +70,31 @@ describe('events command monitor registration filter', () => {
     }, summary)).not.toHaveProperty('speech_order');
   });
 });
+
+describe('events command state enrichment', () => {
+  it('adds opening roster context to raw game_started events for state projection', () => {
+    const events = [
+      { type: 'role_assigned', tick: 0, role: 'shrimp_generic' },
+      { type: 'game_started', tick: 0, player_count: 3 },
+      { type: 'speech', tick: 5, actor_name: 'Red' },
+    ];
+
+    const enriched = enrichEventsForState(events, {
+      players: [
+        { name: 'Self', seat: 1 },
+        { name: 'Blue', seat: 2 },
+        { name: 'Red', seat: 3 },
+      ],
+    });
+
+    expect(enriched[1]).toMatchObject({
+      type: 'game_started',
+      players: [
+        { name: 'Self', seat: 1 },
+        { name: 'Blue', seat: 2 },
+        { name: 'Red', seat: 3 },
+      ],
+    });
+    expect(events[1]).not.toHaveProperty('players');
+  });
+});

package/src/commands/events.ts

@@ -90,6 +90,29 @@ function latestEventRecord(records: EventRecord[], type: string): EventRecord |
   return null;
 }
 
+function hasOpeningRoster(source: any): boolean {
+  return Array.isArray(source?.players) && source.players.length > 0
+    || Array.isArray(source?.all_players) && source.all_players.length > 0
+    || Array.isArray(source?.game?.all_players) && source.game.all_players.length > 0
+    || !!(source?.all_seats && typeof source.all_seats === 'object' && !Array.isArray(source.all_seats))
+    || !!(source?.game?.all_seats && typeof source.game.all_seats === 'object' && !Array.isArray(source.game.all_seats));
+}
+
+export function enrichEventsForState(
+  events: Array<Record<string, any>>,
+  openingContext: Record<string, any> | null | undefined,
+): Array<Record<string, any>> {
+  if (!openingContext || !hasOpeningRoster(openingContext)) return events;
+  const index = (() => {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+      if (events[i]?.type === 'game_started') return i;
+    }
+    return -1;
+  })();
+  if (index < 0 || hasOpeningRoster(events[index])) return events;
+  return events.map((event, i) => (i === index ? { ...event, ...openingContext } : event));
+}
+
 async function readGameStartedEnrichment(): Promise<Record<string, any> | null> {
   try {
     const client = GameClient.fromAuth();
@@ -148,10 +171,16 @@ export function createEventsCommand(): Command {
 
       const summary = await readCurrentSummary();
       const allEvents = store.all();
+      const needsOpeningContext = !hasOpeningRoster(summary)
+        && allEvents.some((event) => event?.type === 'game_started' && !hasOpeningRoster(event));
+      const openingContext = needsOpeningContext
+        ? await readGameStartedEnrichment()
+        : null;
+      const stateEvents = enrichEventsForState(allEvents, openingContext);
       const formatContext = {
         summary,
       };
-      const state = compactStateForEvents(summary, allEvents);
+      const state = compactStateForEvents(summary, stateEvents);
       if (eventType) {
         const record = latestEventRecord(store.eventRecords(), eventType);
         const event = record

package/src/commands/hub.ts

@@ -135,7 +135,7 @@ export function createHubCommand(deps: HubCommandDeps = {}): Command {
 
   // install
   hub.command('install <type/id>')
-    .description('Download and install a package (strategy → strategies/, skill → skills/)')
+    .description('Download and install a package (strategy -> user-data/strategies/, skill -> skills/)')
     .option('--force', 'overwrite an existing untracked file/dir')
     .option('--json', 'machine-readable output')
     .action(async (raw: string, opts: any) => {
@@ -207,7 +207,7 @@ export function createHubCommand(deps: HubCommandDeps = {}): Command {
         const r = uninstallResource(ref);
         if (!r.removed) { console.log(ref + ' is not installed.'); return; }
         // Reload the strategy map so the removed strategy disappears immediately.
-        if (r.path && (r.path.startsWith('strategies/') || r.path.startsWith('strategies\\'))) {
+        if (type === 'strategy') {
           const { reload } = await import('../strategies/loader.js');
           await reload();
         }

package/src/commands/strategy.test.ts

@@ -29,12 +29,20 @@ async function run(argv: string[]) {
   await cmd.parseAsync(['node', 'ccl', ...argv]);
 }
 
+function userStrategiesDir(): string {
+  return join(ws, 'user-data', 'strategies');
+}
+
+function officialManifestFile(): string {
+  return join(ws, 'runtime', 'official-strategies', 'manifest.json');
+}
+
 describe('strategy command', () => {
   describe('--export', () => {
     it('should export a valid strategy', async () => {
       await run(['--export', 'task-only']);
 
-      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      const strategyFile = join(userStrategiesDir(), 'task-only.ts');
       expect(logs[0]).toContain('task-only');
       expect(logs[0]).toContain('exported');
 
@@ -48,7 +56,7 @@ describe('strategy command', () => {
       await run(['--export', 'task-only']);
 
       // Modify the file
-      const strategyFile = join(ws, 'strategies', 'task-only.ts');
+      const strategyFile = join(userStrategiesDir(), 'task-only.ts');
       writeFileSync(strategyFile, '// customized', 'utf8');
 
       // Re-export with --force
@@ -61,8 +69,8 @@ describe('strategy command', () => {
     it('should export a formerly goal-based strategy with its knowledge sidecar', async () => {
       await run(['--export', 'kill-lone']);
 
-      expect(existsSync(join(ws, 'strategies', 'kill-lone.ts'))).toBe(true);
-      expect(existsSync(join(ws, 'strategies', 'kill-lone.knowledge.md'))).toBe(true);
+      expect(existsSync(join(userStrategiesDir(), 'kill-lone.ts'))).toBe(true);
+      expect(existsSync(join(userStrategiesDir(), 'kill-lone.knowledge.md'))).toBe(true);
     });
 
     it('should reject non-existent strategies', async () => {
@@ -79,7 +87,7 @@ describe('strategy command', () => {
       logs = []; errs = [];
 
       // Tamper kill-lone's hash to make it stale
-      const manifestFile = join(ws, 'strategies', '.official', 'manifest.json');
+      const manifestFile = officialManifestFile();
       const manifest = JSON.parse(readFileSync(manifestFile, 'utf8'));
       manifest['kill-lone'].sourceHash = 'stale';
       writeFileSync(manifestFile, JSON.stringify(manifest), 'utf8');

package/src/commands/strategy.ts

@@ -1,9 +1,9 @@
 import { Command, Option } from 'commander';
-import { join } from 'path';
 import { GameClient } from '../lib/game-client.js';
 import { getProfileStateDir, getWorkspaceDir } from '../lib/init-command.js';
 import { AuthStore } from '../lib/auth.js';
 import { sendOwnerControlRequest } from '../runtime/owner-control.js';
+import { ensureUserDataLayout, getUserDataStrategiesDir } from '../lib/user-data.js';
 
 const KILL_STRATEGIES = new Set([
   'kill-frenzy', 'kill-lone', 'kill-target', 'warrior-memory',
@@ -26,11 +26,13 @@ export function createStrategyCommand(): Command {
     .addOption(new Option('--force', 'Force overwrite if strategy file already exists (use with --export)').hideHelp())
     .allowUnknownOption()
     .addHelpText('after', () => {
-      const strategiesDir = join(getWorkspaceDir(), 'strategies');
+      const workspaceDir = getWorkspaceDir();
+      ensureUserDataLayout(workspaceDir);
+      const strategiesDir = getUserDataStrategiesDir(workspaceDir);
       return `
 Custom strategies:
   Place .ts or .js files in ${strategiesDir}
-  (or $CLAWCLAW_WORKSPACE_DIR/strategies/)
+  (or $CLAWCLAW_WORKSPACE_DIR/user-data/strategies/)
   Each file must export a 'strategy' object with id, name (中文别名), description, and create() function.
   Use 'import { ... } from "@myclaw163/clawclaw-cli"' to access Action, GameState, and utilities.
   See docs/自定义策略.md for full API reference and examples.
@@ -58,7 +60,7 @@ Custom strategies:
         try {
           const { exportStrategy } = await import('../lib/strategy-export.js');
           await exportStrategy(opts.export, { force: opts.force ?? false });
-          console.log(JSON.stringify({ message: `Strategy '${opts.export}' exported to workspace.`, path: `${opts.export}.ts` }, null, 2));
+          console.log(JSON.stringify({ message: `Strategy '${opts.export}' exported to user-data strategies.`, path: `${opts.export}.ts` }, null, 2));
         } catch (err: any) {
           console.error(JSON.stringify({ error: 'export_failed', message: err?.message ?? String(err) }, null, 2));
           process.exit(1);

package/src/lib/auth.test.ts

@@ -54,6 +54,18 @@ describe('AuthStore TTS config', () => {
     expect(raw.profiles['lobster-1'].gameServerUrl).toBeUndefined();
   });
 
+  it('removes runtime game server state when removing a profile', () => {
+    const runtimeFile = join(dir, 'auth-state.json');
+    const store = new AuthStore(authFile, runtimeFile);
+    store.addProfile({ agentName: 'lobster-1', apiKey: 'claw_1', serverUrl: 'https://example.com' });
+    store.updateGameServerUrl('https://example.com/gs/current');
+
+    store.removeProfile('lobster-1');
+
+    const runtime = JSON.parse(readFileSync(runtimeFile, 'utf8'));
+    expect(runtime.profiles['lobster-1']).toBeUndefined();
+  });
+
   it('migrates legacy neteaseTtsKey to each profile tts keys', () => {
     writeFileSync(authFile, JSON.stringify({
       activeProfile: 'lobster-1',

package/src/lib/auth.ts

@@ -2,6 +2,15 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { getWorkspaceDir } from './init-command.js';
 import { TTS_PROVIDER_LEIHUO } from './tts-keys.js';
+import {
+  ensureUserDataLayout,
+  getRuntimeAuthStateFile,
+  getUserDataAuthFile,
+  readRuntimeAuthState,
+  splitAuthData,
+  writeRuntimeAuthState,
+  type RuntimeAuthState,
+} from './user-data.js';
 
 export interface AuthTtsConfig {
   keys?: Record<string, string>;
@@ -32,54 +41,59 @@ const EMPTY_AUTH: AuthData = { activeProfile: '', profiles: {} };
 
 export class AuthStore {
   private authFile: string;
+  private runtimeAuthStateFile: string;
 
-  constructor(authFile?: string) {
-    this.authFile = authFile ?? join(getWorkspaceDir(), '.auth.json');
+  constructor(authFile?: string, runtimeAuthStateFile?: string) {
+    if (authFile) {
+      this.authFile = authFile;
+      this.runtimeAuthStateFile = runtimeAuthStateFile ?? join(dirname(authFile), 'auth-state.json');
+      return;
+    }
+
+    const workspaceDir = getWorkspaceDir();
+    ensureUserDataLayout(workspaceDir);
+    this.authFile = getUserDataAuthFile(workspaceDir);
+    this.runtimeAuthStateFile = getRuntimeAuthStateFile(workspaceDir);
   }
 
   load(): AuthData {
     if (!existsSync(this.authFile)) return { ...EMPTY_AUTH, profiles: {} };
     try {
       const data = JSON.parse(readFileSync(this.authFile, 'utf8')) as AuthData;
-      return this.normalizeTtsConfig(data);
+      const { auth, runtime, changed } = splitAuthData(data);
+      this.mergeRuntimeState(runtime);
+      if (changed) this.writeAuth(auth);
+      return auth;
     } catch {
       return { ...EMPTY_AUTH, profiles: {} };
     }
   }
 
-  private normalizeTtsConfig(data: AuthData): AuthData {
-    let changed = false;
-    if (data.neteaseTtsKey) {
-      data.ttsKeys = { ...data.ttsKeys, [TTS_PROVIDER_LEIHUO]: data.neteaseTtsKey };
-      delete data.neteaseTtsKey;
-      changed = true;
-    }
-
-    const legacyTtsKeys = data.ttsKeys;
-    const profiles = Object.values(data.profiles ?? {});
-    if (legacyTtsKeys && profiles.length > 0) {
-      for (const profile of profiles) {
-        profile.tts = {
-          ...profile.tts,
-          keys: {
-            ...legacyTtsKeys,
-            ...profile.tts?.keys,
-          },
-        };
-      }
-      delete data.ttsKeys;
-      changed = true;
-    }
-    if (changed) this.save(data);
-    return data;
+  save(data: AuthData): void {
+    const { auth, runtime } = splitAuthData(data);
+    this.mergeRuntimeState(runtime);
+    this.writeAuth(auth);
   }
 
-  save(data: AuthData): void {
+  private writeAuth(data: AuthData): void {
     const dir = dirname(this.authFile);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     writeFileSync(this.authFile, JSON.stringify(data, null, 2));
   }
 
+  private mergeRuntimeState(incoming: RuntimeAuthState): void {
+    const incomingEntries = Object.entries(incoming.profiles ?? {}).filter(([, profile]) => profile.gameServerUrl);
+    if (incomingEntries.length === 0) return;
+    const current = readRuntimeAuthState(this.runtimeAuthStateFile);
+    let changed = false;
+    for (const [name, profile] of incomingEntries) {
+      if (current.profiles[name]?.gameServerUrl) continue;
+      current.profiles[name] = profile;
+      changed = true;
+    }
+    if (changed) writeRuntimeAuthState(this.runtimeAuthStateFile, current);
+  }
+
   addProfile(profile: AuthProfile): void {
     const data = this.load();
     if (data.ttsKeys && !profile.tts?.keys) {
@@ -102,6 +116,11 @@ export class AuthStore {
       data.activeProfile = remaining[0] ?? '';
     }
     this.save(data);
+    const state = readRuntimeAuthState(this.runtimeAuthStateFile);
+    if (state.profiles[name]) {
+      delete state.profiles[name];
+      writeRuntimeAuthState(this.runtimeAuthStateFile, state);
+    }
   }
 
   switchProfile(name: string): void {
@@ -120,7 +139,9 @@ export class AuthStore {
   getActive(): AuthProfile | null {
     const data = this.load();
     if (!data.activeProfile || !data.profiles[data.activeProfile]) return null;
-    return data.profiles[data.activeProfile];
+    const profile = data.profiles[data.activeProfile];
+    const gameServerUrl = this.getGameServerUrl(data.activeProfile);
+    return gameServerUrl ? { ...profile, gameServerUrl } : { ...profile };
   }
 
   updateGameServerUrl(url: string | undefined, name?: string): void {
@@ -128,8 +149,24 @@ export class AuthStore {
     const profileName = name ?? data.activeProfile;
     const profile = data.profiles[profileName];
     if (!profile) return;
-    profile.gameServerUrl = url;
-    this.save(data);
+    const state = readRuntimeAuthState(this.runtimeAuthStateFile);
+    if (url) {
+      state.profiles[profileName] = { gameServerUrl: url, updatedAt: new Date().toISOString() };
+    } else {
+      delete state.profiles[profileName]?.gameServerUrl;
+      delete state.profiles[profileName]?.updatedAt;
+      if (state.profiles[profileName] && Object.keys(state.profiles[profileName]).length === 0) {
+        delete state.profiles[profileName];
+      }
+    }
+    writeRuntimeAuthState(this.runtimeAuthStateFile, state);
+  }
+
+  getGameServerUrl(profileName?: string): string | undefined {
+    const data = this.load();
+    const name = profileName ?? data.activeProfile;
+    if (!name) return undefined;
+    return readRuntimeAuthState(this.runtimeAuthStateFile).profiles[name]?.gameServerUrl;
   }
 
   setTtsKey(provider: string, key: string, profileName?: string): void {

package/src/lib/hub-install.test.ts

@@ -65,8 +65,8 @@ describe('installResource (strategy)', () => {
     expect(readLockfile()['strategy/ab12'].title).toBe('Aggressive Kill');
   });
   it('refuses untracked clobber without force', () => {
-    mkdirSync(join(ws, 'strategies'), { recursive: true });
-    writeFileSync(join(ws, 'strategies', 'aggressive-kill__ab12.ts'), 'old');
+    mkdirSync(join(ws, 'user-data', 'strategies'), { recursive: true });
+    writeFileSync(join(ws, 'user-data', 'strategies', 'aggressive-kill__ab12.ts'), 'old');
     expect(() => installResource(detail({}), Buffer.from('new'))).toThrow(/already exists/);
     expect(() => installResource(detail({}), Buffer.from('new'), { force: true })).not.toThrow();
   });