@myclaw163/clawclaw-cli 0.6.71 → 0.6.76

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

@@ -1,267 +1,267 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  corpseAtScene,
-  dist,
-  firstAvailableTask,
-  hasKnownCorpse,
-  isKnowledgeHostile,
-  isKnowledgeTrusted,
-  killCooldownSecs,
-  killCommitRange,
-  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 { 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;
-
-type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
-
-/**
- * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
- *
- * - P0 发现尸体：旁边是 hostile/启动猎杀目标且刀可用 → 现场先手击杀；未报警的身份不明者默认不灭口
- *   （CORPSE_SCENE_KILL_ENABLED，根治误杀）；否则报警（靠近至可报距离）。
- * - P1 处理危险：**只对【已确认 hostile】（启动参数 / 知识库 hostile）出刀**——刀好就追杀，刀冷就硬躲所有非好人。
- *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑）：**只回避、绝不出刀**——无可信同伴且单个被怀疑者
- *   贴近 → 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
- *   （历史上的「贴身追击判定 + 诱饵试探 + 绝境自卫反杀」整套已删除：几何上无法把「贴身跟我观察的好人」和「贴身追我的
- *   凶手」区分开，自卫出刀迟早误杀同阵营好人、触发 warrior_shrimp_self_destruct 直接崩盘，代价远大于收益。）
- * - 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;
-
-  constructor(private readonly huntTargets: string[] = []) {
-    super();
-  }
-
-  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.setHunt(this.nearestByDistance(state, huntTargets).name);
-        return [];
-      }
-
-      // 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-C 只剩被怀疑者（无已确认坏人）：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离（只回避，绝不出刀）；
-      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务。
-      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 [];
-      }
-    }
-
-    // ── 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;
-  }
-
-  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)),
-      // 行为不变（仍躲所有非 trusted）；措辞按真实身份逐个标注，免得把一起躲的被怀疑者也叫成「认定坏人」。
-      { threatRadius: Infinity, noun: (p, c) => this.isHuntTarget(p, c) ? '认定坏人' : '被怀疑者' } 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);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  corpseAtScene,
+  dist,
+  firstAvailableTask,
+  hasKnownCorpse,
+  isKnowledgeHostile,
+  isKnowledgeTrusted,
+  killCooldownSecs,
+  killCommitRange,
+  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 { 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;
+
+type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
+
+/**
+ * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
+ *
+ * - P0 发现尸体：旁边是 hostile/启动猎杀目标且刀可用 → 现场先手击杀；未报警的身份不明者默认不灭口
+ *   （CORPSE_SCENE_KILL_ENABLED，根治误杀）；否则报警（靠近至可报距离）。
+ * - P1 处理危险：**只对【已确认 hostile】（启动参数 / 知识库 hostile）出刀**——刀好就追杀，刀冷就硬躲所有非好人。
+ *   其余非 trusted 一律按「被怀疑」处理（未标记 = 默认被怀疑）：**只回避、绝不出刀**——无可信同伴且单个被怀疑者
+ *   贴近 → 按普通虾 B 档先拉开距离（多人互为目击者则照常做任务）。
+ *   （历史上的「贴身追击判定 + 诱饵试探 + 绝境自卫反杀」整套已删除：几何上无法把「贴身跟我观察的好人」和「贴身追我的
+ *   凶手」区分开，自卫出刀迟早误杀同阵营好人、触发 warrior_shrimp_self_destruct 直接崩盘，代价远大于收益。）
+ * - 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;
+
+  constructor(private readonly huntTargets: string[] = []) {
+    super();
+  }
+
+  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.setHunt(this.nearestByDistance(state, huntTargets).name);
+        return [];
+      }
+
+      // 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-C 只剩被怀疑者（无已确认坏人）：无可信同伴且单个贴近、且未被目击者豁免 → 按普通虾 B 档拉开距离（只回避，绝不出刀）；
+      // 多个被怀疑者互为目击者（witnessExempt）则不后撤，落到下面照常做任务。
+      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 [];
+      }
+    }
+
+    // ── 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;
+  }
+
+  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)),
+      // 行为不变（仍躲所有非 trusted）；措辞按真实身份逐个标注，免得把一起躲的被怀疑者也叫成「认定坏人」。
+      { threatRadius: Infinity, noun: (p, c) => this.isHuntTarget(p, c) ? '认定坏人' : '被怀疑者' } 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);
+  }
+}

package/src/strategies/greeting.ts

@@ -1,53 +1,53 @@
-import { Action } from '../sdk/action.js';
-import type { GameState } from '../sdk/types.js';
-import type { BehaviorDecision } from './types.js';
-import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
-import { stripRoleIds } from './player-targets.js';
-
-export const MAX_GREETING_PHRASES = 3;
-export const GREETING_COOLDOWN_MS = 120_000;
-
-/**
- * 解析「打招呼话术」启动参数：剥掉 role-id 噪声与空串，校验条数（≤3）与单条长度（≤TTS 上限）。
- * 供 task-report / corpse-patrol / shrimp-memory / paradise-fish 共用——它们的启动参数语义都是「打招呼话术」。
- *
- * @param strategyId 仅用于错误文案。
- */
-export function parseGreetingArgs(args: string[] | undefined, strategyId: string): string[] {
-  if (!args || args.length === 0) return [];
-
-  const phrases = args.map(a => stripRoleIds(a)).filter(a => a.length > 0);
-  if (phrases.length === 0) return [];
-
-  if (phrases.length > MAX_GREETING_PHRASES) {
-    throw new Error(`${strategyId} strategy accepts 0-${MAX_GREETING_PHRASES} greeting phrases (got ${phrases.length}).`);
-  }
-  for (const phrase of phrases) {
-    if (phrase.length > TTS_TEXT_MAX_LENGTH) {
-      throw new Error(`Greeting phrase too long (${phrase.length} chars, max ${TTS_TEXT_MAX_LENGTH}).`);
-    }
-  }
-  return phrases;
-}
-
-/**
- * 打招呼节流器：视野内有人时随机发一条话术，之后 GREETING_COOLDOWN_MS 内不再发。
- * 被多个编排型 Top Goal（TaskReportTop / NormalShrimpTop 等）持有复用。
- */
-export class GreetingTracker {
-  private lastGreetingAt: number | null = null;
-
-  constructor(private readonly phrases: string[]) {}
-
-  tryGreeting(state: GameState): BehaviorDecision | null {
-    if (this.phrases.length === 0) return null;
-    if (state.players.length === 0) return null;
-
-    const now = Date.now();
-    if (this.lastGreetingAt !== null && now - this.lastGreetingAt < GREETING_COOLDOWN_MS) return null;
-
-    const text = this.phrases[Math.floor(Math.random() * this.phrases.length)];
-    this.lastGreetingAt = now;
-    return { action: Action.speech(text) };
-  }
-}
+import { Action } from '../sdk/action.js';
+import type { GameState } from '../sdk/types.js';
+import type { BehaviorDecision } from './types.js';
+import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
+import { stripRoleIds } from './player-targets.js';
+
+export const MAX_GREETING_PHRASES = 3;
+export const GREETING_COOLDOWN_MS = 120_000;
+
+/**
+ * 解析「打招呼话术」启动参数：剥掉 role-id 噪声与空串，校验条数（≤3）与单条长度（≤TTS 上限）。
+ * 供 task-report / corpse-patrol / shrimp-memory / paradise-fish 共用——它们的启动参数语义都是「打招呼话术」。
+ *
+ * @param strategyId 仅用于错误文案。
+ */
+export function parseGreetingArgs(args: string[] | undefined, strategyId: string): string[] {
+  if (!args || args.length === 0) return [];
+
+  const phrases = args.map(a => stripRoleIds(a)).filter(a => a.length > 0);
+  if (phrases.length === 0) return [];
+
+  if (phrases.length > MAX_GREETING_PHRASES) {
+    throw new Error(`${strategyId} strategy accepts 0-${MAX_GREETING_PHRASES} greeting phrases (got ${phrases.length}).`);
+  }
+  for (const phrase of phrases) {
+    if (phrase.length > TTS_TEXT_MAX_LENGTH) {
+      throw new Error(`Greeting phrase too long (${phrase.length} chars, max ${TTS_TEXT_MAX_LENGTH}).`);
+    }
+  }
+  return phrases;
+}
+
+/**
+ * 打招呼节流器：视野内有人时随机发一条话术，之后 GREETING_COOLDOWN_MS 内不再发。
+ * 被多个编排型 Top Goal（TaskReportTop / NormalShrimpTop 等）持有复用。
+ */
+export class GreetingTracker {
+  private lastGreetingAt: number | null = null;
+
+  constructor(private readonly phrases: string[]) {}
+
+  tryGreeting(state: GameState): BehaviorDecision | null {
+    if (this.phrases.length === 0) return null;
+    if (state.players.length === 0) return null;
+
+    const now = Date.now();
+    if (this.lastGreetingAt !== null && now - this.lastGreetingAt < GREETING_COOLDOWN_MS) return null;
+
+    const text = this.phrases[Math.floor(Math.random() * this.phrases.length)];
+    this.lastGreetingAt = now;
+    return { action: Action.speech(text) };
+  }
+}