@myclaw163/clawclaw-cli 0.6.67 → 0.6.69

package/src/strategies/goals/paradise-fish-top.ts

@@ -1,8 +1,9 @@
 import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
 import {
   corpseAtScene,
+  emergencyRushDecision,
   hasKnownCorpse,
-  isKnowledgeThreat,
+  isKnowledgeHostile,
   isKnowledgeTrusted,
   nonTeammatesVisible,
   PatrolState,
@@ -20,7 +21,7 @@ const SUB_PRIORITY = 0.5;
 const AVOID_ROUTE_MEMORY_MS = 10_000;
 const WITNESS_EXEMPT_COUNT = 2;
 
-type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
+type Tier = 'emergency' | 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
 
 export class ParadiseFishTop extends Goal {
   private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
@@ -39,16 +40,16 @@ export class ParadiseFishTop extends Goal {
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
     const visible = nonTeammatesVisible(state, ctx);
-    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
+    const threatTargets = visible.filter(p => this.isHostile(p, ctx));
     const trustedTargets = visible.filter(p => this.isTrusted(p, ctx));
     const strangerAvoidTargets = this.strangerAvoidTargets(visible, ctx);
     this.rememberAvoidPoints(visible, ctx, strangerAvoidTargets.length > 0);
-    const decisions: BehaviorDecision[] = [];
-    const greeting = this.greeting.tryGreeting(state);
-    if (greeting) decisions.push(greeting);
 
     if (threatTargets.length > 0) {
-      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
+      const decisions: BehaviorDecision[] = [];
+      const greeting = this.greeting.tryGreeting(state);
+      if (greeting) decisions.push(greeting);
+      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isHostile(p, c)), {
         threatRadius: Infinity,
         noun: '认定带刀坏人',
       });
@@ -56,6 +57,18 @@ export class ParadiseFishTop extends Goal {
       return decisions;
     }
 
+    // 残局抢修紧急任务（已知存活≤6）：仅次于躲避带刀坏人，先于保持距离/贴尸/抱团。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.clearSub();
+      this.emitProgress(state, ctx, visible, 'emergency');
+      return [emergency];
+    }
+
+    const decisions: BehaviorDecision[] = [];
+    const greeting = this.greeting.tryGreeting(state);
+    if (greeting) decisions.push(greeting);
+
     if (strangerAvoidTargets.length > 0) {
       this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
         threatRadius: Infinity,
@@ -91,8 +104,9 @@ export class ParadiseFishTop extends Goal {
     return [...this.wander(state, ctx), ...decisions];
   }
 
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  /** 坏人：知识库 hostile（明确敌对带刀者）。被怀疑者（未标记）走下面的保持距离档。 */
+  private isHostile(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeHostile(p, ctx);
   }
 
   private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
@@ -101,14 +115,14 @@ export class ParadiseFishTop extends Goal {
 
   private strangerAvoidTargets(visible: PlayerInfo[], ctx: StrategyContext): PlayerInfo[] {
     if (visible.some(p => this.isTrusted(p, ctx))) return [];
-    const nonBad = visible.filter(p => !this.isThreat(p, ctx));
+    const nonBad = visible.filter(p => !this.isHostile(p, ctx));
     if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
-    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
+    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isHostile(p, ctx));
   }
 
   private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
     const visible = nonTeammatesVisible(state, ctx);
-    const threats = visible.filter(p => this.isThreat(p, ctx));
+    const threats = visible.filter(p => this.isHostile(p, ctx));
     return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
   }
 
@@ -132,7 +146,7 @@ export class ParadiseFishTop extends Goal {
         this.recentAvoidPoints.delete(key);
         continue;
       }
-      const threat = this.isThreat(p, ctx);
+      const threat = this.isHostile(p, ctx);
       if (!threat && !avoidNonThreat) {
         this.recentAvoidPoints.delete(key);
         continue;
@@ -183,7 +197,10 @@ export class ParadiseFishTop extends Goal {
 
     const room = state.you.room ?? '未知';
     let msg = `[进度] 当前在${room}`;
-    if (tier === 'corpse') {
+    if (tier === 'emergency') {
+      const name = ctx.emergency?.task_name ?? '紧急维修';
+      msg += `，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
+    } else if (tier === 'corpse') {
       // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
       if (!corpseAtScene(state)) {
         msg += '，记得有尸体，正前往尸体处（不报警）。';
@@ -193,7 +210,7 @@ export class ParadiseFishTop extends Goal {
           : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
       }
     } else 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 += `，附近有${visible.length}人但无可信同伴，保持距离中。`;

package/src/strategies/goals/warrior-shrimp-top.test.ts

@@ -29,7 +29,7 @@ function state(): GameState {
   };
 }
 
-function knowledge(mark: 'suspect' | 'hostile' | 'trusted') {
+function knowledge(mark: 'hostile' | 'trusted') {
   const ts = Date.now();
   const file: KnowledgeFile = {
     version: 1,
@@ -68,10 +68,11 @@ function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
 }
 
 describe('WarriorShrimpTop knowledge tiers', () => {
-  it('avoids a suspect even when the weapon is ready', () => {
+  it('keeps distance from an unmarked (suspected-by-default) player even when the weapon is ready', () => {
     const top = new WarriorShrimpTop();
 
-    top.tick(state(), context({ knowledge: knowledge('suspect') }));
+    // 不打任何标记：未标记 = 默认被怀疑 → 只保持距离，刀好也不主动出刀。
+    top.tick(state(), context());
 
     expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
   });

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

@@ -1,7 +1,5 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
-import { planEscape } from '../pathfind/escape-planner.js';
-import { loadWalkableGrid, type WalkableGrid } from '../pathfind/walkable-grid.js';
 import {
   canUseKill,
   corpseAtScene,
@@ -9,11 +7,9 @@ import {
   firstAvailableTask,
   hasKnownCorpse,
   isKnowledgeHostile,
-  isKnowledgeThreat,
   isKnowledgeTrusted,
   killCooldownSecs,
   killCommitRange,
-  killRangeFor,
   matchesAnyTarget,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -24,7 +20,7 @@ import {
 } from '../game-utils.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
-import { KEEP_AWAY_BASE_PLAN_OPTS, KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
 import { KillVisibleTargetGoal } from './kill-target-goal.js';
 import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
 
@@ -36,105 +32,57 @@ const WITNESS_EXEMPT_COUNT = 2;
 const TASK_RETURN_INERTIA_MS = 2_000;
 const FLEE_KEY = 'warrior-flee';
 const STRANGER_KEY = 'warrior-stranger-distance';
-// 自卫总开关：false=遇到 suspect 一律只回避（绝不变向试探、绝不自卫出刀），等同纯回避档；true=启用下方绝境自卫流程。
-const SELF_DEFENSE_ENABLED: boolean = false;
-// 自卫出刀只能由「主动变向试探 + 验证对方跟随」达成，绝不靠被动转角/方位判定——那些会被走廊弯曲、寻路曲线、
-// 贴身掠过污染（对方只是顺着走廊转、并非在追我，却累积出大转角）。流程：
-// ① 同一 suspect 连续 JUKE_STREAK 帧「朝我贴身追击」（aimedPursuit：相对上帧位移 ≥ MOVE_EPS 且方向与「指向我」
-//    夹角余弦 ≥ TOWARD_COS；cone 半角≈31.8°）且 planEscape 判定甩不掉 → 被咬住又逃不掉，开始试探；
-// ② 主动横向变一次向（jukeTarget），变向幅度足够大，使「不跟随者」必然掉出 cone；
-// ③ 变向后 JUKE_WINDOW 帧内，若它重新指向我的【新】位置（cone re-entry）= 跟随一次。只认变向【之后】的重新瞄准，
-//    走廊弯曲转过的角度一概不算——直奔固定任务点 / 顺着走廊走的虾不会跟我的横向变向，永远掉出 cone、攒不到跟随。
-//    变向后第 1 帧对方因反应延迟可能短暂掉出 cone，故用 WINDOW 容忍这一帧；窗口内始终不重新瞄准 = 没跟 → 重置。
-// ④ 攒够 JUKE_FOLLOWS 次跟随、且已进 killRangeFor 射程、视线无墙，才出刀（趁 160 射程在合拢阶段先手，蟹只有 80）。
-const SELF_DEFENSE_JUKE_STREAK = 2;
-const SELF_DEFENSE_JUKE_WINDOW = 3;
-const SELF_DEFENSE_JUKE_FOLLOWS = 2;
-const SELF_DEFENSE_MOVE_EPS = 40;
-const SELF_DEFENSE_TOWARD_COS = 0.85;
-// 主动变向试探：横向位移目标距离；方向以横向为主、略带「背离对方」分量以免试探时丢距离；落点至少这么远才算有效变向。
-const SELF_DEFENSE_JUKE_DIST = 170;
-const SELF_DEFENSE_JUKE_LATERAL = 0.85;
-const SELF_DEFENSE_JUKE_AWAY = 0.45;
-const SELF_DEFENSE_JUKE_MIN_MOVE = 60;
+// 尸体现场灭口开关：false=站在尸体旁也绝不因「身边有未报警的身份不明者」先手灭口，只报警（hostile/启动目标仍按 P1 追杀）；
+// true=刀可用时先击杀尸体旁最近的非 trusted 非队友。关掉是为根治「把尸体边未报警的无辜虾当凶手灭口」的误杀。
+const CORPSE_SCENE_KILL_ENABLED: boolean = false;
 
 type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
 
-/** 单位向量；长度过小（重合）返回 null。 */
-function unitVec(x: number, y: number): { x: number; y: number } | null {
-  const m = Math.hypot(x, y);
-  if (m < 1e-6) return null;
-  return { x: x / m, y: y / m };
-}
-
-/** 两点世界坐标连线是否整段可走（无墙）。沿线段每半格采样一次，任一采样点落在墙上即判被挡。 */
-function segmentWalkable(grid: WalkableGrid, ax: number, ay: number, bx: number, by: number): boolean {
-  const span = Math.hypot(bx - ax, by - ay);
-  const steps = Math.max(1, Math.ceil(span / (grid.tileSize * 0.5)));
-  for (let i = 0; i <= steps; i++) {
-    const t = i / steps;
-    const x = ax + (bx - ax) * t;
-    const y = ay + (by - ay) * t;
-    if (!grid.isWalkable(Math.floor(x / grid.tileSize), Math.floor(y / grid.tileSize))) return false;
-  }
-  return true;
-}
-
 /**
  * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
  *
- * - P0 发现尸体：旁边有非保护对象且刀可用 → 先出刀；否则报警（靠近至可报距离）。
- * - P1 处理危险：明确猎杀目标（启动参数 / hostile）刀好就追杀；
- *   suspect 只表示可疑，默认回避，绝不仅凭怀疑或被动观察出刀——只有主动变向试探、验证它确实跟着我变向追击且退无可退才自卫先手；
- *   无可信同伴且单个无标记陌生人贴近 → 按普通虾 B 档先拉开距离。
+ * - P0 发现尸体：旁边是 hostile/启动猎杀目标且刀可用 → 现场先手击杀；未报警的身份不明者默认不灭口
+ *   （CORPSE_SCENE_KILL_ENABLED，根治误杀）；否则报警（靠近至可报距离）。
+ * - P1 处理危险：**只对【已确认 hostile】（启动参数 / 知识库 hostile）出刀**——刀好就追杀，刀冷就硬躲所有非好人。
+ *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑）：**只回避、绝不出刀**——无可信同伴且单个被怀疑者
+ *   贴近 → 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
+ *   （历史上的「贴身追击判定 + 诱饵试探 + 绝境自卫反杀」整套已删除：几何上无法把「贴身跟我观察的好人」和「贴身追我的
+ *   凶手」区分开，自卫出刀迟早误杀同阵营好人、触发 warrior_shrimp_self_destruct 直接崩盘，代价远大于收益。）
  * - P2 紧急任务：无危险时优先处理。
  * - P3 兜底：做任务 / 巡逻
  *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
  *
- * 谁算「认定坏人」「可信同伴」来自 ctx.knowledge（见 warrior-memory.knowledge.md），
+ * 谁算「坏人」「可信同伴」来自 ctx.knowledge（见 warrior-memory.knowledge.md），其余默认被怀疑；
  * 队友由游戏事实判定（nonTeammatesVisible），知识库只提供推断。
  */
 export class WarriorShrimpTop extends Goal {
   private readonly taskGoal = new SafeTaskOrPatrolGoal(
-    // 威胁点 = 当前会触发追杀/后撤的对象，或未被目击者豁免的无标记陌生人；保护对象不算。
+    // 威胁点 = 坏人（始终算），或未被目击者豁免的被怀疑者；可信同伴不算。
     (s, c) => nonTeammatesVisible(s, c)
       .filter(p => !this.isTrusted(p, c))
-      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
+      .filter(p => this.isHuntTarget(p, c) || !this.witnessExempt)
       .map(p => ({ x: p.x, y: p.y })),
   );
   private readonly strangerSeenAt = new Map<string, number>();
   private witnessExempt = false;
-  /** 自卫：当前被判定在追我的 suspect key、它上一帧坐标、连续「朝我贴身追击」帧数（决定何时开始试探）、
-   *  变向后等待对方跟随的剩余帧数（0=未在等）、发起变向那刻我的坐标（验证跟随用）、已验证的跟随次数、
-   *  本轮是否已推过自卫简报。 */
-  private selfDefenseTargetKey: string | null = null;
-  private selfDefenseSuspectPrev: { x: number; y: number } | null = null;
-  private selfDefenseStreak = 0;
-  private selfDefenseJukeWatch = 0;
-  private selfDefenseJukeFromPos: { x: number; y: number } | null = null;
-  private selfDefenseJukeFollows = 0;
-  private selfDefenseAlerted = false;
 
   constructor(private readonly huntTargets: string[] = []) {
     super();
   }
 
-  /** warrior-memory 开会后不重建 Top（resetOnMeetingResume:false）；自卫追击计数按「连续游荡」语义，
-   *  开会是天然中断点，恢复后从零重算，避免拿会议前的追击 streak 一恢复就秒杀。 */
-  onMeetingResume(): void {
-    this.resetSelfDefense();
-  }
-
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
     const visible = nonTeammatesVisible(state, ctx);
     this.updateWitnessMemory(visible, ctx);
     const killReady = canUseKill(state);
 
     // ── P0 发现尸体 ──
-    // 灭口贴脸目击者只在「此刻就在命案现场」（当帧视野有尸体）时考虑——记忆里某处有尸体不算现场，
-    // 否则会变成随便撞见一个人就灭口。
+    // 只在「此刻就在命案现场」（当帧视野有尸体）时考虑现场出刀——记忆里某处有尸体不算现场。
     if (corpseAtScene(state) && killReady) {
-      const victim = this.nearestKillable(state, ctx, visible);
+      // 尸体旁的【已确认敌对 / 启动猎杀目标】始终先手击杀，不受灭口开关影响、且排在报尸之前——凶手就在身边时照杀。
+      // 仅「未报警的身份不明者」（非 trusted、非 hostile）才受 CORPSE_SCENE_KILL_ENABLED 控制：默认关，
+      // 根治「把尸体边未报警的无辜虾当凶手灭口」的误杀。
+      const victim = this.nearestKillable(state, ctx, visible, true)
+        ?? (CORPSE_SCENE_KILL_ENABLED ? this.nearestKillable(state, ctx, visible, false) : null);
       if (victim) {
         this.clearSub();
         return [{ action: Action.kill(victim.name) }];
@@ -149,36 +97,32 @@ export class WarriorShrimpTop extends Goal {
       }
     }
 
-    // ── P1-A hostile 刀好就追；suspect 只回避（避不开且能杀时自卫出刀） ──
-    const threats = visible.filter(p => this.isThreat(p, ctx));
+    // ── P1 处理危险：非 trusted 即潜在威胁（坏人 + 被怀疑） ──
+    const threats = visible.filter(p => !this.isTrusted(p, ctx));
     if (threats.length > 0) {
       const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
+      // P1-A 坏人/启动目标且刀好 → 主动追杀。
       if (killReady && huntTargets.length > 0) {
-        this.resetSelfDefense();
         this.setHunt(this.nearestByDistance(state, huntTargets).name);
         return [];
       }
-      // 只剩 suspect、本应只回避；但若连续多帧确认同一个在朝我贴身追击且避让算法判定避不开，就主动横向变向试探，
-      // 只有它每次都跟着我的变向重新咬住（攒够跟随次数）、且已进 160 射程、视线无墙，才自卫先下手（趁 reach 优势在合拢阶段先手）+ Agent 自卫简报。
-      const selfDefense = this.selfDefenseKill(state, ctx, threats, killReady);
-      if (selfDefense) return selfDefense;
 
-      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-      this.setFlee();
-      this.emitProgress(state, ctx, visible, 'flee-bad');
-      return [];
-    }
-    this.resetSelfDefense();
+      // P1-B 有坏人/启动目标但刀冷（杀不了）→ 硬躲所有非好人。
+      if (huntTargets.length > 0) {
+        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+        this.setFlee();
+        this.emitProgress(state, ctx, visible, 'flee-bad');
+        return [];
+      }
 
-    // ── P1-B 无可信同伴且无标记陌生人贴近 → 按普通虾 B 档拉开距离 ──
-    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
-    if (!trustedVisible) {
+      // P1-C 只剩被怀疑者（无已确认坏人）：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离（只回避，绝不出刀）；
+      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务。
+      const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
       const worker = this.subGoal;
-      const strangerClose = visible.some(p =>
-        this.isUnmarkedStranger(p, ctx)
-        && (p.distance ?? dist(p.x, p.y, state.you.x, state.you.y)) <= STRANGER_TRIGGER_RADIUS);
+      const suspectedClose = threats.some(p =>
+        (p.distance ?? dist(p.x, p.y, state.you.x, state.you.y)) <= STRANGER_TRIGGER_RADIUS);
       const stillBackingOff = worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY && !worker.isFinish(state, ctx);
-      if (!this.witnessExempt && (strangerClose || stillBackingOff)) {
+      if (!trustedVisible && !this.witnessExempt && (suspectedClose || stillBackingOff)) {
         this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
         this.setStrangerKeepAway();
         this.emitProgress(state, ctx, visible, 'keep-distance');
@@ -199,11 +143,11 @@ export class WarriorShrimpTop extends Goal {
     return this.taskGoal.tick(state, ctx);
   }
 
-  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上陌生人时不对无标记者后撤。 */
+  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上被怀疑者时不对其后撤（多人互为目击者，蟹不敢当众动手）。 */
   private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
     const now = Date.now();
     for (const p of visible) {
-      if (!this.isUnmarkedStranger(p, ctx)) continue;
+      if (!this.isSuspected(p, ctx)) continue;
       const key = p.name || String(p.seat ?? '');
       if (key) this.strangerSeenAt.set(key, now);
     }
@@ -213,8 +157,9 @@ export class WarriorShrimpTop extends Goal {
     this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
   }
 
-  private isUnmarkedStranger(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx) && !this.isThreat(p, ctx);
+  /** 被怀疑者：非 trusted（好人）且非坏人/启动目标——未标记的默认就落这档，对应 B 档保持距离（只回避、绝不出刀）。 */
+  private isSuspected(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx) && !this.isHuntTarget(p, ctx);
   }
 
   /** 知识里 trusted 的玩家：可信同伴，永不击杀。 */
@@ -222,22 +167,28 @@ export class WarriorShrimpTop extends Goal {
     return isKnowledgeTrusted(p, ctx);
   }
 
-  /** 明确猎杀目标：启动参数或 hostile；suspect 不在这里。 */
+  /** 坏人 / 明确猎杀目标：启动参数或知识库 hostile；被怀疑者不在这里。 */
   private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
     return !this.isTrusted(p, ctx)
       && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
   }
 
-  /** 威胁：明确猎杀目标，或知识库 suspect 标记；trusted 永远排除。 */
+  /** 潜在威胁 = 任何非 trusted（坏人 + 被怀疑）；刀冷遇坏人时硬躲这一整组。 */
   private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx)
-      && (this.isHuntTarget(p, ctx) || isKnowledgeThreat(p, ctx));
+    return !this.isTrusted(p, ctx);
   }
 
-  /** 尸体场景下「认定坏人/身份不明」= 视野内最近的非保护非队友，且在出刀范围内。 */
-  private nearestKillable(state: GameState, ctx: StrategyContext, visible: PlayerInfo[]): PlayerInfo | null {
+  /** 尸体场景出刀目标 = 视野内最近、在出刀范围内的非 trusted 非队友。hostileOnly=true 只取已确认敌对/启动猎杀目标
+   *  （hostile / hunt 参数），用于「尸体旁敌对照杀、不受灭口开关限制」；false 含未报警的身份不明者（受开关控制）。 */
+  private nearestKillable(
+    state: GameState,
+    ctx: StrategyContext,
+    visible: PlayerInfo[],
+    hostileOnly: boolean,
+  ): PlayerInfo | null {
     return visible
       .filter(p => !this.isTrusted(p, ctx))
+      .filter(p => !hostileOnly || this.isHuntTarget(p, ctx))
       .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
       .filter(x => x.d <= killCommitRange(state.you.role))
       .sort((a, b) => a.d - b.d)[0]?.p ?? null;
@@ -249,191 +200,6 @@ export class WarriorShrimpTop extends Goal {
       .sort((a, b) => a.d - b.d)[0].p;
   }
 
-  /**
-   * 自卫击杀 / 变向试探：只处理「只剩 suspect、本应只回避」的情形（hostile 在上面已优先追杀）。出刀只能由
-   * 「主动变向 + 验证对方跟随」达成，绝不靠被动转角/方位，避免「对方只是顺着走廊转、并非在追我」被误判。
-   * 每帧：
-   * ① aimedPursuit 判定本帧是否「朝我贴身追击」，维护连续帧数（变向等待期内的一帧不朝我是预期的反应延迟，先容忍）。
-   * ② 若处在变向等待期：它重新指向我的新位置 = 跟随一次（攒一次）；窗口内始终不重新瞄准 = 没跟 → 重置。
-   * ③ 攒够 SELF_DEFENSE_JUKE_FOLLOWS 次跟随、已进 killRangeFor 射程、planEscape 判定甩不掉、视线无墙 → 出刀，
-   *    并给 Agent 推一条「被动自卫」简报（区别于主动猎杀，免得之后发言/投票露馅）。
-   * ④ 否则若已被贴身追够 JUKE_STREAK 帧、甩不掉、且不在等待期 → 主动横向变一次向逼它暴露（窄道无处可变才交回常规逃跑）。
-   *
-   * 趁 reach 优势：武士虾出刀范围(160)远大于蟹(80)，确认在追后在合拢阶段先手，而不是等贴脸拼手速。出刀确认前
-   * 不清零追击状态——空刀（极端情况）下进度不该白丢；真杀掉后对方消失，下一帧威胁清空自然重置。
-   */
-  private selfDefenseKill(
-    state: GameState,
-    ctx: StrategyContext,
-    threats: PlayerInfo[],
-    killReady: boolean,
-  ): BehaviorDecision[] | null {
-    if (!SELF_DEFENSE_ENABLED) return null; // 开关关闭：直接回退到「只回避」，不进入任何试探/出刀逻辑。
-    const suspects = threats.filter(p => !this.isHuntTarget(p, ctx));
-    if (suspects.length === 0) {
-      this.resetSelfDefense();
-      return null;
-    }
-    const nearest = this.nearestByDistance(state, suspects);
-    const aimed = this.aimedPursuit(state, nearest);
-
-    if (!killReady) return null;
-
-    // 维护「朝我贴身追击」连续帧数（决定何时开始试探）。某帧不再朝我 = 追击中断，清零进度但【保留当前目标身份】
-    // 继续跟它（softResetPursuit，不是 resetSelfDefense——后者会把目标也丢掉、下一帧又当「第一次见到」永远攒不起来）。
-    // 例外：变向等待期内的一帧不朝我是预期的反应延迟，先容忍不清零。
-    if (aimed) {
-      this.selfDefenseStreak++;
-    } else if (this.selfDefenseJukeWatch === 0) {
-      this.softResetPursuit();
-      return null;
-    }
-
-    // 变向等待期：它重新指向我的【新】位置 = 跟随一次。但必须等我相对变向起点真的横向拉开够远
-    // （jukeFollowed：站在对方位置看，「我变向前」与「我现在」已分得比 cone 还开）才算数——否则我变向移动还没生效、
-    // 或位移太小直线仍落在 cone 内时，会把「持续朝旧/当前位置走」误判成「响应我变向重新咬住」。窗口内始终凑不出
-    // 一次有效跟随 = 没跟（不是在追我）→ 清零进度重新观察。
-    if (this.selfDefenseJukeWatch > 0) {
-      if (aimed && this.jukeFollowed(state, nearest)) {
-        this.selfDefenseJukeFollows++;
-        this.selfDefenseJukeWatch = 0;
-      } else if (--this.selfDefenseJukeWatch === 0) {
-        this.softResetPursuit();
-        return null;
-      }
-    }
-
-    const hopeless = this.escapeHopeless(state, threats);
-    const d = nearest.distance ?? dist(state.you.x, state.you.y, nearest.x, nearest.y);
-    if (
-      this.selfDefenseJukeFollows >= SELF_DEFENSE_JUKE_FOLLOWS
-      && d <= killRangeFor(state.you.role)
-      && hopeless
-      && this.hasShotLine(state, nearest)
-    ) {
-      this.clearSub();
-      if (!this.selfDefenseAlerted) {
-        this.selfDefenseAlerted = true;
-        ctx.notifications.push(`连续确认被${nearest.name}贴身追击、变向试探它每次都跟着咬住、退无可退，自卫先手出刀。`);
-        ctx.agentAlerts.push(
-          `我被${nearest.name}持续贴身追击、几次变向试探它都跟着甩不掉、已被逼到退无可退，刚出于自卫先下手把对方击杀了。`
-          + `这是被动自卫不是主动猎杀：接下来发言/投票按「对方一直追着我跑、我被逼到死角才自保」的口径走，别承认无故先手。`,
-        );
-      }
-      return [{ action: Action.kill(nearest.name) }];
-    }
-
-    // 还没攒够跟随：被贴身追够、甩不掉、且不在等待期时，主动横向变一次向逼它暴露。无处可变（窄道）才交回常规逃跑。
-    if (this.selfDefenseStreak >= SELF_DEFENSE_JUKE_STREAK && this.selfDefenseJukeWatch === 0 && hopeless) {
-      const juke = this.jukeTarget(state, nearest);
-      if (juke) {
-        this.selfDefenseJukeWatch = SELF_DEFENSE_JUKE_WINDOW;
-        this.selfDefenseJukeFromPos = { x: state.you.x, y: state.you.y };
-        this.clearSub();
-        return [{ action: Action.move(juke).withThinking('换个方向甩开') }];
-      }
-    }
-    return null;
-  }
-
-  /**
-   * 变向跟随是否成立：站在 suspect 当前位置看，「我发起变向那刻的位置」与「我现在的位置」的夹角已超出 cone
-   * （半角≈31.8°）。成立才说明我确实横向拉开够远——此时它仍朝我（aimed）= 它跟着我的变向重新瞄准了；
-   * 直奔我变向前位置/顺着走廊直走的虾此刻必然落在 cone 外、aimed 不成立，不会被算作跟随。
-   */
-  private jukeFollowed(state: GameState, suspect: PlayerInfo): boolean {
-    const from = this.selfDefenseJukeFromPos;
-    if (!from) return false;
-    const toFrom = unitVec(from.x - suspect.x, from.y - suspect.y);
-    const toNow = unitVec(state.you.x - suspect.x, state.you.y - suspect.y);
-    if (!toFrom || !toNow) return false;
-    return toFrom.x * toNow.x + toFrom.y * toNow.y < SELF_DEFENSE_TOWARD_COS;
-  }
-
-  /**
-   * 本帧同一 suspect 是否「朝我贴身追击」：相对上一帧位移 ≥ MOVE_EPS（确实在动，排除站桩做任务）且位移方向
-   * 与「指向我当前位置」夹角余弦 ≥ TOWARD_COS（朝我来；cone 半角≈31.8°）。换目标时整体重置并返回 false。
-   * 只读对方位移与「指向我」的关系，参考点一致；不累计任何转角（转角会被走廊弯曲污染，确认改由变向跟随负责）。
-   */
-  private aimedPursuit(state: GameState, nearest: PlayerInfo): boolean {
-    const key = nearest.name || String(nearest.seat ?? '');
-    const curS = { x: nearest.x, y: nearest.y };
-    if (key !== this.selfDefenseTargetKey) {
-      this.resetSelfDefense();
-      this.selfDefenseTargetKey = key;
-      this.selfDefenseSuspectPrev = curS;
-      return false;
-    }
-    const sPrev = this.selfDefenseSuspectPrev;
-    this.selfDefenseSuspectPrev = curS;
-    if (!sPrev) return false;
-
-    const heading = unitVec(curS.x - sPrev.x, curS.y - sPrev.y);
-    const aim = unitVec(state.you.x - sPrev.x, state.you.y - sPrev.y);
-    const movedFar = dist(sPrev.x, sPrev.y, curS.x, curS.y) >= SELF_DEFENSE_MOVE_EPS;
-    return !!heading && !!aim && movedFar
-      && heading.x * aim.x + heading.y * aim.y >= SELF_DEFENSE_TOWARD_COS;
-  }
-
-  /** planEscape 判定每条逃跑分支都会在推演内被追上（避不开）；用与 KeepAwayGoal 一致的基线参数。 */
-  private escapeHopeless(state: GameState, threats: PlayerInfo[]): boolean {
-    const threatPoints = threats.map(p => ({ x: p.x, y: p.y }));
-    return planEscape(state.you, threatPoints, KEEP_AWAY_BASE_PLAN_OPTS).caught;
-  }
-
-  /** 我到目标的连线是否无墙——确认了也别对着墙空刀（target_blocked_by_wall）。 */
-  private hasShotLine(state: GameState, target: PlayerInfo): boolean {
-    return segmentWalkable(loadWalkableGrid(), state.you.x, state.you.y, target.x, target.y);
-  }
-
-  /**
-   * 主动变向试探的落点：垂直于「背离 suspect」轴的横向点（略带背离分量以免丢距离），取两侧中离 suspect 更远、
-   * 且我到落点整段无墙的一侧。两侧都不可走 / 反而明显贴近 suspect（窄道、贴墙）时返回 null，交回常规逃跑。
-   */
-  private jukeTarget(state: GameState, suspect: PlayerInfo): Position | null {
-    const grid = loadWalkableGrid();
-    const me = state.you;
-    const curSep = dist(me.x, me.y, suspect.x, suspect.y);
-    const away = unitVec(me.x - suspect.x, me.y - suspect.y) ?? { x: 1, y: 0 };
-    const sides = [{ x: -away.y, y: away.x }, { x: away.y, y: -away.x }];
-    let best: { target: Position; sep: number } | null = null;
-    for (const perp of sides) {
-      const dir = unitVec(
-        perp.x * SELF_DEFENSE_JUKE_LATERAL + away.x * SELF_DEFENSE_JUKE_AWAY,
-        perp.y * SELF_DEFENSE_JUKE_LATERAL + away.y * SELF_DEFENSE_JUKE_AWAY,
-      );
-      if (!dir) continue;
-      const raw = { x: me.x + dir.x * SELF_DEFENSE_JUKE_DIST, y: me.y + dir.y * SELF_DEFENSE_JUKE_DIST };
-      const cell = grid.snapToWalkable(grid.worldToCell(raw.x, raw.y), 6);
-      if (cell < 0) continue;
-      const target = grid.cellToWorld(cell);
-      if (dist(me.x, me.y, target.x, target.y) < SELF_DEFENSE_JUKE_MIN_MOVE) continue;
-      if (!segmentWalkable(grid, me.x, me.y, target.x, target.y)) continue;
-      const sep = dist(target.x, target.y, suspect.x, suspect.y);
-      if (!best || sep > best.sep) best = { target, sep };
-    }
-    // 不往 suspect 身上凑：最优侧也比当前明显更近就放弃变向（交回常规逃跑）。
-    if (best && best.sep < curSep - SELF_DEFENSE_JUKE_MIN_MOVE) return null;
-    return best?.target ?? null;
-  }
-
-  /** 追击中断（某帧不再朝我 / 变向窗口内没凑出有效跟随）：清零追击进度，但【保留当前目标身份与上一帧坐标】，
-   *  它若重新咬住可继续累计——区别于 resetSelfDefense 连目标一起丢（那样下一帧又当「第一次见到」永远攒不起来）。 */
-  private softResetPursuit(): void {
-    this.selfDefenseStreak = 0;
-    this.selfDefenseJukeWatch = 0;
-    this.selfDefenseJukeFromPos = null;
-    this.selfDefenseJukeFollows = 0;
-    this.selfDefenseAlerted = false;
-  }
-
-  /** 整体重置：连当前追击目标身份一起丢（换目标、目标消失、开会、转入主动猎杀时用）。 */
-  private resetSelfDefense(): void {
-    this.selfDefenseTargetKey = null;
-    this.selfDefenseSuspectPrev = null;
-    this.softResetPursuit();
-  }
-
   private setHunt(targetName: string): void {
     const worker = this.subGoal;
     if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
@@ -448,7 +214,8 @@ export class WarriorShrimpTop extends Goal {
     this.setSubGoal(new KeepAwayGoal(
       FLEE_KEY,
       (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)),
-      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
+      // 行为不变（仍躲所有非 trusted）；措辞按真实身份逐个标注，免得把一起躲的被怀疑者也叫成「认定坏人」。
+      { threatRadius: Infinity, noun: (p, c) => this.isHuntTarget(p, c) ? '认定坏人' : '被怀疑者' } satisfies KeepAwayGoalOptions,
     ), SUB_PRIORITY);
   }
 
@@ -458,10 +225,10 @@ export class WarriorShrimpTop extends Goal {
     if (this.subGoal) this.removeSubGoal();
     this.setSubGoal(new KeepAwayGoal(
       STRANGER_KEY,
-      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isUnmarkedStranger(p, c)),
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isSuspected(p, c)),
       {
         threatRadius: STRANGER_RELEASE_RADIUS,
-        noun: '陌生人',
+        noun: '被怀疑者',
         planOpts: { steps: 4 },
       } satisfies KeepAwayGoalOptions,
     ), SUB_PRIORITY);
@@ -484,11 +251,11 @@ export class WarriorShrimpTop extends Goal {
     if (visible.length === 0) {
       msg += '，附近无人，做任务/巡逻。';
     } else if (tier === 'keep-distance') {
-      msg += '，无标记陌生人靠得太近，先拉开距离再做任务。';
+      msg += '，被怀疑者靠得太近，先拉开距离再做任务。';
     } else {
-      const bad = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name);
-      if (bad.length > 0) msg += `，发现认定坏人${bad.join('、')}`;
-      else if (this.witnessExempt) msg += `，附近有${visible.length}个无标记陌生人互为目击者，正常做任务`;
+      const bad = visible.filter(p => this.isHuntTarget(p, ctx)).map(p => p.name);
+      if (bad.length > 0) msg += `，发现坏人${bad.join('、')}`;
+      else if (this.witnessExempt) msg += `，附近有${visible.length}个被怀疑者互为目击者，正常做任务`;
       else msg += `，附近有${visible.length}人，正常做任务`;
       if (tier === 'flee-bad') msg += killCooldownSecs(state) > 0 ? '，刀在冷却，正在回避' : '，正在处理';
       if (cd > 0) msg += `（攻击冷却${cd}s）`;