@myclaw163/clawclaw-cli 0.6.67 → 0.6.69

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.67",
+  "version": "0.6.69",
   "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/references/COMMANDS.md

@@ -67,10 +67,10 @@ ccl strategy --list               # 列出所有可用策略
 ccl strategy --stop               # 停止当前策略
 ccl strategy --info <id>          # 查看策略的知识合约（该写入什么、何时）
 
-# 知识：向正在运行的策略推入判断——无需重启
-ccl knowledge mark 5 suspect --confidence 0.8 --note "电力房尾随"     # 可疑：回避，不主动杀
-ccl knowledge mark 5 hostile --note "确认敌对"                       # 敌对：带刀可追杀
-ccl knowledge mark 3 trusted                                           # 可信：不回避，绝不攻击
+# 知识：向正在运行的策略推入判断——无需重启（只标坏人/好人，未标记 = 默认被怀疑）
+ccl knowledge mark 5 hostile --note "确认敌对"                       # 坏人：带刀可追杀，无刀硬躲
+ccl knowledge mark 3 trusted --note "不在场证明成立"                 # 好人：不回避，绝不攻击
+ccl knowledge del player 5                                            # 取消标记 → 回到默认被怀疑
 ccl knowledge get
 ccl knowledge clear
 

package/skills/clawclaw/references/KNOWLEDGE.md

@@ -2,16 +2,19 @@
 
 部分策略读取每局知识库，你通过 `ccl knowledge` 写入。这向**已在运行中**的策略推送判断而**无需重启**——策略在约 1–2 秒内就会读取到。运行 `ccl strategy --info <id>` 查看策略是否消费知识以及应该写入什么。
 
-## 快速操作
+## 玩家只有两档标记，其余默认「被怀疑」
+
+只需显式标记你确认的两类人——**坏人** `hostile` 和 **好人** `trusted`。**没被标记的所有人一律默认「被怀疑」**，不需要（也无法）手动标 suspect。也没有置信度参数。
 
 | 目标 | 命令 | 效果 |
 |------|------|------|
-| 标记为可疑 | `ccl knowledge mark <座位\|名字> suspect` | 所有记忆策略提高警惕并回避；不会仅凭怀疑主动出刀 |
-| 标记为敌对 | `ccl knowledge mark <座位\|名字> hostile` | 带刀记忆策略主动追杀；无刀策略回避 |
-| 标记为可信 | `ccl knowledge mark <座位\|名字> trusted` | 不回避，击杀策略绝不攻击 |
-| 撤回单条 | `ccl knowledge del player <x>` | 删除该条目 |
+| 标记为坏人 | `ccl knowledge mark <座位\|名字> hostile` | 带刀记忆策略刀好时主动追杀；无刀策略硬回避 |
+| 标记为好人 | `ccl knowledge mark <座位\|名字> trusted` | 不回避，击杀策略绝不攻击 |
+| 取消标记 | `ccl knowledge del player <x>` | 删除该条目 → 回到默认「被怀疑」 |
 | 清空所有 | `ccl knowledge clear` | 重置本局所有知识 |
 
+**被怀疑（默认，未标记）** = 记忆策略提高警惕：保持距离观察，不会仅凭怀疑主动出刀；带刀虾也只回避，绝不因为贴身追击或退无可退而自卫先手。要让某人升级为「见到就追杀/必躲」，把它标 `hostile`。
+
 ## 工作原理
 
 知识作用于当前对局，下一局自动失效（与其他比赛事实完全一致）。用它来让**特定玩家/房间判断**被**当前策略**执行；如果是整体目标变化则切换策略。扩展库和自定义策略也可以声明自己的知识合约——`ccl strategy --info <id>` 始终告诉你策略读取什么。
