@myclaw163/clawclaw-cli 0.6.67 → 0.6.69

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, activeEmergencyRushTask, killYieldsToEmergencyRepair, 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.test.ts

@@ -1,7 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import type { GameState, TaskInfo } from '../sdk/types.js';
 import type { StrategyContext } from './types.js';
-import { CorpseMemory, firstAvailableTask, nearestSafeTask, PatrolState, safePatrolStep } from './game-utils.js';
+import {
+  CorpseMemory,
+  emergencyRushDecision,
+  firstAvailableTask,
+  killYieldsToEmergencyRepair,
+  nearestSafeTask,
+  PatrolState,
+  safePatrolStep,
+} from './game-utils.js';
 
 function state(overrides: Partial<GameState> = {}): GameState {
   return {
@@ -163,6 +171,50 @@ describe('safePatrolStep', () => {
   });
 });
 
+describe('emergency repair kill yielding', () => {
+  function emergencyContext(overrides: Partial<StrategyContext> = {}): StrategyContext {
+    return context({
+      emergency: {
+        task_id: 'repair',
+        task_name: 'repair',
+        room: 'control',
+        status: 'emergency',
+        x: 100,
+        y: 0,
+        remaining_secs: 45,
+      },
+      ...overrides,
+    });
+  }
+
+  it('yields near the repair task at one player above the rush threshold', () => {
+    const repairState = state({ alive_count: 7 });
+    const ctx = emergencyContext();
+
+    expect(killYieldsToEmergencyRepair(
+      repairState,
+      ctx,
+      { room: 'control', x: 130, y: 0 },
+    )).toBe(true);
+    expect(emergencyRushDecision(repairState, ctx)).toBeNull();
+  });
+
+  it('does not yield before the one-player buffer', () => {
+    expect(killYieldsToEmergencyRepair(
+      state({ alive_count: 8 }),
+      emergencyContext(),
+      { room: 'control', x: 130, y: 0 },
+    )).toBe(false);
+  });
+
+  it('still rushes the repair task at the endgame threshold', () => {
+    const decision = emergencyRushDecision(state({ alive_count: 6 }), emergencyContext());
+
+    expect(decision?.action.type).toBe('move');
+    expect(decision?.action.payload).toMatchObject({ target_x: 100, target_y: 0 });
+  });
+});
+
 describe('nearestSafeTask', () => {
   // 威胁贴在起点旁（视野内 ~52px），唯一安全任务远在反方向、离威胁 556px（> 端点
   // 排除半径 500）。修复前 pathNearAny 会因起点采样紧贴威胁把整条「背向威胁」的路线判危，

package/src/strategies/game-utils.ts

@@ -65,23 +65,33 @@ function normalizeRoom(room?: string): string {
 }
 
 /**
- * 任务点是否落在「尸体回避区」，供做任务伪装的角色跳过命案房间的任务。命中其一即算：
- * 1. **同房间**：任务与任一已知尸体在同一个（非走廊）房间——房间级回避，自动随房间尺寸缩放，
- *    这样坏人杀完不会回到陈尸的那个房间里做任务，哪怕任务点离尸体有大半个房间远。
- * 2. **距离兜底**：欧氏距离 ≤ CORPSE_TASK_AVOID_RANGE——覆盖尸体贴门跨到隔壁房间、或尸体/任务
- *    缺房间标签（走廊命案、坐标未回填）的情形。
+ * 两点是否「紧挨」——命中其一即算：
+ * 1. **同房间**：两者在同一个（非走廊）房间——房间级判据，自动随房间尺寸缩放。
+ * 2. **距离兜底**：欧氏距离 ≤ range——覆盖贴门跨到隔壁房间、或缺房间标签（走廊、坐标未回填）的情形。
+ * 供「避开尸体做任务」「残局维修点附近不杀人」等「某点是否紧挨某参照点」的判断统一复用。
+ */
+export function sameRoomOrWithinRange(
+  a: { x?: number; y?: number; room?: string },
+  b: { x?: number; y?: number; room?: string },
+  range: number,
+): boolean {
+  const ar = normalizeRoom(a.room);
+  if (ar && ar === normalizeRoom(b.room)) return true;
+  return a.x != null && a.y != null && b.x != null && b.y != null
+    && dist(a.x, a.y, b.x, b.y) <= range;
+}
+
+/**
+ * 任务点是否落在「尸体回避区」，供做任务伪装的角色跳过命案房间的任务。命中其一即算（同房间 / 欧氏
+ * 距离 ≤ CORPSE_TASK_AVOID_RANGE，见 sameRoomOrWithinRange）：这样坏人杀完不会回到陈尸的那个房间里
+ * 做任务，哪怕任务点离尸体有大半个房间远；距离兜底覆盖尸体贴门跨房、或尸体/任务缺房间标签的情形。
  */
 export function taskNearKnownCorpse(
   task: { x?: number; y?: number; room?: string },
   avoidCorpses?: CorpseInfo[] | null,
 ): boolean {
   if (!avoidCorpses || avoidCorpses.length === 0) return false;
-  const taskRoom = normalizeRoom(task.room);
-  return avoidCorpses.some(c => {
-    if (taskRoom && normalizeRoom(c.room) === taskRoom) return true;
-    return c.x != null && c.y != null && task.x != null && task.y != null
-      && dist(task.x, task.y, c.x, c.y) <= CORPSE_TASK_AVOID_RANGE;
-  });
+  return avoidCorpses.some(c => sameRoomOrWithinRange(task, c, CORPSE_TASK_AVOID_RANGE));
 }
 
 export function firstAvailableTask(
@@ -327,6 +337,68 @@ 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;
+
+/** 当前是否有「进行中、带坐标」的紧急维修任务（不看存活人数门槛）。 */
+function pendingEmergencyRepair(ctx: StrategyContext): EmergencyInfo | null {
+  const e = ctx.emergency;
+  if (!e || e.status === 'completed' || e.x == null || e.y == null) return null;
+  return e;
+}
+
+/**
+ * 残局抢修是否「该生效」：已知存活人数（state.alive_count，含本玩家尚未目睹其死亡者）≤
+ * EMERGENCY_RUSH_ALIVE_THRESHOLD 且当前有进行中、带坐标的紧急维修任务时返回该任务，否则 null。
+ * 这是 emergencyRushDecision「奔去维修」的门槛；「维修点附近不杀人」（killYieldsToEmergencyRepair）
+ * 共用同一个紧急任务判定，但存活门槛比这里高一人，原因见该函数注释。
+ */
+export function activeEmergencyRushTask(state: GameState, ctx: StrategyContext): EmergencyInfo | null {
+  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD) return null;
+  return pendingEmergencyRepair(ctx);
+}
+
+/**
+ * 残局抢修紧急维修任务的「靠近 → 到点提交」单步决策：activeEmergencyRushTask 生效时返回该决策，否则 null
+ * （行为不触发，调用方按自身原优先级继续）。
+ *
+ * 背景：紧急任务超时则蟹阵营直接获胜（后端倒计时），而中立的章鱼/天堂鱼要靠活到最后取胜，因此残局应抢着
+ * 把维修做掉、掐断蟹的破坏取胜线。服务端已放开中立/蟹阵营提交紧急任务。紧急任务被任意玩家完成 / 开会 /
+ * 超时后，服务端会清空 state.emergency（→ ctx.emergency 为 null），activeEmergencyRushTask 随之自动返回 null。
+ */
+export function emergencyRushDecision(state: GameState, ctx: StrategyContext): BehaviorDecision | null {
+  const task = activeEmergencyRushTask(state, ctx);
+  if (!task) return null;
+  // 维修点恰是上一帧被挡的移动目标 → 本帧让出（与旧 firstAvailableTask 的 blocked 兜底一致），别对着堵点空撞。
+  if (ctx.blockedMoveTarget && dist(task.x!, task.y!, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 10) {
+    return null;
+  }
+  return taskMoveDecision(state, ctx, task);
+}
+
+/**
+ * 残局抢修期，落单目标是否「紧挨紧急维修点」而该让位于维修、不该追杀。
+ *
+ * 存活门槛比抢修本身（activeEmergencyRushTask，≤EMERGENCY_RUSH_ALIVE_THRESHOLD）**高一人**，因为出一刀
+ * 会让存活−1：alive_count == THRESHOLD+1 时此刻把这个落单目标杀掉，下一帧就跌进抢修档、又奔回这同一个维修点，
+ * 正好踩在自己刚造的尸体 + 涌来的虾群里，自证清白极难。所以 alive_count ≤ THRESHOLD+1 就让位。注意：把抢修
+ * 门槛整体抬到 7 治不了这个——边界只会平移到 8→7 复现同样的「杀完立刻奔回去维修」；真正的修法是让位档恒比
+ * 抢修档高 1。
+ *
+ * 命中还需有进行中带坐标的紧急维修、且目标与维修点同房间或在 CORPSE_TASK_AVOID_RANGE 内（复用做任务伪装时
+ * 「避开尸体」的同房间+距离判据）。远离维修点的落单目标不受影响，照常猎杀（抢修仍低于猎杀的设定不变）。
+ */
+export function killYieldsToEmergencyRepair(
+  state: GameState,
+  ctx: StrategyContext,
+  target: { x?: number; y?: number; room?: string },
+): boolean {
+  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD + 1) return false;
+  const e = pendingEmergencyRepair(ctx);
+  if (!e) return false;
+  return sameRoomOrWithinRange(target, { x: e.x, y: e.y, room: e.room }, CORPSE_TASK_AVOID_RANGE);
+}
+
 export function nearestReportableCorpse(state: GameState): GameState['corpses'][number] | null {
   const nearby = state.corpses
     .map(corpse => {
@@ -666,29 +738,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/crab-octopus-reflexes.ts

@@ -1,4 +1,4 @@
-import type { GameState } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
 import {
   canUseKill,
@@ -58,8 +58,15 @@ export function corpseReportWithNonTeammate(state: GameState, ctx: StrategyConte
   }];
 }
 
-/** 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
-export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+/**
+ * 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。
+ * 可选 skipTarget：返回 true 的目标本帧不出刀（章鱼残局抢修期用它放过紧挨紧急维修点的目标）。
+ */
+export function immediateLoneKillDecision(
+  state: GameState,
+  ctx: StrategyContext,
+  skipTarget?: (target: PlayerInfo) => boolean,
+): BehaviorDecision[] | null {
   if (!canUseKill(state)) return null;
 
   const targets = nonTeammatesVisible(state, ctx);
@@ -68,6 +75,7 @@ export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext
   const target = targets[0];
   const distance = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
   if (distance > killCommitRange(state.you.role)) return null;
+  if (skipTarget?.(target)) return null;
 
   ctx.notifications.push(`发现落单目标${target.name}就在身边，立刻出刀！`);
   return [{ action: Action.kill(target.name) }];

package/src/strategies/goals/keep-away-goal.ts

@@ -18,7 +18,7 @@ const PANIC_REPLAN_TARGET_SHIFT = 220;
  * keep-away 逃跑推演基线参数。各档（FLEE 不覆盖；陌生人覆盖 steps:4）在此基础上合并 options.planOpts。
  * killRange 取 SHRIMP_KILL_RANGE(160) 而非 planner 默认 80：本层威胁只有坐标、没有角色（resolver
  * 返回可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor，故统一用带刀虾兜底，
- * 宁可对蟹/章鱼多拉开也不对带刀好人少逃。武士虾自卫判定（warrior-shrimp-top）复用它，保证「避不开」口径一致。
+ * 宁可对蟹/章鱼多拉开也不对带刀好人少逃；带刀好人遇到未确认对象也只复用这一层做回避，不再自卫出刀。
  */
 export const KEEP_AWAY_BASE_PLAN_OPTS: EscapeOptions = {
   killRange: SHRIMP_KILL_RANGE,
@@ -39,8 +39,9 @@ export interface KeepAwayGoalOptions {
   finishWhenClear?: boolean;
   /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
   idleNotices?: boolean;
-  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。 */
-  noun?: string;
+  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。传字符串则所有威胁共用一个称呼；传函数则
+   *  逐个威胁按其真实身份标注（如坏人/被怀疑者分别措辞），避免把混在一起躲的被怀疑者也一律叫成坏人。 */
+  noun?: string | ((p: PlayerInfo, ctx: StrategyContext) => string);
   /** 覆盖 planEscape 参数（与 PLAN_OPTS 合并）。 */
   planOpts?: EscapeOptions;
 }
@@ -201,11 +202,14 @@ export class KeepAwayGoal extends Goal {
     this.committed = target;
     this.lastCommitAt = Date.now();
     this.lastCommitWasPanic = panic;
-    const names = threats.map(p => p.name).join('、');
+    const noun = this.options.noun;
+    const body = typeof noun === 'function'
+      ? threats.map(p => `${noun(p, ctx)}${p.name}`).join('、')
+      : `${noun ?? ''}${threats.map(p => p.name).join('、')}`;
     this.notice(
       ctx,
       `${verb}:${targetKey(target)}`,
-      `发现${this.options.noun ?? ''}${names}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
+      `发现${body}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
     );
   }
 

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 {

package/src/strategies/goals/lone-kill-task-top.ts

@@ -1,7 +1,9 @@
-import type { GameState } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import {
+  emergencyRushDecision,
   firstAvailableTask,
   killCooldownSecs,
+  killYieldsToEmergencyRepair,
   nonTeammatesVisible,
   PatrolState,
   PROGRESS_INTERVAL_MS,
@@ -11,7 +13,7 @@ import { Goal } from './goal.js';
 import { LoneKillCore } from './lone-kill-core.js';
 import { LoneKillGoal } from './lone-kill-goal.js';
 import { WanderTaskGoal } from './wander-task-goal.js';
-import { emitLeaf, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
+import { emitLeaf, EMERGENCY_GOAL_PRIORITY, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
 import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
 
 /**
@@ -21,8 +23,12 @@ import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-o
  * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(出刀范围内)且刀好 →
  *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
  * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
- *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。
- * 2. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务；章鱼不能提交紧急维修任务，
+ *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。**残局抢修期例外**：落单目标紧挨紧急维修点
+ *    （同房间或避尸距离内，killYieldsToEmergencyRepair）时跳过反射刀/落单猎杀，让位给第 2 步去修——虾群都
+ *    涌向维修点，在那儿动手必被围观、还会撇下维修把破坏倒计时取胜线让给蟹；远离维修点的目标照常猎杀。
+ * 2. 残局抢修紧急任务（EMERGENCY，仅已知存活≤6）：低于落单猎杀（击杀优先），高于伪装任务——
+ *    紧急任务超时则蟹阵营直接获胜，中立章鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
+ * 3. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务（排除当前紧急任务，那个走第 2 步），
  *    跳过紧挨已知尸体（含看见过、已离开视野的）的任务，没任务就按房间巡逻，绝不停在原地。
  */
 export class LoneKillTaskTop extends Goal {
@@ -30,7 +36,14 @@ export class LoneKillTaskTop extends Goal {
   private readonly patrol = new PatrolState();
   private readonly loneKillGoal = new LoneKillGoal(this.killCore);
   private readonly wanderGoal = new WanderTaskGoal(
-    (state, ctx) => firstAvailableTask(ctx.taskData, () => true, undefined, ctx.blockedMoveTarget, ctx.knownCorpses),
+    // 排除当前紧急任务：它由 tick 里的残局抢修分支按 EMERGENCY 优先级处理，不在此当普通伪装任务做。
+    (state, ctx) => firstAvailableTask(
+      ctx.taskData,
+      t => t.task_name !== ctx.emergency?.task_name,
+      undefined,
+      ctx.blockedMoveTarget,
+      ctx.knownCorpses,
+    ),
     () => this.killCore.patrolStopOnPlayer(),
     this.patrol,
   );
@@ -40,28 +53,62 @@ export class LoneKillTaskTop extends Goal {
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    this.emitProgress(state, ctx);
+    // 残局抢修期：紧急维修点附近不杀人。虾群都涌向维修点，在那儿动手必被围观、还会撇下维修把破坏
+    // 倒计时取胜线让给蟹。落单目标紧挨维修点（同房间或避尸距离内）时跳过反射刀与落单猎杀，让位给下面
+    // 的抢修分支；远离维修点的目标照常猎杀（抢修仍低于猎杀的设定不变）。
+    const yieldsToRepair = (t: PlayerInfo) => killYieldsToEmergencyRepair(state, ctx, t);
 
-    const immediateKill = immediateLoneKillDecision(state, ctx);
-    if (immediateKill) return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+    const immediateKill = immediateLoneKillDecision(state, ctx, yieldsToRepair);
+    if (immediateKill) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+    }
 
     const corpseReport = corpseReportWithNonTeammate(state, ctx);
-    if (corpseReport) return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+    if (corpseReport) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+    }
 
     const target = this.killCore.assess(state, ctx);
-    if (target.kind === 'hunt') {
+    const sparedNearRepair = target.kind === 'hunt' && yieldsToRepair(target.target);
+    if (target.kind === 'hunt' && !sparedNearRepair) {
+      this.emitProgress(state, ctx, false);
       this.loneKillGoal.setTarget(target.target);
       return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
     }
+
+    // 残局抢修紧急任务（已知存活≤6）：高于伪装任务，低于上面的落单猎杀/反射。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.emitProgress(state, ctx, true, sparedNearRepair ? target.target.name : null);
+      return emitLeaf(this, [emergency], EMERGENCY_GOAL_PRIORITY);
+    }
+
+    this.emitProgress(state, ctx, false);
     return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
   }
 
-  private emitProgress(state: GameState, ctx: StrategyContext): void {
+  private emitProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    emergencyRush: boolean,
+    sparedNearRepair: string | null = null,
+  ): 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 ?? '紧急维修';
+      let msg = `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
+      if (sparedNearRepair) {
+        msg += ` 落单目标${sparedNearRepair}就在维修点附近，先修不杀，免得在虾群涌入的维修点暴露自己。`;
+      }
+      ctx.notifications.push(msg);
+      return;
+    }
     const cd = killCooldownSecs(state);
     const killsRemaining = state.you.kills_remaining;
     const nonTeammates = nonTeammatesVisible(state, ctx);

package/src/strategies/goals/normal-shrimp-top.ts

@@ -4,7 +4,7 @@ import {
   dist,
   firstAvailableTask,
   hasKnownCorpse,
-  isKnowledgeThreat,
+  isKnowledgeHostile,
   isKnowledgeTrusted,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -39,8 +39,8 @@ type Tier = 'flee-bad' | 'keep-distance' | 'task';
  *
  * - P0 发现尸体：一律报警（reportCorpseDecision），必要时提示 Agent 更新尸体旁玩家记忆。
  * - P1 规避危险：
- *   · A 视野里有威胁（知识库 suspect/hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
- *   · B 无可信同伴且陌生人贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
+ *   · A 视野里有坏人（知识库 hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
+ *   · B 无可信同伴且被怀疑者（未标记 = 默认被怀疑）贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
  *     目击者豁免：当前见到 ≥2 个陌生人时不触发后撤（蟹不敢当众动手，独处才危险）；
  *     进行中的后撤也会重新判定，只有仍是单陌生人危险时才拉满到 300px。豁免期间陌生人也不算任务威胁点。
  * - P2 紧急任务：无危险时优先处理。
@@ -54,7 +54,7 @@ export class NormalShrimpTop extends Goal {
     // 豁免期间陌生人不算威胁点（与 B 档不触发保持视野半径对齐），认定坏人始终算。
     (s, c) => nonTeammatesVisible(s, c)
       .filter(p => !this.isTrusted(p, c))
-      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
+      .filter(p => this.isHostile(p, c) || !this.witnessExempt)
       .map(p => ({ x: p.x, y: p.y })),
   );
   private readonly strangerSeenAt = new Map<string, number>();
@@ -91,10 +91,10 @@ export class NormalShrimpTop extends Goal {
     }
 
     // ── P1-A 视野里有认定坏人 → 寻路躲避 ──
-    const threats = visible.filter(p => this.isThreat(p, ctx));
+    const threats = visible.filter(p => this.isHostile(p, ctx));
     if (threats.length > 0) {
       this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-      this.setKeepAway(FLEE_BAD_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
+      this.setKeepAway(FLEE_BAD_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => this.isHostile(p, c)), {
         threatRadius: Infinity,
         noun: '认定坏人',
       });
@@ -153,9 +153,9 @@ export class NormalShrimpTop extends Goal {
     this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
   }
 
-  /** 威胁：知识库 suspect/hostile，且未被标记为 trusted。 */
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  /** 坏人：知识库 hostile（明确敌对）。被怀疑者（未标记）不在此列，走 B 档保持距离。 */
+  private isHostile(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeHostile(p, ctx);
   }
 
   /** 可信同伴：知识库 trusted。 */
@@ -185,7 +185,7 @@ export class NormalShrimpTop extends Goal {
       if (!key || this.corpseWitnessNotified.has(key)) continue;
       this.corpseWitnessNotified.add(key);
 
-      if (this.isThreat(player, ctx)) bad.push(player.name);
+      if (this.isHostile(player, ctx)) bad.push(player.name);
       else if (this.isKnownParadiseFish(player, ctx)) paradise.push(player.name);
       else if (this.isTrusted(player, ctx)) trusted.push(player.name);
       else unknown.push(player.name);
@@ -217,7 +217,7 @@ export class NormalShrimpTop extends Goal {
 
     let msg = `[进度] 当前在${room}`;
     if (tier === 'flee-bad') {
-      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
+      const names = visible.filter(p => this.isHostile(p, ctx)).map(p => p.name).join('、');
       msg += `，发现认定坏人${names}，正在远离。`;
     } else if (tier === 'keep-distance') {
       msg += `，陌生人靠得太近，先拉开距离再做任务。`;