@myclaw163/clawclaw-cli 0.6.61 → 0.6.64

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

@@ -1,5 +1,7 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import type { GameState, PlayerInfo, Position } 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,
@@ -11,6 +13,7 @@ import {
   isKnowledgeTrusted,
   killCooldownSecs,
   killCommitRange,
+  killRangeFor,
   matchesAnyTarget,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -21,7 +24,7 @@ import {
 } from '../game-utils.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
-import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
+import { KEEP_AWAY_BASE_PLAN_OPTS, KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
 import { KillVisibleTargetGoal } from './kill-target-goal.js';
 import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
 
@@ -33,15 +36,54 @@ const WITNESS_EXEMPT_COUNT = 2;
 const TASK_RETURN_INERTIA_MS = 2_000;
 const FLEE_KEY = 'warrior-flee';
 const STRANGER_KEY = 'warrior-stranger-distance';
+// 自卫出刀只能由「主动变向试探 + 验证对方跟随」达成，绝不靠被动转角/方位判定——那些会被走廊弯曲、寻路曲线、
+// 贴身掠过污染（对方只是顺着走廊转、并非在追我，却累积出大转角）。流程：
+// ① 同一 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;
 
 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 只表示可疑，始终回避，不会仅凭怀疑主动出刀；
+ *   suspect 只表示可疑，默认回避，绝不仅凭怀疑或被动观察出刀——只有主动变向试探、验证它确实跟着我变向追击且退无可退才自卫先手；
  *   无可信同伴且单个无标记陌生人贴近 → 按普通虾 B 档先拉开距离。
  * - P2 紧急任务：无危险时优先处理。
  * - P3 兜底：做任务 / 巡逻
@@ -60,11 +102,27 @@ export class WarriorShrimpTop extends Goal {
   );
   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);
@@ -89,19 +147,26 @@ export class WarriorShrimpTop extends Goal {
       }
     }
 