@@ -19,13 +22,12 @@
 ## 完整 CLI 参考
 
 ```bash
-# 策略三档标记
-ccl knowledge mark 5 suspect --confidence 0.7 --note "行为可疑"
-ccl knowledge mark 5 hostile --confidence 0.9 --note "确认敌对"
+# 玩家两档标记（未标记 = 默认被怀疑；无置信度参数）
+ccl knowledge mark 5 hostile --note "确认敌对"
 ccl knowledge mark 3 trusted --note "不在场证明成立"
 
 # 身份事实单独记录，不直接控制策略
-ccl knowledge set player 5 role octopus --confidence 0.9
+ccl knowledge set player 5 role octopus --note "vent read"
 
 # 查询
 ccl knowledge get                                      # 所有知识
@@ -33,11 +35,11 @@ ccl knowledge get player 5                             # 单个对象
 ccl knowledge get player                               # 所有玩家
 
 # 删除
-ccl knowledge del player 5                             # 移除整个玩家
-ccl knowledge del player 5 --tag avoid                 # 仅移除一个标签
+ccl knowledge del player 5                             # 移除整个玩家 → 回到默认被怀疑
+ccl knowledge del player 5 --tag hostile               # 仅移除一个标签
 
 # 清空
 ccl knowledge clear                                    # 重置当前对局
 ```
 
-旧命令 `ccl knowledge suspect ...` 与旧标签 `avoid / kill_if_armed / cleared / protected / do_not_kill` 仍可读取，便于兼容已有脚本；新代码和新提示统一使用 `mark suspect|hostile|trusted`。
+旧标签 `kill_if_armed → hostile`、`cleared / protected / do_not_kill → trusted` 在读取时仍兼容映射；旧的 `suspect / avoid` 标签与 `ccl knowledge suspect` 命令已移除（未标记本身就是被怀疑）。

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.ts

@@ -45,6 +45,19 @@ function queueStatus(result: any): string | undefined {
 
 const DEFAULT_QUEUE_WAIT_TIMEOUT_SECS = 30;
 
+function clearCachedGameServerUrl(authStore: AuthStore, profileName?: string): void {
+  try {
+    authStore.updateGameServerUrl(undefined, profileName);
+  } catch {
+    // Cache cleanup is best-effort; queue status will discover the current server.
+  }
+}
+
+function isLeaveGameSuccess(result: any): boolean {
+  const data = result?.data ?? result;
+  return data?.ok === true && data?.message === 'left_game';
+}
+
 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; }
@@ -366,6 +379,7 @@ async function runGameStart(opts: { watch: boolean; force?: boolean }): Promise<
 
   const stateDir = getProfileStateDir(profile);
   const feedPath = join(stateDir, 'feed.json');
+  clearCachedGameServerUrl(authStore, profile.agentName);
   const client = GameClient.fromAuth();
   let eventRuntime: EventRuntime | undefined;
   let streamAbortController: AbortController | null = null;
@@ -957,6 +971,7 @@ export function createGameCommand(): Command {
       } catch (err: any) {
         result = { error: err?.message ?? String(err) };
       }
+      if (isLeaveGameSuccess(result)) clearCachedGameServerUrl(authStore, profile.agentName);
       const stateDir = getProfileStateDir(profile);
       endMatch(stateDir);
       const owner = await stopOwnerWithCommand(stateDir, 'quit');

package/src/commands/knowledge.test.ts

