@myclaw163/clawclaw-cli 0.6.67 → 0.6.68

package/src/lib/knowledge-store.test.ts

@@ -46,8 +46,7 @@ describe('KnowledgeStore', () => {
       selector: '5',
       key: 'role',
       value: 'impostor',
-      tags: ['suspect', 'kill_if_armed'],
-      confidence: 0.8,
+      tags: ['kill_if_armed'],
       note: 'vent read',
     });
 
@@ -55,9 +54,7 @@ describe('KnowledgeStore', () => {
 
     expect(file?.gameId).toBe('game-1');
     expect(file?.subjects['player:5']?.facts?.role.value).toBe('impostor');
-    expect(file?.subjects['player:5']?.facts?.role.confidence).toBe(0.8);
-    expect(file?.subjects['player:5']?.tags?.suspect.note).toBe('vent read');
-    expect(file?.subjects['player:5']?.tags?.kill_if_armed.confidence).toBe(0.8);
+    expect(file?.subjects['player:5']?.tags?.kill_if_armed.note).toBe('vent read');
   });
 
   it('preserves explicit null fact values', () => {
@@ -79,16 +76,8 @@ describe('KnowledgeStore', () => {
     expect(readKnowledgeFileResult(path).status).toBe('invalid');
   });
 
-  it('rejects invalid confidence values', () => {
-    const s = store();
-
-    expect(() => s.set({ type: 'player', selector: '5', tags: ['avoid'], confidence: Number.NaN })).toThrow(/confidence/);
-    expect(() => s.set({ type: 'player', selector: '5', tags: ['avoid'], confidence: -0.1 })).toThrow(/confidence/);
-    expect(() => s.set({ type: 'player', selector: '5', tags: ['avoid'], confidence: 1.1 })).toThrow(/confidence/);
-  });
-
   it('returns an empty file when loading knowledge from another game', () => {
-    store('old-game').set({ type: 'player', selector: '5', tags: ['avoid'] });
+    store('old-game').set({ type: 'player', selector: '5', tags: ['hostile'] });
 
     expect(store('new-game').list()).toEqual({
       version: 1,
@@ -97,14 +86,30 @@ describe('KnowledgeStore', () => {
     });
   });
 
+  it('treats unmarked players as suspected by default', () => {
+    const s = store();
+    s.set({ type: 'player', selector: '5', tags: ['hostile'] });
+
+    const v = view({ '5': 'Bob', '9': 'Zed' });
+
+    // 显式标记的两档
+    expect(v.isHostile({ seat: 5 })).toBe(true);
+    expect(v.isSuspect({ seat: 5 })).toBe(false);
+    // 完全没标记的人 = 被怀疑（markOf 返回 undefined）
+    expect(v.markOf({ seat: 9 })).toBeUndefined();
+    expect(v.isSuspect({ name: 'Zed' })).toBe(true);
+    expect(v.isHostile({ seat: 9 })).toBe(false);
+    expect(v.isTrusted({ seat: 9 })).toBe(false);
+  });
+
   it('aggregates player marks written by seat and by name', () => {
     const s = store();
-    s.set({ type: 'player', selector: '5', tags: ['suspect'] });
+    s.set({ type: 'player', selector: '5', tags: ['hostile'] });
 
     const v = view({ '5': 'Bob' });
 
-    expect(v.isSuspect({ name: 'Bob' })).toBe(true);
-    expect(v.markOf({ seat: 5 })).toBe('suspect');
+    expect(v.isHostile({ name: 'Bob' })).toBe(true);
+    expect(v.markOf({ seat: 5 })).toBe('hostile');
   });
 
   it('uses the latest mark across seat and name selectors', () => {
@@ -127,12 +132,12 @@ describe('KnowledgeStore', () => {
   it('keeps role facts independent from strategy marks', () => {
     const s = store();
     s.set({ type: 'player', selector: '5', key: 'role', value: 'impostor' });
-    s.set({ type: 'player', selector: '5', tags: ['suspect'] });
+    s.set({ type: 'player', selector: '5', tags: ['trusted'] });
 
     const v = view();
 
     expect(v.roleOf({ seat: 5 })).toBe('impostor');
-    expect(v.markOf({ seat: 5 })).toBe('suspect');
+    expect(v.markOf({ seat: 5 })).toBe('trusted');
     expect(v.isHostile({ seat: 5 })).toBe(false);
   });
 
@@ -140,38 +145,23 @@ describe('KnowledgeStore', () => {
     const s = store();
     s.set({ type: 'player', selector: '5', tags: ['trusted'] });
     tick();
-    s.set({ type: 'player', selector: 'Bob', tags: ['suspect'] });
+    s.set({ type: 'player', selector: 'Bob', tags: ['hostile'] });
 
     const v = view({ '5': 'Bob' });
 
-    expect(v.isSuspect({ seat: 5 })).toBe(true);
+    expect(v.isHostile({ seat: 5 })).toBe(true);
     expect(v.isTrusted({ seat: 5 })).toBe(false);
     expect(v.selectorsWithTag('player', 'trusted')).toEqual([]);
-    expect(v.selectorsWithTag('player', 'suspect')).toEqual(['Bob']);
-  });
-
-  it('applies confidence thresholds to facts and tags', () => {
-    const s = store();
-    s.set({ type: 'player', selector: '5', tags: ['suspect'], confidence: 0.5 });
-    s.set({ type: 'player', selector: '6', tags: ['hostile'], confidence: 0.7 });
-
-    const v = view();
-
-    expect(v.isSuspect({ seat: 5 }, 0.4)).toBe(true);
-    expect(v.isSuspect({ seat: 5 }, 0.6)).toBe(false);
-    expect(v.isHostile({ seat: 6 }, 0.6)).toBe(true);
-    expect(v.isHostile({ seat: 6 }, 0.8)).toBe(false);
+    expect(v.selectorsWithTag('player', 'hostile')).toEqual(['Bob']);
   });
 
-  it('maps legacy tags onto the three canonical marks', () => {
+  it('maps legacy tags onto the two canonical marks', () => {
     const s = store();
-    s.set({ type: 'player', selector: '5', tags: ['avoid'] });
     s.set({ type: 'player', selector: '6', tags: ['kill_if_armed'] });
     s.set({ type: 'player', selector: '7', tags: ['protected'] });
 
     const v = view();
 
-    expect(v.markOf({ seat: 5 })).toBe('suspect');
     expect(v.markOf({ seat: 6 })).toBe('hostile');
     expect(v.markOf({ seat: 7 })).toBe('trusted');
     expect(v.hasTag({ seat: 6 }, 'hostile')).toBe(true);

package/src/lib/knowledge-store.ts

@@ -5,8 +5,9 @@
  *  - 跨进程：Agent（短进程 CLI）写，strategy（长进程 loop）按 mtime 轮询读，免重启。
  *  - 快照而非日志：单个 JSON 对象，del/clear 直接重写；写入用临时文件 + rename 原子替换。
  *  - gameId 作用域：每份知识标记所属对局（= 最新 session 文件名），换局自动失效。
- *  - 价值中立：只存推断 + confidence/source，对 value 不做价值判断；
+ *  - 价值中立：只存推断 + source，对 value 不做价值判断；
  *    确定事实（role/队友/尸体…）走 state/ctx.teammates，不入库。
+ *  - 玩家两档标记：只显式标 hostile（坏人）/ trusted（好人），未标记的一律默认「被怀疑」，不再有 suspect 标记，也不存置信度。
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
@@ -20,14 +21,12 @@ export type KnowledgeScope = 'game' | 'session' | 'persistent';
 
 export interface FactMeta {
   value: unknown;
-  confidence?: number;
   note?: string;
   source?: KnowledgeSource;
   ts: number;
 }
 
 export interface TagMeta {
-  confidence?: number;
   note?: string;
   source?: KnowledgeSource;
   ts: number;
@@ -38,7 +37,7 @@ export interface SubjectEntry {
   type: string;                          // 'player' | 'room' | 'task' | 'global' | <自定义>
   selector: string;                      // player→座位号或名字；room→房名；global→''
   facts?: Record<string, FactMeta>;      // 键值事实，如 role: { value: 'impostor' }
-  tags?: Record<string, TagMeta>;        // 玩家策略主标记：suspect / hostile / trusted；也支持自定义标签
+  tags?: Record<string, TagMeta>;        // 玩家策略主标记：hostile / trusted（未标记默认被怀疑）；也支持自定义标签
   scope?: KnowledgeScope;
 }
 
@@ -56,7 +55,8 @@ export type KnowledgeFileReadResult =
 export type PlayerRef = { name?: string; seat?: number };
 export type SubjectRef = { type: string; selector: string };
 export type KnowledgeRef = PlayerRef | SubjectRef;
-export type PlayerMark = 'suspect' | 'hostile' | 'trusted';
+/** 玩家显式标记只有两档：hostile（坏人）/ trusted（好人）。未标记 = 被怀疑（markOf 返回 undefined）。 */
+export type PlayerMark = 'hostile' | 'trusted';
 
 export interface KnowledgeView {
   /** 当前没有任何知识时为 true。 */
@@ -65,28 +65,24 @@ export interface KnowledgeView {
   subject(type: string, selector: string): SubjectEntry | undefined;
   /** 取某 subject 的键值事实。player ref 会按座位↔名字归一化解析。 */
   getFact(ref: KnowledgeRef, key: string): FactMeta | undefined;
-  /** 该 subject 是否带某标签（可选最低置信度门槛）。玩家三档 mark 及旧别名按最新结论解析。 */
-  hasTag(ref: KnowledgeRef, tag: string, minConfidence?: number): boolean;
-  /** 按 type / tag / factKey / 置信度筛选 subject。玩家 mark 标签同样遵守最新结论。 */
-  query(q: { type?: string; tag?: string; factKey?: string; minConfidence?: number }): SubjectEntry[];
+  /** 该 subject 是否带某标签。玩家两档 mark 及旧别名按最新结论解析。 */
+  hasTag(ref: KnowledgeRef, tag: string): boolean;
+  /** 按 type / tag / factKey 筛选 subject。玩家 mark 标签同样遵守最新结论。 */
+  query(q: { type?: string; tag?: string; factKey?: string }): SubjectEntry[];
   /** 某 type 下带某标签的全部 selector（喂给 matchesAnyTarget 用）。玩家 mark 标签同样过滤旧结论。 */
-  selectorsWithTag(type: string, tag: string, minConfidence?: number): string[];
+  selectorsWithTag(type: string, tag: string): string[];
   // —— player 便捷语法糖 ——
   /** 最近一次 role 事实。身份事实与策略 mark 完全解耦。 */
   roleOf(p: PlayerRef): string | undefined;
-  markOf(p: PlayerRef, minConfidence?: number): PlayerMark | undefined;
-  isSuspect(p: PlayerRef, minConfidence?: number): boolean;
-  isHostile(p: PlayerRef, minConfidence?: number): boolean;
-  isTrusted(p: PlayerRef, minConfidence?: number): boolean;
-  /** @deprecated Use isHostile. */
-  isConfirmedHostile(p: PlayerRef, minConfidence?: number): boolean;
-  /** @deprecated Use isTrusted. */
-  isCleared(p: PlayerRef): boolean;
+  /** 最新显式标记；未标记返回 undefined（= 被怀疑）。 */
+  markOf(p: PlayerRef): PlayerMark | undefined;
+  /** 被怀疑 = 既非 hostile 也非 trusted（含完全未标记者）。 */
+  isSuspect(p: PlayerRef): boolean;
+  isHostile(p: PlayerRef): boolean;
+  isTrusted(p: PlayerRef): boolean;
 }
 
 const PLAYER_MARK_ALIASES: Record<string, PlayerMark> = {
-  suspect: 'suspect',
-  avoid: 'suspect',
   hostile: 'hostile',
   kill_if_armed: 'hostile',
   trusted: 'trusted',
@@ -95,6 +91,14 @@ const PLAYER_MARK_ALIASES: Record<string, PlayerMark> = {
   do_not_kill: 'trusted',
 };
 
+/**
+ * 两档化后被废弃的旧玩家标记：一律视同未标记（= 被怀疑），不映射到任何 canonical mark
+ *（「被怀疑」就是默认态，没有对应标签）。读取侧与写入侧共用这一份清单，避免漂移：
+ *  - 读取侧（buildKnowledgeView.tagActive）：旧数据里的 tags.suspect / tags.avoid 不再被 hasTag / query / selectorsWithTag 命中。
+ *  - 写入侧（knowledge mark 的 removeTags）：改判玩家时顺手删掉残留的 raw tag，否则 knowledge get / subject() 仍会暴露 tags.suspect/avoid 误导人。
+ */
+export const DROPPED_PLAYER_MARK_TAGS = new Set(['suspect', 'avoid']);
+
 function nowTs(): number {
   return Date.now();
 }
@@ -180,7 +184,6 @@ export interface KnowledgeSetInput {
   value?: unknown;
   tags?: string[];
   removeTags?: string[];
-  confidence?: number;
   note?: string;
   source?: KnowledgeSource;
   scope?: KnowledgeScope;
@@ -210,9 +213,6 @@ export class KnowledgeStore {
 
   set(input: KnowledgeSetInput): SubjectEntry {
     if (!input.type || !input.selector) throw new Error('knowledge set requires type and selector');
-    if (input.confidence != null && (!Number.isFinite(input.confidence) || input.confidence < 0 || input.confidence > 1)) {
-      throw new Error('confidence must be a finite number between 0 and 1');
-    }
     const file = this.load();
     const key = subjectKey(input.type, input.selector);
     const entry: SubjectEntry = file.subjects[key] ?? { type: input.type, selector: input.selector };
@@ -223,7 +223,6 @@ export class KnowledgeStore {
       entry.facts = entry.facts ?? {};
       entry.facts[input.key] = {
         value: input.value === undefined ? true : input.value,
-        confidence: input.confidence,
         note: input.note,
         source,
         ts,
@@ -233,7 +232,7 @@ export class KnowledgeStore {
       entry.tags = entry.tags ?? {};
       for (const tag of input.tags) {
         if (!tag) continue;
-        entry.tags[tag] = { confidence: input.confidence, note: input.note, source, ts };
+        entry.tags[tag] = { note: input.note, source, ts };
       }
     }
     if (input.removeTags && entry.tags) {
@@ -283,7 +282,6 @@ export function buildKnowledgeView(
 ): KnowledgeView {
   const subjects = file?.subjects ?? {};
   const namesBySeat = opts.playerNamesBySeat ?? {};
-  const confOk = (conf: number | undefined, min?: number): boolean => min == null || (conf ?? 1) >= min;
 
   const resolveAll = (ref: KnowledgeRef): SubjectEntry[] => {
     if (isSubjectRef(ref)) {
@@ -302,8 +300,9 @@ export function buildKnowledgeView(
     return best;
   };
 
-  type MarkVerdict = { kind: PlayerMark; ts: number; confidence?: number };
-  const markRank = (kind: PlayerMark): number => kind === 'trusted' ? 3 : kind === 'hostile' ? 2 : 1;
+  type MarkVerdict = { kind: PlayerMark; ts: number };
+  // 同一时刻打了冲突标记时，trusted 优先级高于 hostile（好人判断更慎重，不轻易被覆盖）。
+  const markRank = (kind: PlayerMark): number => kind === 'trusted' ? 2 : 1;
   const latestMark = (ref: KnowledgeRef): MarkVerdict | undefined => {
     let best: MarkVerdict | undefined;
     const take = (v: MarkVerdict) => {
@@ -316,56 +315,52 @@ export function buildKnowledgeView(
     for (const s of resolveAll(ref)) {
       for (const [tag, meta] of Object.entries(s.tags ?? {})) {
         const kind = PLAYER_MARK_ALIASES[tag];
-        if (kind) take({ kind, ts: meta.ts, confidence: meta.confidence });
+        if (kind) take({ kind, ts: meta.ts });
       }
     }
     return best;
   };
 
   const markKindForTag = (tag: string): PlayerMark | undefined => PLAYER_MARK_ALIASES[tag];
-  const tagActive = (s: SubjectEntry, tag: string, min?: number): boolean => {
-    const requestedMark = markKindForTag(tag);
-    if (s.type === 'player' && requestedMark) {
-      const carriesRequestedMark = Object.keys(s.tags ?? {}).some(candidate => markKindForTag(candidate) === requestedMark);
-      if (!carriesRequestedMark) return false;
-      const ref: PlayerRef = /^\d+$/.test(s.selector.trim()) ? { seat: Number(s.selector) } : { name: s.selector };
-      const mark = latestMark(ref);
-      return !!mark && mark.kind === requestedMark && confOk(mark.confidence, min);
+  const tagActive = (s: SubjectEntry, tag: string): boolean => {
+    if (s.type === 'player') {
+      const requestedMark = markKindForTag(tag);
+      if (requestedMark) {
+        const carriesRequestedMark = Object.keys(s.tags ?? {}).some(candidate => markKindForTag(candidate) === requestedMark);
+        if (!carriesRequestedMark) return false;
+        const ref: PlayerRef = /^\d+$/.test(s.selector.trim()) ? { seat: Number(s.selector) } : { name: s.selector };
+        const mark = latestMark(ref);
+        return !!mark && mark.kind === requestedMark;
+      }
+      // 废弃的旧玩家标记（suspect/avoid）= 未标记 = 被怀疑，绝不命中；其余自定义标签（如 paradise_fish）照常按原值判定。
+      if (DROPPED_PLAYER_MARK_TAGS.has(tag)) return false;
     }
-    const meta = s.tags?.[tag];
-    return !!meta && confOk(meta.confidence, min);
+    return !!s.tags?.[tag];
   };
 
   return {
     empty: Object.keys(subjects).length === 0,
     subject: (type, selector) => subjects[subjectKey(type, selector)],
     getFact: (ref, key) => latestFact(ref, key),
-    hasTag: (ref, tag, min) => resolveAll(ref).some((s) => tagActive(s, tag, min)),
+    hasTag: (ref, tag) => resolveAll(ref).some((s) => tagActive(s, tag)),
     query: (q) => Object.values(subjects).filter((s) => {
       if (q.type && s.type !== q.type) return false;
-      if (q.factKey) {
-        const f = s.facts?.[q.factKey];
-        if (!f || !confOk(f.confidence, q.minConfidence)) return false;
-      }
-      if (q.tag && !tagActive(s, q.tag, q.minConfidence)) return false;
+      if (q.factKey && !s.facts?.[q.factKey]) return false;
+      if (q.tag && !tagActive(s, q.tag)) return false;
       return true;
     }),
-    selectorsWithTag: (type, tag, min) => Object.values(subjects)
-      .filter((s) => s.type === type && tagActive(s, tag, min))
+    selectorsWithTag: (type, tag) => Object.values(subjects)
+      .filter((s) => s.type === type && tagActive(s, tag))
       .map((s) => s.selector),
     roleOf: (p) => {
       const fact = latestFact(p, 'role');
       return typeof fact?.value === 'string' ? fact.value : undefined;
     },
-    markOf: (p, min) => {
-      const mark = latestMark(p);
-      return mark && confOk(mark.confidence, min) ? mark.kind : undefined;
-    },
-    isSuspect: (p, min) => latestMark(p)?.kind === 'suspect' && confOk(latestMark(p)?.confidence, min),
-    isHostile: (p, min) => latestMark(p)?.kind === 'hostile' && confOk(latestMark(p)?.confidence, min),
-    isTrusted: (p, min) => latestMark(p)?.kind === 'trusted' && confOk(latestMark(p)?.confidence, min),
-    isConfirmedHostile: (p, min) => latestMark(p)?.kind === 'hostile' && confOk(latestMark(p)?.confidence, min),
-    isCleared: (p) => latestMark(p)?.kind === 'trusted',
+    markOf: (p) => latestMark(p)?.kind,
+    // 未标记 hostile/trusted 的玩家一律「被怀疑」——这就是「除好人坏人外剩下全是被怀疑」的落点。
+    isSuspect: (p) => !latestMark(p),
+    isHostile: (p) => latestMark(p)?.kind === 'hostile',
+    isTrusted: (p) => latestMark(p)?.kind === 'trusted',
   };
 }
 

package/src/sdk/index.ts

@@ -21,8 +21,7 @@
  *     hasKnownCorpse / corpseAtScene / nearestReportableCorpse / safePatrolStep /
  *     nonTeammatesVisible / matchesTarget / isTargetAlive / nearestVisibleTarget /
  *     pursueVisibleTarget / killCooldownSecs / hasKillUseRemaining / canUseKill / killRangeFor / killCommitRange /
- *     isKnowledgeHostile / isKnowledgeThreat / isKnowledgeTrusted
- *     (含 @deprecated 别名 isKnowledgeKillTarget / isKnowledgeAvoid / isKnowledgeProtected) /
+ *     isKnowledgeHostile（坏人）/ isKnowledgeThreat（非 trusted = 坏人+被怀疑）/ isKnowledgeTrusted（好人）/
  *     PatrolState / SafeTaskOptions / SafePatrolOptions + 常量(TASK_SUBMIT_RADIUS /
  *     SHRIMP_VISION_RANGE / SHRIMP_VISION_EXIT_BUFFER / SHRIMP_VISION_RELEASE_RANGE /
  *     FOLLOW_RANGE / PATROL_REACHED_DISTANCE / PROGRESS_INTERVAL_MS)
@@ -53,12 +52,12 @@ export type {
 // Game utilities (for user strategies)
 export {
   dist, firstAvailableTask, nearestKnownCorpse, nearestKnownCorpseNav, hasKnownCorpse, corpseAtScene, nearestReportableCorpse,
+  emergencyRushDecision, EMERGENCY_RUSH_ALIVE_THRESHOLD,
   safePatrolStep,
   nonTeammatesVisible, matchesTarget, isTargetAlive,
   nearestVisibleTarget, pursueVisibleTarget,
   killCooldownSecs, hasKillUseRemaining, canUseKill, killRangeFor, killCommitRange,
   isKnowledgeHostile, isKnowledgeThreat, isKnowledgeTrusted,
-  isKnowledgeKillTarget, isKnowledgeAvoid, isKnowledgeProtected,
   PatrolState,
   TASK_SUBMIT_RADIUS, SHRIMP_VISION_RANGE, SHRIMP_VISION_EXIT_BUFFER, SHRIMP_VISION_RELEASE_RANGE,
   FOLLOW_RANGE, PATROL_REACHED_DISTANCE,

package/src/sdk/types.ts

@@ -130,6 +130,8 @@ export interface GameState {
   players: PlayerInfo[];
   corpses: CorpseInfo[];
   emergency?: EmergencyInfo;
+  /** 服务端下发的「已知存活人数」：存活者 + 本玩家尚未目睹其死亡者之和。残局抢修紧急任务的门槛。 */
+  alive_count?: number;
   task_progress?: { completed: number; goal: number };
   new_events?: Array<Record<string, any>>;
   stale: boolean;

package/src/strategies/avoid-players.knowledge.md

@@ -1,20 +1,19 @@
 # avoid-players 知识契约
 
-`avoid-players` 读取统一的玩家三档标记：
+`avoid-players` 读取两档玩家标记，**未标记的一律默认「被怀疑」**：
 
 | 标记 | 行为 |
 |------|------|
-| `suspect` | 加入回避名单，进入视野便逃离 |
-| `hostile` | 加入回避名单，进入视野便逃离 |
-| `trusted` | 不因知识标记而回避 |
+| `hostile`（坏人） | 加入回避名单，进入视野便逃离 |
+| `trusted`（好人） | 不因知识标记而回避 |
+| 未标记（被怀疑） | 不自动回避——照常按房间巡逻（需要躲谁就把它标 hostile，或用启动参数点名） |
 
-回避名单 = 启动参数（座位号/名字）∪ suspect/hostile 标记。威胁消失后恢复巡逻。
+回避名单 = 启动参数（座位号/名字）∪ 知识库 hostile 标记。威胁消失后恢复巡逻。
 
 ```bash
-ccl knowledge mark 4 suspect --confidence 0.7 --note "贴脸尾随"
-ccl knowledge mark 4 hostile --confidence 0.9 --note "确认危险"
+ccl knowledge mark 4 hostile --note "确认危险"
 ccl knowledge mark 4 trusted --note "已澄清"
-ccl knowledge del player 4
+ccl knowledge del player 4            # 取消标记 → 回到默认「被怀疑」（不自动回避）
 ```
 
 `role` 是纯身份事实，不直接控制策略。

package/src/strategies/avoid-players.ts

@@ -5,7 +5,7 @@ import { parseTargetArgs } from './player-targets.js';
 
 export const strategy: StrategyEntry = {
   id: 'avoid-players',
-  description: '回避玩家：按房间顺序巡逻，视野里出现回避目标就寻路躲避（推演逃点、持续远离），威胁消失后恢复巡逻。回避名单 = 启动参数（座位号或名字，可多人，可省略）∪ 知识库中标记为 suspect/hostile 的玩家；trusted 不回避。Agent 可用 `ccl knowledge mark` 动态改判，免重启。',
+  description: '回避玩家：按房间顺序巡逻，视野里出现回避目标就寻路躲避（推演逃点、持续远离），威胁消失后恢复巡逻。回避名单 = 启动参数（座位号或名字，可多人，可省略）∪ 知识库中标记为 hostile（坏人）的玩家；trusted 与未标记的被怀疑者都不自动回避（要躲就标 hostile 或用启动参数点名）。Agent 可用 `ccl knowledge mark` 动态改判，免重启。',
   create(args?: string[]) {
     const targets = args ? parseTargetArgs(args) : [];
     return new GoalRootStrategy('avoid-players', () => new AvoidPlayersTop(targets), {

package/src/strategies/corpse-patrol.ts

@@ -15,7 +15,7 @@ class CorpsePatrolStrategy extends GoalRootStrategy {
 
 export const strategy: StrategyEntry = {
   id: 'corpse-patrol',
-  description: '发现尸体就在附近40至100距离内随机游荡，但不报告——故意在尸体旁出没制造嫌疑感。没有尸体时巡逻各房间。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。不做任务，不杀人。（天堂鱼默认；进阶版见 paradise-fish）参数：可选：1~3 条打招呼话术。',
+  description: '发现尸体就在附近40至100距离内随机游荡，但不报告——故意在尸体旁出没制造嫌疑感。没有尸体时巡逻各房间。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。不做任务，不杀人；但残局（已知存活≤6）出现紧急维修任务时例外，会最高优先级抢着去做，阻止蟹靠破坏倒计时取胜。（天堂鱼默认；进阶版见 paradise-fish）参数：可选：1~3 条打招呼话术。',
   create(args?: string[]) {
     return new CorpsePatrolStrategy(parseGreetingArgs(args, 'corpse-patrol'));
   },

package/src/strategies/game-utils.ts

@@ -327,6 +327,26 @@ export function taskMoveDecision(state: GameState, ctx: StrategyContext, task: T
   return { action: Action.move({ x: task.x!, y: task.y! }) };
 }
 
+/** 已知存活人数 ≤ 此值才触发「残局抢修紧急任务」。 */
+export const EMERGENCY_RUSH_ALIVE_THRESHOLD = 6;
+
+/**
+ * 残局抢修紧急维修任务的「靠近 → 到点提交」决策：已知存活人数（state.alive_count，含本玩家尚未目睹其
+ * 死亡者）≤ EMERGENCY_RUSH_ALIVE_THRESHOLD 且当前有进行中的紧急任务时返回该单步决策，否则返回 null
+ * （行为不触发，调用方按自身原优先级继续）。
+ *
+ * 背景：紧急任务超时则蟹阵营直接获胜（后端倒计时），而中立的章鱼/天堂鱼要靠活到最后取胜，因此残局应抢着
+ * 把维修做掉、掐断蟹的破坏取胜线。服务端已放开中立/蟹阵营提交紧急任务。紧急任务被任意玩家完成 / 开会 /
+ * 超时后，服务端会清空 state.emergency（→ ctx.emergency 为 null），本函数随之自动返回 null。
+ */
+export function emergencyRushDecision(state: GameState, ctx: StrategyContext): BehaviorDecision | null {
+  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD) {
+    return null;
+  }
+  const emergency = firstAvailableTask([], () => true, ctx.emergency, ctx.blockedMoveTarget);
+  return emergency ? taskMoveDecision(state, ctx, emergency) : null;
+}
+
 export function nearestReportableCorpse(state: GameState): GameState['corpses'][number] | null {
   const nearby = state.corpses
     .map(corpse => {
@@ -666,29 +686,21 @@ function knowledgeOf(ctx: StrategyContext) {
   return ctx.knowledge ?? FALLBACK_KNOWLEDGE;
 }
 
-/** hostile：带刀策略可主动攻击；无刀策略应回避。 */
-export function isKnowledgeHostile(p: PlayerRef, ctx: StrategyContext, minConfidence?: number): boolean {
-  return knowledgeOf(ctx).isHostile(p, minConfidence);
+/** hostile（坏人）：明确敌对。带刀策略刀好时可主动攻击；无刀策略硬回避。 */
+export function isKnowledgeHostile(p: PlayerRef, ctx: StrategyContext): boolean {
+  return knowledgeOf(ctx).isHostile(p);
 }
 
-/** suspect 或 hostile：任何生存型策略都应视为威胁并回避。 */
-export function isKnowledgeThreat(p: PlayerRef, ctx: StrategyContext, minConfidence?: number): boolean {
-  const mark = knowledgeOf(ctx).markOf(p, minConfidence);
-  return mark === 'suspect' || mark === 'hostile';
+/** 威胁 = 非 trusted（坏人 + 被怀疑）。未标记 trusted 的人一律按需警惕——「除好人外都值得提防」。 */
+export function isKnowledgeThreat(p: PlayerRef, ctx: StrategyContext): boolean {
+  return !knowledgeOf(ctx).isTrusted(p);
 }
 
-/** trusted：可信同伴，永远优先于回避与击杀。 */
-export function isKnowledgeTrusted(p: PlayerRef, ctx: StrategyContext, minConfidence?: number): boolean {
-  return knowledgeOf(ctx).isTrusted(p, minConfidence);
+/** trusted（好人）：可信同伴，永远优先于回避与击杀。 */
+export function isKnowledgeTrusted(p: PlayerRef, ctx: StrategyContext): boolean {
+  return knowledgeOf(ctx).isTrusted(p);
 }
 
-/** @deprecated Use isKnowledgeHostile. */
-export const isKnowledgeKillTarget = isKnowledgeHostile;
-/** @deprecated Use isKnowledgeThreat. */
-export const isKnowledgeAvoid = isKnowledgeThreat;
-/** @deprecated Use isKnowledgeTrusted. */
-export const isKnowledgeProtected = isKnowledgeTrusted;
-
 export function resolveRoom(name: string, ctx: StrategyContext): RoomTarget | null {
   const folded = name.trim().toLowerCase();
   if (!folded) return null;

package/src/strategies/goals/avoid-players-top.ts

@@ -1,5 +1,5 @@
 import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { hasReachedRoomTarget, isKnowledgeThreat, isTargetAlive, matchesAnyTarget, PatrolState, PROGRESS_INTERVAL_MS } from '../game-utils.js';
+import { hasReachedRoomTarget, isKnowledgeHostile, isTargetAlive, matchesAnyTarget, PatrolState, PROGRESS_INTERVAL_MS } from '../game-utils.js';
 import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
 import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
@@ -62,10 +62,10 @@ export class AvoidPlayersTop extends Goal {
     this.moveMode = 'flee';
   }
 
-  /** args 回避名单（活着的）∪ 知识里标记 suspect/hostile 的玩家。 */
+  /** args 回避名单（活着的）∪ 知识库标记 hostile（坏人）的玩家。被怀疑者（未标记）不自动回避——照常按房间巡逻。 */
   private threats(state: GameState, ctx: StrategyContext): PlayerInfo[] {
     const validTargets = this.targets.filter(target => isTargetAlive(state, target, ctx));
-    return state.players.filter(p => matchesAnyTarget(p, validTargets, ctx) || isKnowledgeThreat(p, ctx));
+    return state.players.filter(p => matchesAnyTarget(p, validTargets, ctx) || isKnowledgeHostile(p, ctx));
   }
 
   private setMoveGoal(room: RoomTarget, priority: number, mode: 'patrol' | 'flee', stopOnPlayer: boolean): void {

package/src/strategies/goals/corpse-patrol-top.ts

@@ -2,6 +2,7 @@ import type { GameState } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
 import {
   corpseAtScene,
+  emergencyRushDecision,
   nearestKnownCorpseNav,
   patrolStep,
   PatrolState,
@@ -24,6 +25,14 @@ export class CorpsePatrolTop extends Goal {
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    // 残局抢修紧急任务（已知存活≤6）：天堂鱼最高优先级，先于贴尸/巡逻/打招呼——
+    // 紧急任务超时则蟹直接获胜，天堂鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.emitProgress(state, ctx, null, true);
+      return [emergency];
+    }
+
     const decisions: BehaviorDecision[] = [];
 
     const greetingDecision = this.tryGreeting(state);
@@ -63,13 +72,26 @@ export class CorpsePatrolTop extends Goal {
     return { action: Action.speech(text) };
   }
 
-  private emitProgress(state: GameState, ctx: StrategyContext, corpse: CorpseTarget | null): void {
+  private emitProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    corpse: CorpseTarget | null,
+    emergencyRush = false,
+  ): void {
     const now = Date.now();
     if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
     ctx.lastProgressNotifyAt = now;
 
     const room = state.you.room ?? '未知';
 
+    if (emergencyRush) {
+      const name = ctx.emergency?.task_name ?? '紧急维修';
+      ctx.notifications.push(
+        `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`,
+      );
+      return;
+    }
+
     let msg = `[进度] 当前在${room}`;
     if (corpse) {
       const label = corpse.name ?? '未知';

package/src/strategies/goals/leaf-goal.ts

@@ -2,6 +2,8 @@ import type { BehaviorDecision } from '../types.js';
 import { Goal } from './goal.js';
 
 export const URGENT_GOAL_PRIORITY = 1;
+/** 残局抢修紧急任务：高于游走任务、低于落单猎杀/反射（URGENT），故对发言仍可被打断（< URGENT）。 */
+export const EMERGENCY_GOAL_PRIORITY = 0.6;
 export const WANDER_GOAL_PRIORITY = 0.2;
 
 export class LeafGoal extends Goal {