-    // ── P1-A hostile 刀好就追；suspect 只回避 ──
+    // ── P1-A hostile 刀好就追；suspect 只回避（避不开且能杀时自卫出刀） ──
     const threats = visible.filter(p => this.isThreat(p, ctx));
     if (threats.length > 0) {
       const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
       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 无可信同伴且无标记陌生人贴近 → 按普通虾 B 档拉开距离 ──
     const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
@@ -182,6 +247,190 @@ 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 {
+    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;

package/src/strategies/hide-spots.ts

@@ -0,0 +1,123 @@
+import type { Position } from '../sdk/types.js';
+import { dist } from './game-utils.js';
+import { assessRoutes } from './pathfind/escape-planner.js';
+
+export interface HideSpot {
+  /** 世界像素坐标，与 GameState / 可行走网格同坐标系。 */
+  x: number;
+  y: number;
+  /** 所在房间，仅供日志/调试。 */
+  room: string;
+}
+
+/**
+ * 躲藏点：离线从服务端烘焙地图（config/clawclaw/clawclaw.tmj.baked.npz）算出的「藏身角落」。筛选条件：
+ *  - 所在房间有 ≥2 个出口（非死胡同，被追能逃）；**走廊**（做任务的必经路线）一律排除；
+ *  - 出口 ≥4 的枢纽房间排除（穿行人流太大，藏不住）；
+ *  - 取房间内「离各出口最深、且远离任务点/出生点」的可走格（缩在内侧角落，避开穿行线与刷新点）。
+ *
+ * 重新生成：scripts/find-hide-spots.py（用后端 venv 解释器跑，读 baked.npz，打印可粘贴的本数组）。
+ * 这是离线烘焙数据，和 pathfind 的可行走网格一样：运行时按需 snap 到最近可走格即可。
+ */
+export const HIDE_SPOTS: readonly HideSpot[] = [
+  { x: 2882, y: 1362, room: '导航仓' },
+  { x: 2386, y: 1138, room: '健身房' },
+  { x: 1922, y: 1234, room: '酒吧' },
+  { x: 2418, y: 2130, room: '休闲会所' },
+  { x: 1538, y: 1826, room: '监控室' },
+  { x: 514, y: 2402, room: '动力监控室' },
+  { x: 1538, y: 2514, room: '自助餐厅' },
+  { x: 1314, y: 2674, room: '制氧舱' },
+  { x: 2514, y: 2882, room: '中央厨房' },
+  { x: 2882, y: 2994, room: '冷库' },
+  { x: 3858, y: 2434, room: '情报室' },
+];
+
+/** 躲藏点离任一威胁多近就硬排除（与 nearestSafeTask 的端点排除同量级）。 */
+export const HIDE_THREAT_EXCLUDE_RANGE = 500;
+/** 去躲藏点的测地路径经过威胁这个距离内也排除（避免走向把守者）。 */
+export const HIDE_PATH_THREAT_RADIUS = 350;
+
+export interface NearestSafeHideOptions {
+  threatExcludeRadius?: number;
+  pathThreatRadius?: number;
+  /** 当前已选躲藏点：仍是合法候选就保持不变，杜绝等距摇摆。 */
+  stickyTo?: HideSpot | null;
+  /** 被标记为不可达的移动目标：在其附近的点跳过。 */
+  blockedTarget?: Position | null;
+}
+
+const BLOCKED_RADIUS = 12;
+
+function sameSpot(a: HideSpot, b: HideSpot): boolean {
+  return a.x === b.x && a.y === b.y;
+}
+
+/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
+function farthestFromThreats(threatPoints: Position[], blocked?: Position | null): HideSpot | null {
+  let best: HideSpot | null = null;
+  let bestMin = -Infinity;
+  for (const s of HIDE_SPOTS) {
+    if (blocked && dist(s.x, s.y, blocked.x, blocked.y) <= BLOCKED_RADIUS) continue;
+    const minD = threatPoints.length === 0 ? 0 : Math.min(...threatPoints.map(p => dist(s.x, s.y, p.x, p.y)));
+    if (minD > bestMin) {
+      bestMin = minD;
+      best = s;
+    }
+  }
+  return best;
+}
+
+/**
+ * 选「最近的安全躲藏点」：与 nearestSafeTask 同构——威胁旁的点硬排除、去路经过威胁附近的点排除，
+ * 余者取测地最近（distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。
+ * 全部被威胁封死时退回「离威胁最远」的点。
+ */
+export function nearestSafeHideSpot(
+  from: Position,
+  threatPoints: Position[] = [],
+  opts: NearestSafeHideOptions = {},
+): HideSpot | null {
+  const excludeR = opts.threatExcludeRadius ?? HIDE_THREAT_EXCLUDE_RANGE;
+  const blocked = opts.blockedTarget ?? null;
+
+  const candidates = HIDE_SPOTS.filter(s =>
+    (!blocked || dist(s.x, s.y, blocked.x, blocked.y) > BLOCKED_RADIUS)
+    && !threatPoints.some(p => dist(s.x, s.y, p.x, p.y) <= excludeR));
+
+  if (candidates.length === 0) return farthestFromThreats(threatPoints, blocked);
+
+  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
+  if (opts.stickyTo && threatPoints.length === 0) {
+    const sticky = candidates.find(c => sameSpot(c, opts.stickyTo!));
+    if (sticky) return sticky;
+  }
+
+  const routes = assessRoutes(
+    from,
+    candidates.map(c => ({ x: c.x, y: c.y })),
+    threatPoints,
+    opts.pathThreatRadius ?? HIDE_PATH_THREAT_RADIUS,
+  );
+  const indexed = candidates.map((c, i) => ({ c, i }));
+  const viable = routes == null ? indexed : indexed.filter(({ i }) => !routes[i].nearThreat);
+  const pool = viable.length > 0 ? viable : indexed;
+
+  if (opts.stickyTo) {
+    const sticky = pool.find(({ c }) => sameSpot(c, opts.stickyTo!));
+    if (sticky) return sticky.c;
+  }
+
+  let best = pool[0].c;
+  let bestScore = Infinity;
+  for (const { c, i } of pool) {
+    const euclid = dist(from.x, from.y, c.x, c.y);
+    const geo = routes?.[i].distancePx;
+    const score = geo == null ? euclid : geo !== Infinity ? geo : euclid + 1e6;
+    if (score < bestScore) {
+      bestScore = score;
+      best = c;
+    }
+  }
+  return best;
+}

package/src/strategies/hide.ts

@@ -0,0 +1,23 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { HideTop } from './goals/hide-top.js';
+
+/** 解析参数：kill/fight → 死角自保开；nokill/flee/pacifist → 关；缺省（null）= 按角色默认。 */
+export function parseHideKillArg(args?: string[]): boolean | null {
+  for (const raw of args ?? []) {
+    const a = raw.trim().toLowerCase();
+    if (a === 'kill' || a === 'fight' || a === 'kill=on') return true;
+    if (a === 'nokill' || a === 'flee' || a === 'pacifist' || a === 'kill=off') return false;
+  }
+  return null;
+}
+
+export const strategy: StrategyEntry = {
+  id: 'hide',
+  description:
+    '躲藏策略：在离线从地图算好的若干「非走廊、≥2 出口可逃、远离任务点/出生点」的藏身角落里，选测地最近且不挨威胁的一个潜伏不动；视野里一出现非队友，就像 shrimp-memory 那样保持距离甩开（KeepAway），并边逃边重算排除该威胁的新藏点，逃完落到新点继续潜伏。蟹不躲队友。可选参数 kill / nokill 控制「被单个对手逼进出刀距离且无路可逃时是否出刀自保」——缺省按角色：蟹/章鱼默认开，武士虾/枪虾（及无刀角色）默认关。',
+  create(args?: string[]) {
+    const killWhenCornered = parseHideKillArg(args);
+    return new GoalRootStrategy('hide', () => new HideTop(killWhenCornered), { resetOnMeetingResume: false });
+  },
+};

package/src/strategies/strategy-loop.ts

@@ -379,6 +379,7 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
 
   const ctx: StrategyContext = {
     taskData: [],
+    taskLocations: [],
     emergency: null,
     taskLocalBlockedUntil: 0,
     reportCorpseTarget: null,
@@ -669,6 +670,9 @@ export async function runStrategyLoop(strategyId: string, args?: string[]): Prom
           is_fake_shrimp: t.is_fake_shrimp ?? false,
           faction: taskFactionByName.get(t.name),
         }));