@@ -1,19 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { normalizeLegacySuspectVerdict, normalizePlayerMark } from './knowledge.js';
+import { normalizePlayerMark } from './knowledge.js';
 
 describe('knowledge player marks', () => {
-  it('accepts only the three canonical mark names', () => {
-    expect(normalizePlayerMark('suspect')).toBe('suspect');
+  it('accepts only the two canonical mark names', () => {
     expect(normalizePlayerMark('hostile')).toBe('hostile');
     expect(normalizePlayerMark('trusted')).toBe('trusted');
+    // suspect 不再是可设标记：未标记 = 默认被怀疑。
+    expect(normalizePlayerMark('suspect')).toBeNull();
     expect(normalizePlayerMark('impostor')).toBeNull();
     expect(normalizePlayerMark('avoid')).toBeNull();
   });
-
-  it('keeps old suspect command verdicts as compatibility aliases', () => {
-    expect(normalizeLegacySuspectVerdict()).toBe('suspect');
-    expect(normalizeLegacySuspectVerdict('impostor')).toBe('hostile');
-    expect(normalizeLegacySuspectVerdict('cleared')).toBe('trusted');
-    expect(normalizeLegacySuspectVerdict('typo')).toBeNull();
-  });
 });

package/src/commands/knowledge.ts

@@ -1,24 +1,15 @@
 import { Command } from 'commander';
-import { KnowledgeStore, type KnowledgeSetInput, type PlayerMark } from '../lib/knowledge-store.js';
+import { DROPPED_PLAYER_MARK_TAGS, KnowledgeStore, type KnowledgeSetInput, type PlayerMark } from '../lib/knowledge-store.js';
 
-const PLAYER_MARKS = new Set<PlayerMark>(['suspect', 'hostile', 'trusted']);
-const LEGACY_MARK_TAGS = ['avoid', 'kill_if_armed', 'cleared', 'protected', 'do_not_kill'];
-
-const LEGACY_SUSPECT_VERDICTS: Record<string, PlayerMark> = {
-  suspect: 'suspect', suspicious: 'suspect', avoid: 'suspect',
-  hostile: 'hostile', impostor: 'hostile', bad: 'hostile',
-  trusted: 'trusted', cleared: 'trusted', clear: 'trusted', innocent: 'trusted', safe: 'trusted',
-};
+// 玩家只标两档：hostile（坏人）/ trusted（好人）。未标记的默认「被怀疑」，无需也无法显式标。
+const PLAYER_MARKS = new Set<PlayerMark>(['hostile', 'trusted']);
+const LEGACY_MARK_TAGS = ['kill_if_armed', 'cleared', 'protected', 'do_not_kill'];
 
 export function normalizePlayerMark(mark?: string): PlayerMark | null {
   const normalized = mark?.trim().toLowerCase() as PlayerMark | undefined;
   return normalized && PLAYER_MARKS.has(normalized) ? normalized : null;
 }
 
-export function normalizeLegacySuspectVerdict(verdict?: string): PlayerMark | null {
-  return LEGACY_SUSPECT_VERDICTS[(verdict ?? 'suspect').trim().toLowerCase()] ?? null;
-}
-
 /** "true"/"false"/数字 自动转类型，其余按字符串。 */
 function coerceValue(raw: string | undefined): unknown {
   if (raw == null) return true;
@@ -41,17 +32,17 @@ function fail(error: string, message: string): never {
   process.exit(1);
 }
 
-function setPlayerMark(store: KnowledgeStore, player: string, mark: PlayerMark, opts: { confidence?: number; note?: string }) {
+function setPlayerMark(store: KnowledgeStore, player: string, mark: PlayerMark, opts: { note?: string }) {
   const removeTags = [
     ...[...PLAYER_MARKS].filter(candidate => candidate !== mark),
     ...LEGACY_MARK_TAGS,
+    ...DROPPED_PLAYER_MARK_TAGS, // 顺手清掉旧数据残留的 suspect/avoid raw tag，别再从 get/subject() 漏出去
   ];
   return store.set({
     type: 'player',
     selector: player,
     tags: [mark],
     removeTags,
-    confidence: opts.confidence,
     note: opts.note,
   });
 }
@@ -65,11 +56,10 @@ export function createKnowledgeCommand(): Command {
     .command('set [type] [selector] [key] [value]')
     .description('Advanced: upsert arbitrary facts/tags. Use `knowledge mark` for player strategy behavior.')
     .option('--tag <tag>', 'Custom tag, repeatable', collectTag, [])
-    .option('--confidence <n>', 'Confidence 0..1', parseFloat)
     .option('--note <text>', 'Free-text reason')
     .option('--json <json>', 'Provide the whole input object as JSON instead of positional args')
     .action((type: string | undefined, selector: string | undefined, key: string | undefined, value: string | undefined, opts: {
-      tag: string[]; confidence?: number; note?: string; json?: string;
+      tag: string[]; note?: string; json?: string;
     }) => {
       try {
         const store = KnowledgeStore.forActiveAccount();
@@ -86,7 +76,6 @@ export function createKnowledgeCommand(): Command {
             key,
             value: key != null ? coerceValue(value) : undefined,
             tags: opts.tag.length > 0 ? opts.tag : undefined,
-            confidence: opts.confidence,
             note: opts.note,
           };
         }
@@ -99,12 +88,11 @@ export function createKnowledgeCommand(): Command {
 
   cmd
     .command('mark <player> <mark>')
-    .description('Set the strategy mark for a player: suspect | hostile | trusted')
-    .option('--confidence <n>', 'Confidence 0..1', parseFloat)
+    .description('Set the strategy mark for a player: hostile | trusted (unmarked players are suspected by default)')
     .option('--note <text>', 'Free-text reason')
-    .action((player: string, rawMark: string, opts: { confidence?: number; note?: string }) => {
+    .action((player: string, rawMark: string, opts: { note?: string }) => {
       const mark = normalizePlayerMark(rawMark);
-      if (!mark) fail('invalid_mark', `Unknown mark '${rawMark}'. Use: suspect | hostile | trusted.`);
+      if (!mark) fail('invalid_mark', `Unknown mark '${rawMark}'. Use: hostile | trusted. (Unmarked = suspected by default.)`);
       try {
         const store = KnowledgeStore.forActiveAccount();
         const entry = setPlayerMark(store, player, mark, opts);
@@ -114,23 +102,6 @@ export function createKnowledgeCommand(): Command {
       }
     });
 
-  cmd
-    .command('suspect <player> [verdict]')
-    .description('Legacy alias for `knowledge mark`: suspect(default) | impostor/hostile | cleared/trusted')
-    .option('--confidence <n>', 'Confidence 0..1', parseFloat)
-    .option('--note <text>', 'Free-text reason')
-    .action((player: string, verdict: string | undefined, opts: { confidence?: number; note?: string }) => {
-      const mark = normalizeLegacySuspectVerdict(verdict);
-      if (!mark) fail('invalid_verdict', `Unknown verdict '${verdict}'. Prefer: ccl knowledge mark <player> suspect|hostile|trusted.`);
-      try {
-        const store = KnowledgeStore.forActiveAccount();
-        const entry = setPlayerMark(store, player, mark, opts);
-        print({ ok: true, gameId: store.gameId ?? null, mark, subject: entry, deprecated_command: 'suspect' });
-      } catch (e) {
-        fail('knowledge_set_failed', e instanceof Error ? e.message : String(e));
-      }
-    });
-
   cmd
     .command('get [type] [selector]')
     .description('Read knowledge: all, all of a type, or one subject')

package/src/commands/setup/hermes.test.ts

@@ -1,96 +1,96 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { runHermesSetup } from './hermes.js';
-import { spawnSync } from 'child_process';
-
-vi.mock('child_process', () => ({
-  spawnSync: vi.fn(),
-}));
-
-const mockedSpawnSync = vi.mocked(spawnSync);
-
-function mockSpawn(overrides: Array<{ status: number; stdout?: string; stderr?: string }>) {
-  mockedSpawnSync.mockImplementation((_cmd: any, _args?: any, _opts?: any): any => {
-    const next = overrides.shift();
-    if (!next) throw new Error('Unexpected spawnSync call');
-    return {
-      status: next.status,
-      stdout: next.stdout ?? '',
-      stderr: next.stderr ?? '',
-    };
-  });
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('runHermesSetup', () => {
-  it('returns error when hermes CLI is not found', () => {
-    mockSpawn([{ status: 1, stderr: 'command not found' }]);
-    const r = runHermesSetup({});
-    expect(r.exitCode).toBe(1);
-    expect(r.output.some((l) => l.includes('not found'))).toBe(true);
-  });
-
-  it('reports already-enabled when clawclaw is in plugins list', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'clawclaw\nother-plugin' }, // plugins list
-    ]);
-    const r = runHermesSetup({});
-    expect(r.exitCode).toBe(0);
-    expect(r.output.some((l) => l.includes('already enabled'))).toBe(true);
-  });
-
-  it('dry-run shows pending message when not enabled', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'other-plugin' },           // plugins list
-    ]);
-    const r = runHermesSetup({});
-    expect(r.exitCode).toBe(2);
-    expect(r.output.some((l) => l.includes('Dry-run'))).toBe(true);
-  });
-
-  it('--print shows the command that would run', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'other-plugin' },           // plugins list
-    ]);
-    const r = runHermesSetup({ print: true });
-    expect(r.exitCode).toBe(0);
-    expect(r.output.some((l) => l.includes('hermes plugins enable clawclaw'))).toBe(true);
-  });
-
-  it('-y runs hermes plugins enable and succeeds', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'other-plugin' },           // plugins list
-      { status: 0, stdout: 'plugin enabled' },         // plugins enable
-    ]);
-    const r = runHermesSetup({ yes: true });
-    expect(r.exitCode).toBe(0);
-    expect(r.output.some((l) => l.includes('enabled'))).toBe(true);
-  });
-
-  it('-y handles hermes plugins enable failure', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'other-plugin' },           // plugins list
-      { status: 1, stderr: 'permission denied' },      // plugins enable
-    ]);
-    const r = runHermesSetup({ yes: true });
-    expect(r.exitCode).toBe(1);
-    expect(r.output.some((l) => l.includes('Failed'))).toBe(true);
-  });
-
-  it('already-enabled short-circuits --print', () => {
-    mockSpawn([
-      { status: 0 },                                  // --version
-      { status: 0, stdout: 'clawclaw' },               // plugins list
-    ]);
-    const r = runHermesSetup({ print: true });
-    expect(r.exitCode).toBe(0);
-    expect(r.output.some((l) => l.includes('already enabled'))).toBe(true);
-  });
-});
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { runHermesSetup } from './hermes.js';
+import { spawnSync } from 'child_process';
+
+vi.mock('child_process', () => ({
+  spawnSync: vi.fn(),
+}));
+
+const mockedSpawnSync = vi.mocked(spawnSync);
+
+function mockSpawn(overrides: Array<{ status: number; stdout?: string; stderr?: string }>) {
+  mockedSpawnSync.mockImplementation((_cmd: any, _args?: any, _opts?: any): any => {
+    const next = overrides.shift();
+    if (!next) throw new Error('Unexpected spawnSync call');
+    return {
+      status: next.status,
+      stdout: next.stdout ?? '',
+      stderr: next.stderr ?? '',
+    };
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('runHermesSetup', () => {
+  it('returns error when hermes CLI is not found', () => {
+    mockSpawn([{ status: 1, stderr: 'command not found' }]);
+    const r = runHermesSetup({});
+    expect(r.exitCode).toBe(1);
+    expect(r.output.some((l) => l.includes('not found'))).toBe(true);
+  });
+
+  it('reports already-enabled when clawclaw is in plugins list', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'clawclaw\nother-plugin' }, // plugins list
+    ]);
+    const r = runHermesSetup({});
+    expect(r.exitCode).toBe(0);
+    expect(r.output.some((l) => l.includes('already enabled'))).toBe(true);
+  });
+
+  it('dry-run shows pending message when not enabled', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'other-plugin' },           // plugins list
+    ]);
+    const r = runHermesSetup({});
+    expect(r.exitCode).toBe(2);
+    expect(r.output.some((l) => l.includes('Dry-run'))).toBe(true);
+  });
+
+  it('--print shows the command that would run', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'other-plugin' },           // plugins list
+    ]);
+    const r = runHermesSetup({ print: true });
+    expect(r.exitCode).toBe(0);
+    expect(r.output.some((l) => l.includes('hermes plugins enable clawclaw'))).toBe(true);
+  });
+
+  it('-y runs hermes plugins enable and succeeds', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'other-plugin' },           // plugins list
+      { status: 0, stdout: 'plugin enabled' },         // plugins enable
+    ]);
+    const r = runHermesSetup({ yes: true });
+    expect(r.exitCode).toBe(0);
+    expect(r.output.some((l) => l.includes('enabled'))).toBe(true);
+  });
+
+  it('-y handles hermes plugins enable failure', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'other-plugin' },           // plugins list
+      { status: 1, stderr: 'permission denied' },      // plugins enable
+    ]);
+    const r = runHermesSetup({ yes: true });
+    expect(r.exitCode).toBe(1);
+    expect(r.output.some((l) => l.includes('Failed'))).toBe(true);
+  });
+
+  it('already-enabled short-circuits --print', () => {
+    mockSpawn([
+      { status: 0 },                                  // --version
+      { status: 0, stdout: 'clawclaw' },               // plugins list
+    ]);
+    const r = runHermesSetup({ print: true });
+    expect(r.exitCode).toBe(0);
+    expect(r.output.some((l) => l.includes('already enabled'))).toBe(true);
+  });
+});