@myclaw163/clawclaw-cli 0.6.66 → 0.6.68

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

@@ -1,500 +1,560 @@
-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,
-  dist,
-  firstAvailableTask,
-  hasKnownCorpse,
-  isKnowledgeHostile,
-  isKnowledgeThreat,
-  isKnowledgeTrusted,
-  killCooldownSecs,
-  killCommitRange,
-  killRangeFor,
-  matchesAnyTarget,
-  nonTeammatesVisible,
-  PROGRESS_INTERVAL_MS,
-  reportCorpseDecision,
-  SHRIMP_VISION_RANGE,
-  SHRIMP_VISION_RELEASE_RANGE,
-  taskMoveDecision,
-} 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 { KillVisibleTargetGoal } from './kill-target-goal.js';
-import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
-
-const SUB_PRIORITY = 0.5;
-const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
-const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
-const WITNESS_MEMORY_MS = 0;
-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;
-
-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 档先拉开距离。
- * - P2 紧急任务：无危险时优先处理。
- * - P3 兜底：做任务 / 巡逻
- *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
- *
- * 谁算「认定坏人」「可信同伴」来自 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)
-      .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);
-      if (victim) {
-        this.clearSub();
-        return [{ action: Action.kill(victim.name) }];
-      }
-    }
-    // 报尸 / 前往报尸：可以追着记忆里看见过、已离开视野的尸体走回去报告。
-    if (hasKnownCorpse(ctx)) {
-      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
-      if (report) {
-        this.clearSub();
-        return [report];
-      }
-    }
-
-    // ── 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));
-    if (!trustedVisible) {
-      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 stillBackingOff = worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY && !worker.isFinish(state, ctx);
-      if (!this.witnessExempt && (strangerClose || stillBackingOff)) {
-        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-        this.setStrangerKeepAway();
-        this.emitProgress(state, ctx, visible, 'keep-distance');
-        return [];
-      }
-    }
-
-    // ── P2 紧急任务 ──
-    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
-    if (emergency) {
-      this.clearSub();
-      return [taskMoveDecision(state, ctx, emergency)];
-    }
-
-    // ── P3 普通任务 / 巡逻 ──
-    this.clearSub();
-    this.emitProgress(state, ctx, visible, 'task');
-    return this.taskGoal.tick(state, ctx);
-  }
-
-  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上陌生人时不对无标记者后撤。 */
-  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
-    const now = Date.now();
-    for (const p of visible) {
-      if (!this.isUnmarkedStranger(p, ctx)) continue;
-      const key = p.name || String(p.seat ?? '');
-      if (key) this.strangerSeenAt.set(key, now);
-    }
-    for (const [key, at] of this.strangerSeenAt) {
-      if (now - at > WITNESS_MEMORY_MS) this.strangerSeenAt.delete(key);
-    }
-    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 的玩家：可信同伴，永不击杀。 */
-  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeTrusted(p, ctx);
-  }
-
-  /** 明确猎杀目标：启动参数或 hostile；suspect 不在这里。 */
-  private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx)
-      && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
-  }
-
-  /** 威胁：明确猎杀目标，或知识库 suspect 标记；trusted 永远排除。 */
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return !this.isTrusted(p, ctx)
-      && (this.isHuntTarget(p, ctx) || isKnowledgeThreat(p, ctx));
-  }
-
-  /** 尸体场景下「认定坏人/身份不明」= 视野内最近的非保护非队友，且在出刀范围内。 */
-  private nearestKillable(state: GameState, ctx: StrategyContext, visible: PlayerInfo[]): PlayerInfo | null {
-    return visible
-      .filter(p => !this.isTrusted(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;
-  }
-
-  private nearestByDistance(state: GameState, players: PlayerInfo[]): PlayerInfo {
-    return players
-      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
-      .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;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KillVisibleTargetGoal(targetName, [], true), SUB_PRIORITY);
-  }
-
-  private setFlee(): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(
-      FLEE_KEY,
-      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)),
-      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
-    ), SUB_PRIORITY);
-  }
-
-  private setStrangerKeepAway(): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(
-      STRANGER_KEY,
-      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isUnmarkedStranger(p, c)),
-      {
-        threatRadius: STRANGER_RELEASE_RADIUS,
-        noun: '陌生人',
-        planOpts: { steps: 4 },
-      } satisfies KeepAwayGoalOptions,
-    ), SUB_PRIORITY);
-  }
-
-  private clearSub(): void {
-    if (this.subGoal) this.removeSubGoal();
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    const cd = killCooldownSecs(state);
-    const killsRemaining = state.you.kills_remaining;
-
-    let msg = `[进度] 当前在${room}`;
-    if (visible.length === 0) {
-      msg += '，附近无人，做任务/巡逻。';
-    } else if (tier === 'keep-distance') {
-      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}个无标记陌生人互为目击者，正常做任务`;
-      else msg += `，附近有${visible.length}人，正常做任务`;
-      if (tier === 'flee-bad') msg += killCooldownSecs(state) > 0 ? '，刀在冷却，正在回避' : '，正在处理';
-      if (cd > 0) msg += `（攻击冷却${cd}s）`;
-      if (killsRemaining === 0) msg += '（出刀次数已用完）';
-      msg += '。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+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,
+  dist,
+  firstAvailableTask,
+  hasKnownCorpse,
+  isKnowledgeHostile,
+  isKnowledgeTrusted,
+  killCooldownSecs,
+  killCommitRange,
+  killRangeFor,
+  matchesAnyTarget,
+  nonTeammatesVisible,
+  PROGRESS_INTERVAL_MS,
+  reportCorpseDecision,
+  SHRIMP_VISION_RANGE,
+  SHRIMP_VISION_RELEASE_RANGE,
+  taskMoveDecision,
+} 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 { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
+const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
+const WITNESS_MEMORY_MS = 0;
+const WITNESS_EXEMPT_COUNT = 2;
+const TASK_RETURN_INERTIA_MS = 2_000;
+const FLEE_KEY = 'warrior-flee';
+const STRANGER_KEY = 'warrior-stranger-distance';
+// 尸体现场灭口开关：false=站在尸体旁也绝不因「身边有未报警的身份不明者」先手灭口，只报警（hostile/启动目标仍按 P1 追杀）；
+// true=刀可用时先击杀尸体旁最近的非 trusted 非队友。关掉是为根治「把尸体边未报警的无辜虾当凶手灭口」的误杀。
+const CORPSE_SCENE_KILL_ENABLED: boolean = false;
+// 自卫总开关：false=遇到被怀疑者一律只回避（绝不变向试探、绝不自卫出刀），等同纯回避档；true=启用下方绝境自卫流程。
+const SELF_DEFENSE_ENABLED: boolean = true;
+// 自卫出刀只能由「主动变向试探 + 验证对方跟随」达成，绝不靠被动转角/方位判定——那些会被走廊弯曲、寻路曲线、
+// 贴身掠过污染（对方只是顺着走廊转、并非在追我，却累积出大转角）。流程：
+// ① 同一被怀疑者连续 JUKE_STREAK 帧「朝我贴身追击」（aimedPursuit：相对上帧位移 ≥ MOVE_EPS 且方向与「指向我」
+//    夹角余弦 ≥ TOWARD_COS；cone 半角≈31.8°）且 planEscape 判定甩不掉 → 被咬住又逃不掉，开始试探；
+// ② 主动横向变一次向（jukeTarget），变向幅度足够大，使「不跟随者」必然掉出 cone；
+// ③ 变向后 JUKE_WINDOW 帧内，比较对方【变向前朝向 hBefore】与【当前朝向 hNow】：朝向变化(hNow−hBefore)沿我 juke
+//    方向偏转 reaim≥MARGIN、且当前朝向仍对准我新位置 = 跟随一次（jukeFollowed）。只认对方朝向【响应我变向】的再
+//    瞄准——同向匀速通勤的虾朝向恒定(hNow≈hBefore，reaim≈0)，无论它是否恰好直行掠过我旧位置都攒不到跟随；走廊弯
+//    曲/几何发散一概不算。变向后第 1 帧对方因反应延迟可能短暂未转向，故用 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;
+// 跟随判定的「再瞄准余量」：变向后对方【朝向变化】(hNow−hBefore)沿我 juke 方向的分量须达到这个余量，才算它响应了
+// 我的变向。同向匀速通勤者朝向恒定、朝向变化≈0 → reaim≈0 天然被拒；真跟随者转向追我新位置、朝向变化沿 juke 方向 →
+// reaim 为正（近距离 >0.2，越远越小但仍 ≫ 位置噪声）。取一个略高于噪声（≪0.01）的小正数即可分开两者；过大会误拒
+// 中远距离的真跟随者、削弱真自卫。
+const SELF_DEFENSE_REAIM_MARGIN = 0.05;
+// 主动变向试探：横向位移目标距离；方向以横向为主、略带「背离对方」分量以免试探时丢距离；落点至少这么远才算有效变向。
+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 发现尸体：旁边是 hostile/启动猎杀目标且刀可用 → 现场先手击杀；未报警的身份不明者默认不灭口
+ *   （CORPSE_SCENE_KILL_ENABLED，根治误杀）；否则报警（靠近至可报距离）。
+ * - P1 处理危险：坏人（启动参数 / 知识库 hostile）刀好就追杀；
+ *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑，不再有 suspect 标记），默认只回避，绝不仅凭怀疑或被动观察出刀——
+ *   只有被同一个被怀疑者持续贴身追击、主动变向试探验证它跟着我变向咬住、退无可退才自卫先手
+ *   （实战里真凶常没来得及标记就追杀，故对所有被怀疑者都适用，不要求先标记）；坏人刀冷时硬躲所有非好人；
+ *   无可信同伴且单个被怀疑者贴近（未触发自卫）→ 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
+ * - P2 紧急任务：无危险时优先处理。
+ * - P3 兜底：做任务 / 巡逻
+ *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
+ *
+ * 谁算「坏人」「可信同伴」来自 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.isHuntTarget(p, c) || !this.witnessExempt)
+      .map(p => ({ x: p.x, y: p.y })),
+  );
+  private readonly strangerSeenAt = new Map<string, number>();
+  private witnessExempt = false;
+  /** 自卫：当前被判定在追我的被怀疑者 key、它上一帧坐标、它本帧朝向、连续「朝我贴身追击」帧数（决定何时开始试探）、
+   *  变向后等待对方跟随的剩余帧数（0=未在等）、发起变向那刻我的坐标（验证跟随用）、已验证的跟随次数、
+   *  本轮是否已推过自卫简报。 */
+  private selfDefenseTargetKey: string | null = null;
+  private selfDefensePursuerPrev: { x: number; y: number } | null = null;
+  /** 追击者本帧朝向（上一帧→本帧的单位位移），aimedPursuit 每帧维护；jukeFollowed 用它判定对方是否响应我变向改朝向。 */
+  private selfDefensePursuerHeading: { x: number; y: number } | null = null;
+  private selfDefenseStreak = 0;
+  private selfDefenseJukeWatch = 0;
+  private selfDefenseJukeFromPos: { x: number; y: number } | null = null;
+  /** 发起变向那刻追击者的朝向（hBefore）：jukeFollowed 比较它与变向后当前朝向的【变化】，判定对方是否真的转向追我新位置。 */
+  private selfDefenseJukePursuerHeading: { 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) {
+      // 尸体旁的【已确认敌对 / 启动猎杀目标】始终先手击杀，不受灭口开关影响、且排在报尸之前——凶手就在身边时照杀。
+      // 仅「未报警的身份不明者」（非 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) }];
+      }
+    }
+    // 报尸 / 前往报尸：可以追着记忆里看见过、已离开视野的尸体走回去报告。
+    if (hasKnownCorpse(ctx)) {
+      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
+      if (report) {
+        this.clearSub();
+        return [report];
+      }
+    }
+
+    // ── 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 [];
+      }
+      // P1-B 绝境自卫：对被怀疑的贴身追击者（非坏人、非 trusted）——连续确认朝我追击、主动变向试探它每次都跟着咬住、
+      // 已进 160 射程、退无可退、视线无墙，才自卫先下手（趁 reach 优势在合拢阶段先手）+ Agent 自卫简报。
+      // 不要求先标 suspect：实战里真凶常没来得及标记就开始追杀，所以对所有被怀疑者都适用（juke 验证保证不误杀顺路虾）。
+      const selfDefense = this.selfDefenseKill(state, ctx, threats, killReady);
+      if (selfDefense) return selfDefense;
+
+      // P1-C 有坏人/启动目标但刀冷（杀不了）→ 硬躲所有非好人。
+      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-D 只剩被怀疑者：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离；
+      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务（自卫追踪已在 selfDefenseKill 内按需维护）。
+      const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
+      const worker = this.subGoal;
+      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 (!trustedVisible && !this.witnessExempt && (suspectedClose || stillBackingOff)) {
+        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+        this.setStrangerKeepAway();
+        this.emitProgress(state, ctx, visible, 'keep-distance');
+        return [];
+      }
+    } else {
+      this.resetSelfDefense();
+    }
+
+    // ── P2 紧急任务 ──
+    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
+    if (emergency) {
+      this.clearSub();
+      return [taskMoveDecision(state, ctx, emergency)];
+    }
+
+    // ── P3 普通任务 / 巡逻 ──
+    this.clearSub();
+    this.emitProgress(state, ctx, visible, 'task');
+    return this.taskGoal.tick(state, ctx);
+  }
+
+  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上被怀疑者时不对其后撤（多人互为目击者，蟹不敢当众动手）。 */
+  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
+    const now = Date.now();
+    for (const p of visible) {
+      if (!this.isSuspected(p, ctx)) continue;
+      const key = p.name || String(p.seat ?? '');
+      if (key) this.strangerSeenAt.set(key, now);
+    }
+    for (const [key, at] of this.strangerSeenAt) {
+      if (now - at > WITNESS_MEMORY_MS) this.strangerSeenAt.delete(key);
+    }
+    this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
+  }
+
+  /** 被怀疑者：非 trusted（好人）且非坏人/启动目标——未标记的默认就落这档，对应 B 档保持距离 + 绝境自卫。 */
+  private isSuspected(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx) && !this.isHuntTarget(p, ctx);
+  }
+
+  /** 知识里 trusted 的玩家：可信同伴，永不击杀。 */
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  /** 坏人 / 明确猎杀目标：启动参数或知识库 hostile；被怀疑者不在这里。 */
+  private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx)
+      && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
+  }
+
+  /** 潜在威胁 = 任何非 trusted（坏人 + 被怀疑）；刀冷遇坏人时硬躲这一整组。 */
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx);
+  }
+
+  /** 尸体场景出刀目标 = 视野内最近、在出刀范围内的非 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;
+  }
+
+  private nearestByDistance(state: GameState, players: PlayerInfo[]): PlayerInfo {
+    return players
+      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
+      .sort((a, b) => a.d - b.d)[0].p;
+  }
+
+  /**
+   * 自卫击杀 / 变向试探：只处理「被怀疑者」（非坏人、非 trusted）持续贴身追击的情形（坏人在上面已优先追杀/硬躲）。
+   * 实战里真凶往往还没被标记就开始追杀，所以这里对所有被怀疑者都适用，不要求先标 suspect——juke 验证保证只杀真在追我的。
+   * 出刀只能由「主动变向 + 验证对方跟随」达成，绝不靠被动转角/方位，避免「对方只是顺着走廊转、并非在追我」被误判。
+   * 每帧：
+   * ① 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; // 开关关闭：直接回退到「只回避」，不进入任何试探/出刀逻辑。
+    // 目击者豁免同样限制自卫：现场≥2 个互为目击者的被怀疑者时不试探、不出刀。人多时蟹不敢当众动手（嫌疑会落到自己头上），
+    // 而拥挤又会把自卫的「退无可退」前提（escapeHopeless 把在场每个人都当障碍）刷成恒真；此档只做任务/回避，杜绝在人堆里误杀。
+    if (this.witnessExempt) {
+      this.resetSelfDefense();
+      return null;
+    }
+    const pursuers = threats.filter(p => !this.isHuntTarget(p, ctx));
+    if (pursuers.length === 0) {
+      this.resetSelfDefense();
+      return null;
+    }
+    const nearest = this.nearestByDistance(state, pursuers);
+    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 };
+        // hBefore：变向前对方朝向，jukeFollowed 拿它和窗口内的当前朝向比【变化量】判断是否响应我变向。
+        this.selfDefenseJukePursuerHeading = this.selfDefensePursuerHeading;
+        this.clearSub();
+        return [{ action: Action.move(juke).withThinking('换个方向甩开') }];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 变向跟随是否成立（对方【朝向变化】响应判定，非几何发散）：比较追击者在我发起变向前的朝向（hBefore）与变向后
+   * 本帧的朝向（hNow），看朝向【变化量】(hNow−hBefore)是否朝我 juke 的方向偏转，且当前朝向确实对准我的新位置：
+   *   · jukeDir = 我从变向起点到现在的实际位移方向（我往哪侧 juke）。
+   *   · reaim = (hNow−hBefore)·jukeDir：对方朝向沿我 juke 方向偏转了多少。
+   * 同向匀速通勤者朝向恒定（hNow≈hBefore）→ reaim≈0 → 判否，与它是否恰好直行掠过我旧位置无关——这正是旧公式的
+   * 漏洞：旧公式只拿【当前朝向】比对【新旧位置】，追击者直行掠过旧位置时「指向旧位置」会翻到它身后，reaim 被刷到
+   * ≈2 误判成跟随。真跟随者为追我的横向变向把朝向转向新位置 → (hNow−hBefore) 沿 jukeDir 为正 → 判真。再加 headingAtNew
+   * 须 ≥ TOWARD_COS，排除「朝向变了但不是冲我新位置来」。不依赖任何固定转角阈值。
+   */
+  private jukeFollowed(state: GameState, pursuer: PlayerInfo): boolean {
+    const from = this.selfDefenseJukeFromPos;
+    const hBefore = this.selfDefenseJukePursuerHeading;
+    const hNow = this.selfDefensePursuerHeading;
+    if (!from || !hBefore || !hNow) return false;
+    // 我相对变向起点还没真的拉开（位移太小）时，朝向变化无从衡量、jukeDir 也是噪声 → 先不判，留给窗口里后续帧。
+    const jukeDir = unitVec(state.you.x - from.x, state.you.y - from.y);
+    if (!jukeDir || dist(from.x, from.y, state.you.x, state.you.y) < SELF_DEFENSE_JUKE_MIN_MOVE) return false;
+    const aimNew = unitVec(state.you.x - pursuer.x, state.you.y - pursuer.y);
+    if (!aimNew) return false;
+    const headingAtNew = hNow.x * aimNew.x + hNow.y * aimNew.y;
+    const reaim = (hNow.x - hBefore.x) * jukeDir.x + (hNow.y - hBefore.y) * jukeDir.y;
+    return headingAtNew >= SELF_DEFENSE_TOWARD_COS && reaim >= SELF_DEFENSE_REAIM_MARGIN;
+  }
+
+  /**
+   * 本帧同一追击者是否「朝我贴身追击」：相对上一帧位移 ≥ MOVE_EPS（确实在动，排除站桩做任务）且位移方向
+   * 与「指向我当前位置」夹角余弦 ≥ TOWARD_COS（朝我来；cone 半角≈31.8°）。换目标时整体重置并返回 false。
+   * 只读对方位移与「指向我」的关系，参考点一致；不累计任何转角（转角会被走廊弯曲污染，确认改由变向跟随负责）。
+   * 注意：这只是【触发器】，不是敌意判别——直线追我与直线通勤在被试探前逐帧完全相同（朝向都恒定、都指向我），
+   * 单凭每帧朝向/方差无法区分；判别力全在 jukeFollowed（试探后对方是否改朝向响应）。顺手把本帧朝向存进
+   * selfDefensePursuerHeading 供其使用（仅在 movedFar 时被消费，故站桩噪声朝向进不去）。
+   */
+  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.selfDefensePursuerPrev = curS;
+      return false;
+    }
+    const sPrev = this.selfDefensePursuerPrev;
+    this.selfDefensePursuerPrev = curS;
+    if (!sPrev) {
+      this.selfDefensePursuerHeading = null;
+      return false;
+    }
+
+    const heading = unitVec(curS.x - sPrev.x, curS.y - sPrev.y);
+    this.selfDefensePursuerHeading = heading;
+    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 一致的基线参数。
+   *  这是自卫的【必要条件】（退无可退才试探/出刀），不是敌意证据——死路里它对任何人都恒真、与对方是否敌对无关；
+   *  敌意判别 100% 来自 jukeFollowed 的朝向响应。 */
+  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);
+  }
+
+  /**
+   * 主动变向试探的落点：垂直于「背离追击者」轴的横向点（略带背离分量以免丢距离），取两侧中离追击者更远、
+   * 且我到落点整段无墙的一侧。两侧都不可走 / 反而明显贴近追击者（窄道、贴墙）时返回 null，交回常规逃跑。
+   */
+  private jukeTarget(state: GameState, pursuer: PlayerInfo): Position | null {
+    const grid = loadWalkableGrid();
+    const me = state.you;
+    const curSep = dist(me.x, me.y, pursuer.x, pursuer.y);
+    const away = unitVec(me.x - pursuer.x, me.y - pursuer.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, pursuer.x, pursuer.y);
+      if (!best || sep > best.sep) best = { target, sep };
+    }
+    // 不往追击者身上凑：最优侧也比当前明显更近就放弃变向（交回常规逃跑）。
+    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.selfDefenseJukePursuerHeading = null;
+    this.selfDefenseJukeFollows = 0;
+    this.selfDefenseAlerted = false;
+  }
+
+  /** 整体重置：连当前追击目标身份一起丢（换目标、目标消失、开会、转入主动猎杀时用）。 */
+  private resetSelfDefense(): void {
+    this.selfDefenseTargetKey = null;
+    this.selfDefensePursuerPrev = null;
+    this.selfDefensePursuerHeading = null;
+    this.softResetPursuit();
+  }
+
+  private setHunt(targetName: string): void {
+    const worker = this.subGoal;
+    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KillVisibleTargetGoal(targetName, [], true), SUB_PRIORITY);
+  }
+
+  private setFlee(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(
+      FLEE_KEY,
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)),
+      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private setStrangerKeepAway(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(
+      STRANGER_KEY,
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isSuspected(p, c)),
+      {
+        threatRadius: STRANGER_RELEASE_RADIUS,
+        noun: '被怀疑者',
+        planOpts: { steps: 4 },
+      } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private clearSub(): void {
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const cd = killCooldownSecs(state);
+    const killsRemaining = state.you.kills_remaining;
+
+    let msg = `[进度] 当前在${room}`;
+    if (visible.length === 0) {
+      msg += '，附近无人，做任务/巡逻。';
+    } else if (tier === 'keep-distance') {
+      msg += '，被怀疑者靠得太近，先拉开距离再做任务。';
+    } else {
+      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）`;
+      if (killsRemaining === 0) msg += '（出刀次数已用完）';
+      msg += '。';
+    }
+    ctx.notifications.push(msg);
+  }
+}