+        ctx.taskLocations = (mapData?.all_task_locations ?? [])
+          .filter((t: any) => t && typeof t.name === 'string' && typeof t.x === 'number' && typeof t.y === 'number')
+          .map((t: any) => ({ name: t.name, room: t.room, x: t.x, y: t.y, faction: t.faction }));
         if (Array.isArray(mapData?.rooms)) {
           if (ctx.rooms.length === 0) {
             const byRoom = taskLocationsByRoom(mapData?.all_task_locations);

package/src/strategies/types.ts

@@ -1,4 +1,4 @@
-import type { GameState, TaskInfo, EmergencyInfo, CorpseInfo } from '../sdk/types.js';
+import type { GameState, TaskInfo, TaskLocation, EmergencyInfo, CorpseInfo } from '../sdk/types.js';
 import type { Action } from '../sdk/action.js';
 import type { KnowledgeView } from '../lib/knowledge-store.js';
 
@@ -57,6 +57,12 @@ export interface RoomTarget {
 
 export interface StrategyContext {
   taskData: TaskInfo[];
+  /**
+   * 全局任务站点（map 的 all_task_locations），strategy-loop 加载地图后写入。与 taskData（仅自己被
+   * 分配、带 status）不同：这是地图上所有任务点的位置，开局固定。用于「同伴停在任务点附近 → 在真实
+   * 任务点假装做任务」这类定点行为。首次地图加载前可能为空/未设置。
+   */
+  taskLocations?: TaskLocation[];
   emergency: EmergencyInfo | null;
   taskLocalBlockedUntil: number;
   reportCorpseTarget: CorpseTarget | null;

package/src/strategies/warrior-memory.knowledge.md

@@ -4,10 +4,12 @@
 
 | 标记 | 行为 |
 |------|------|
-| `suspect` | 可疑：始终回避观察，即使刀可用也不主动击杀 |
+| `suspect` | 可疑：默认回避观察，刀可用也不主动猎杀；仅「绝境自卫」例外（见下） |
 | `hostile` | 敌对：刀可用时主动追杀；刀冷却或枪虾无次数时回避 |
 | `trusted` | 可信：绝不攻击，也不会因其在场而对陌生人后撤 |
 
+**suspect 的绝境自卫例外**：当被同一个 suspect 连续贴身追击、且逃跑推演判定甩不掉时，武士虾会主动横向变一次向试探。只有它跟着变向重新咬住（确认是在追我、不是顺路赶路）、已进 160px 射程、且我到它视线无墙，才会出于自卫先手击杀，并向 agent 推一条「被动自卫」简报（供后续发言/投票口径对齐，别承认无故先手）。直奔身后任务点、顺路掠过的虾不会跟着变向，会被自然甩开、绝不误杀。这是最后手段——多数情况下变向只是把追兵甩开，并不出刀。
+
 无标记玩家按陌生人处理：平时不主动猎杀；无 trusted 同伴且单个陌生人贴近 270px 内时先拉开距离。尸体场景仍有更高优先级：刀可用时会攻击尸体旁最近的非 trusted 非队友，因此确认好人后应及时标为 trusted。
 
 ```bash

package/src/strategies/warrior-memory.ts

@@ -6,7 +6,7 @@ import { parseTargetArgs } from './player-targets.js';
 export const strategy: StrategyEntry = {
   id: 'warrior-memory',
   description:
-    '带刀虾·记忆进阶版（武士虾/枪虾通用，好人带刀；kill-lone 的带记忆升级）。统一读取 ccl knowledge 三档标记：suspect 只回避观察，hostile 在刀好时主动追杀、刀不好时回避，trusted 视为可信同伴且绝不攻击。发现尸体且旁边有非 trusted 对象、刀可用就先出刀，否则靠近报警；无可信同伴且单个陌生人贴近270内时先拉开到300再做任务；无危险时优先紧急任务，否则做任务/巡逻。枪虾会尊重剩余出刀次数。',
+    '带刀虾·记忆进阶版（武士虾/枪虾通用，好人带刀；kill-lone 的带记忆升级）。统一读取 ccl knowledge 三档标记：suspect 默认只回避观察，仅当被同一个持续贴身追击、避让判定甩不掉时主动横向变向试探，只有它跟着变向仍咬住、进了射程且视线无墙才自卫先手击杀（被动自卫，会推 agent 简报；直奔任务点顺路掠过的虾不跟变向、自然甩开不误杀），hostile 在刀好时主动追杀、刀不好时回避，trusted 视为可信同伴且绝不攻击。发现尸体且旁边有非 trusted 对象、刀可用就先出刀，否则靠近报警；无可信同伴且单个陌生人贴近270内时先拉开到300再做任务；无危险时优先紧急任务，否则做任务/巡逻。枪虾会尊重剩余出刀次数。',
   create(args?: string[]) {
     const huntTargets = args ? parseTargetArgs(args) : [];
     return new GoalRootStrategy('warrior-memory', () => new WarriorShrimpTop(huntTargets), {