@myclaw163/clawclaw-cli 0.6.58 → 0.6.60

package/src/strategies/goals/crab-octopus-reflexes.ts

@@ -1,93 +1,93 @@
-import type { GameState } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  canUseKill,
-  corpseAtScene,
-  dist,
-  killCommitRange,
-  nearestReportableCorpse,
-  nonTeammatesVisible,
-  reportCorpseDecision,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-
-/**
- * 蟹（坏人）/ 章鱼（中立带刀）默认策略共享的「反射动作」——由 CrabSabotageTop 与 LoneKillTaskTop
- * 在各自 tick() 的**最前面**调用，抢在破坏/任务/落单猎杀编排之前先处理两类即时机会：
- *
- * - immediateLoneKillDecision：唯一一个落单非队友就贴在脸上(出刀范围内)且刀好 → 立刻出刀。它无视
- *   LoneKillCore 的「暂停窗口」，也不管自己是否正在做破坏任务——只要能原地一刀就先杀。
- * - corpseReportWithNonTeammate：地上有尸体且附近有非队友 → 报警（够不着先靠近）。不管尸体是谁
- *   造成的（含队友的杀），靠主动报警伪装好人 / 把嫌疑栽到在场者身上。
- *
- * 调用方按「能贴脸杀就杀，否则报警」的次序：先 immediateLoneKillDecision 再 corpseReportWithNonTeammate。
- * 两者都**无记忆**（不读 ctx.knowledge），与默认蟹/章鱼对任意落单非队友照杀的设定一致；蟹/章鱼目前
- * 没有记忆版策略，故没有「点名/保护」入口。
- */
-
-/** 有尸体且附近有非队友 → 报警/靠近报警；否则 null。respectBlock 防止 5s 内重复报。 */
-export function corpseReportWithNonTeammate(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
-  // 报尸自证/嫁祸是「此刻就在尸体旁、有人撞见」的现场反射，必须用当帧视野的尸体；用持久记忆会让
-  // 蟹/章鱼在地图别处随便撞见一个人就生成错误的栽赃简报。
-  if (!corpseAtScene(state)) return null;
-  const witnesses = nonTeammatesVisible(state, ctx);
-  if (witnesses.length === 0) return null;
-
-  const report = reportCorpseDecision(state, ctx, { respectBlock: true });
-  if (!report) return null;
-
-  const witnessNames = witnesses.map(p => p.name).join('、');
-  if (report.action.type === 'report') {
-    // 实时给 Agent 一条「为什么是我报的尸」简报：报尸=召集会议，是高风险自证动作。
-    // 若尸体很可能是自己刚才下的那一刀，必须显式提醒，免得 Agent 之后发言露馅。
-    const corpseName = nearestReportableCorpse(state)?.name ?? '';
-    ctx.agentAlerts.push(
-      isRecentOwnKill(ctx, corpseName)
-        ? `我刚下手的目标${corpseName ? `（${corpseName}）` : ''}尸体被${witnessNames}撞见，我抢先报尸召集会议、把自己装成发现者并把嫌疑引向在场者。接下来发言/投票要顺着「我是主动报告的人」走，绝不能承认是自己动的手。`
-        : `尸体旁有${witnessNames}在场，我抢先报尸召集会议、伪装成主动报告的好人。发言时按「主动报告的发现者」立场走。`,
-    );
-    ctx.notifications.push(`尸体旁有${witnessNames}在场，立刻报告自证。`);
-    const base = report.action.thinkingContent ?? '发现尸体，报告召开会议';
-    return [{
-      action: report.action.withThinking(`${base}；尸体旁有${witnessNames}在场，立刻报告自证。`),
-    }];
-  }
-  ctx.notifications.push(`尸体旁有${witnessNames}在场，靠近尸体准备报告自证。`);
-  return [{
-    action: report.action.withThinking(`尸体旁有${witnessNames}在场，靠近尸体准备报告自证。`),
-  }];
-}
-
-/** 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
-export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
-  if (!canUseKill(state)) return null;
-
-  const targets = nonTeammatesVisible(state, ctx);
-  if (targets.length !== 1) return null;
-
-  const target = targets[0];
-  const distance = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-  if (distance > killCommitRange(state.you.role)) return null;
-
-  ctx.notifications.push(`发现落单目标${target.name}就在身边，立刻出刀！`);
-  return [{ action: Action.kill(target.name) }];
-}
-
-/**
- * 这具尸体是不是「自己刚才下的那一刀」。先按尸体名精确匹配 recentlyKilledTargets（刚杀过且未过期），
- * 名字对不上但近期确实杀过人时，冒出的尸体大概率也是自己造成的，按 true 处理（宁可多提醒一次）。
- */
-function isRecentOwnKill(ctx: StrategyContext, corpseName: string): boolean {
-  const map = ctx.recentlyKilledTargets;
-  if (!map || map.size === 0) return false;
-  const now = Date.now();
-  const key = corpseName.trim().toLowerCase();
-  if (key) {
-    const until = map.get(key);
-    if (until != null && until > now) return true;
-  }
-  for (const until of map.values()) {
-    if (until > now) return true;
-  }
-  return false;
-}
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  corpseAtScene,
+  dist,
+  killCommitRange,
+  nearestReportableCorpse,
+  nonTeammatesVisible,
+  reportCorpseDecision,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+
+/**
+ * 蟹（坏人）/ 章鱼（中立带刀）默认策略共享的「反射动作」——由 CrabSabotageTop 与 LoneKillTaskTop
+ * 在各自 tick() 的**最前面**调用，抢在破坏/任务/落单猎杀编排之前先处理两类即时机会：
+ *
+ * - immediateLoneKillDecision：唯一一个落单非队友就贴在脸上(出刀范围内)且刀好 → 立刻出刀。它无视
+ *   LoneKillCore 的「暂停窗口」，也不管自己是否正在做破坏任务——只要能原地一刀就先杀。
+ * - corpseReportWithNonTeammate：地上有尸体且附近有非队友 → 报警（够不着先靠近）。不管尸体是谁
+ *   造成的（含队友的杀），靠主动报警伪装好人 / 把嫌疑栽到在场者身上。
+ *
+ * 调用方按「能贴脸杀就杀，否则报警」的次序：先 immediateLoneKillDecision 再 corpseReportWithNonTeammate。
+ * 两者都**无记忆**（不读 ctx.knowledge），与默认蟹/章鱼对任意落单非队友照杀的设定一致；蟹/章鱼目前
+ * 没有记忆版策略，故没有「点名/保护」入口。
+ */
+
+/** 有尸体且附近有非队友 → 报警/靠近报警；否则 null。respectBlock 防止 5s 内重复报。 */
+export function corpseReportWithNonTeammate(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+  // 报尸自证/嫁祸是「此刻就在尸体旁、有人撞见」的现场反射，必须用当帧视野的尸体；用持久记忆会让
+  // 蟹/章鱼在地图别处随便撞见一个人就生成错误的栽赃简报。
+  if (!corpseAtScene(state)) return null;
+  const witnesses = nonTeammatesVisible(state, ctx);
+  if (witnesses.length === 0) return null;
+
+  const report = reportCorpseDecision(state, ctx, { respectBlock: true });
+  if (!report) return null;
+
+  const witnessNames = witnesses.map(p => p.name).join('、');
+  if (report.action.type === 'report') {
+    // 实时给 Agent 一条「为什么是我报的尸」简报：报尸=召集会议，是高风险自证动作。
+    // 若尸体很可能是自己刚才下的那一刀，必须显式提醒，免得 Agent 之后发言露馅。
+    const corpseName = nearestReportableCorpse(state)?.name ?? '';
+    ctx.agentAlerts.push(
+      isRecentOwnKill(ctx, corpseName)
+        ? `我刚下手的目标${corpseName ? `（${corpseName}）` : ''}尸体被${witnessNames}撞见，我抢先报尸召集会议、把自己装成发现者并把嫌疑引向在场者。接下来发言/投票要顺着「我是主动报告的人」走，绝不能承认是自己动的手。`
+        : `尸体旁有${witnessNames}在场，我抢先报尸召集会议、伪装成主动报告的好人。发言时按「主动报告的发现者」立场走。`,
+    );
+    ctx.notifications.push(`尸体旁有${witnessNames}在场，立刻报告自证。`);
+    const base = report.action.thinkingContent ?? '发现尸体，报告召开会议';
+    return [{
+      action: report.action.withThinking(`${base}；尸体旁有${witnessNames}在场，立刻报告自证。`),
+    }];
+  }
+  ctx.notifications.push(`尸体旁有${witnessNames}在场，靠近尸体准备报告自证。`);
+  return [{
+    action: report.action.withThinking(`尸体旁有${witnessNames}在场，靠近尸体准备报告自证。`),
+  }];
+}
+
+/** 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
+export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+  if (!canUseKill(state)) return null;
+
+  const targets = nonTeammatesVisible(state, ctx);
+  if (targets.length !== 1) return null;
+
+  const target = targets[0];
+  const distance = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
+  if (distance > killCommitRange(state.you.role)) return null;
+
+  ctx.notifications.push(`发现落单目标${target.name}就在身边，立刻出刀！`);
+  return [{ action: Action.kill(target.name) }];
+}
+
+/**
+ * 这具尸体是不是「自己刚才下的那一刀」。先按尸体名精确匹配 recentlyKilledTargets（刚杀过且未过期），
+ * 名字对不上但近期确实杀过人时，冒出的尸体大概率也是自己造成的，按 true 处理（宁可多提醒一次）。
+ */
+function isRecentOwnKill(ctx: StrategyContext, corpseName: string): boolean {
+  const map = ctx.recentlyKilledTargets;
+  if (!map || map.size === 0) return false;
+  const now = Date.now();
+  const key = corpseName.trim().toLowerCase();
+  if (key) {
+    const until = map.get(key);
+    if (until != null && until > now) return true;
+  }
+  for (const until of map.values()) {
+    if (until > now) return true;
+  }
+  return false;
+}

package/src/strategies/goals/crab-sabotage-top.ts

@@ -1,197 +1,197 @@
-import type { GameState, TaskInfo } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import {
-  approachOrDoTaskStep,
-  firstAvailableTask,
-  killCooldownSecs,
-  nonTeammatesVisible,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { LoneKillCore } from './lone-kill-core.js';
-import { LoneKillGoal } from './lone-kill-goal.js';
-import { WanderTaskGoal } from './wander-task-goal.js';
-import { EmergencyHuntGoal } from './emergency-hunt-goal.js';
-import { emitLeaf, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
-import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
-
-const SABOTAGE_ALARM_DEDUPE_MS = 90_000;
-
-/**
- * 蟹的「破坏 + 落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 自上而下判定该走哪条分支、
- * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子；URGENT/WANDER 优先级供 ConversationGoal 判断）：
- *
- * 0a. 反射·立刻出刀（crab-octopus-reflexes，URGENT）：落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀，
- *     无视暂停窗口、不管自己是否正在做破坏任务。
- * 0b. 反射·报尸（crab-octopus-reflexes，URGENT）：有尸体且附近有非队友 → 报警/靠近报警，不管尸体是谁造成的。
- * 1a. 破坏完成 → 触发紧急警报（一次性动作，LeafGoal 承载，URGENT）。
- * 1b. 去做真实破坏任务（到点遇阻返回 null → 回退去猎杀，故 LeafGoal 承载，WANDER）；破坏点紧挨已知尸体时跳过。
- * 1c. 正在做任务（doing_task）→ 本 tick 不产决策，不撇下任务去猎杀（0a 的贴脸反射刀仍生效）。
- * 2.  落单猎杀（LoneKillGoal，URGENT）：assess 判 hunt（刀好且有落单目标）→ 叶子 pursue；
- *     刀在冷却时 assess 返回 idle，不追不等，直接下沉到破坏/任务/巡逻。
- * 3.  紧急期搜猎（EmergencyHuntGoal，URGENT）：往人少处找真正落单的，永远有动作（不在人前乱杀）。
- * 4.  任务伪装 / 巡逻（WanderTaskGoal，WANDER）：先真实任务再虾的伪装任务，跳过紧挨已知尸体的任务，没任务就巡逻。
- */
-export class CrabSabotageTop extends Goal {
-  private readonly killCore = new LoneKillCore();
-  private readonly patrol = new PatrolState();
-  private readonly triggeredSabotageTasks = new Map<string, { at: number; tick: number | null }>();
-  private readonly loneKillGoal = new LoneKillGoal(this.killCore);
-  private readonly emergencyHuntGoal = new EmergencyHuntGoal(this.killCore, this.patrol);
-  private readonly wanderGoal = new WanderTaskGoal(
-    (state, ctx) =>
-      firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses)
-      ?? firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !!t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses),
-    () => this.killCore.patrolStopOnPlayer(),
-    this.patrol,
-  );
-
-  onMeetingResume(): void {
-    this.killCore.reset();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    this.emitProgress(state, ctx);
-
-    const immediateKill = immediateLoneKillDecision(state, ctx);
-    if (immediateKill) return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
-
-    const corpseReport = corpseReportWithNonTeammate(state, ctx);
-    if (corpseReport) return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
-
-    // 1a. 破坏完成 → 触发紧急警报（紧急一次性动作）
-    const alarm = this.trySabotageAlarm(state, ctx);
-    if (alarm) return emitLeaf(this, alarm, URGENT_GOAL_PRIORITY);
-
-    // 1b. 去做真实破坏任务（游走类工作；到点遇阻返回 null → 下沉去猎杀，故可回退）
-    const crabTask = this.tryCrabTask(state, ctx);
-    if (crabTask) return emitLeaf(this, crabTask, WANDER_GOAL_PRIORITY);
-
-    if (state.you.doing_task) {
-      if (this.subGoal) this.removeSubGoal();
-      return [];
-    }
-
-    // 2. 落单猎杀（紧急；紧急期 bypass 暂停窗口持续盯防）
-    const target = this.killCore.assess(state, ctx, { bypassIgnoreWindow: !!ctx.emergency });
-    if (target.kind === 'hunt') {
-      this.loneKillGoal.setTarget(target.target);
-      return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
-    }
-
-    // 3. 紧急期搜猎（紧急）：虾群涌向维修点，蟹不做任务，往人少处找真正落单的（警报期照样会被举报，不在人前乱杀）
-    if (ctx.emergency) return setBehavior(this, this.emergencyHuntGoal, URGENT_GOAL_PRIORITY);
-
-    // 4. 任务伪装 / 巡逻（游走）
-    return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
-  }
-
-  // ── 1a. 破坏完成 → 触发紧急警报 ──
-  private trySabotageAlarm(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
-    if (state.you.faction !== 'crab') return null;
-    if (ctx.emergency) return null;
-
-    const now = Date.now();
-    const completed = ctx.taskData.find(t =>
-      t.faction === 'crab'
-      && !t.is_fake_shrimp
-      && t.status === 'completed'
-      && this.shouldTriggerSabotageAlarm(t, state, now),
-    );
-    if (completed && !state.you.doing_task) {
-      this.markSabotageTriggered(completed, state, now);
-      ctx.alarmDone = true;
-      ctx.notifications.push('破坏任务完成，开启紧急警报！警报期照样会被举报，只清落单目标。');
-      return [{ action: Action.triggerAlarm() }];
-    }
-    return null;
-  }
-
-  // ── 1b. 去做真实破坏任务（破坏点紧挨已知尸体时跳过；到点遇阻返回 null，让上层回退去猎杀）──
-  private tryCrabTask(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
-    if (state.you.faction !== 'crab') return null;
-    if (ctx.emergency) return null;
-    if (state.you.doing_task) return null;
-
-    const task = firstAvailableTask(
-      ctx.taskData,
-      t => t.faction === 'crab' && !t.is_fake_shrimp,
-      undefined,
-      ctx.blockedMoveTarget,
-      ctx.knownCorpses,
-    );
-    if (task) return approachOrDoTaskStep(state, ctx, task, false);
-    return null;
-  }
-
-  private isWorkableTask(task: TaskInfo): boolean {
-    return task.status !== 'emergency';
-  }
-
-  // ── 破坏警报去重（自旧实现原样保留）──
-
-  private sabotageTaskKey(task: TaskInfo): string {
-    const x = task.x == null ? '' : Math.round(task.x);
-    const y = task.y == null ? '' : Math.round(task.y);
-    return `${task.task_id || task.task_name}:${x}:${y}`;
-  }
-
-  private shouldTriggerSabotageAlarm(task: TaskInfo, state: GameState, now: number): boolean {
-    const record = this.triggeredSabotageTasks.get(this.sabotageTaskKey(task));
-    if (!record) return true;
-    if (now - record.at < SABOTAGE_ALARM_DEDUPE_MS) return false;
-    return this.hasFreshSabotageEvent(task, state, record.tick);
-  }
-
-  private markSabotageTriggered(task: TaskInfo, state: GameState, now: number): void {
-    this.triggeredSabotageTasks.set(this.sabotageTaskKey(task), {
-      at: now,
-      tick: this.numericTick(state.tick),
-    });
-  }
-
-  private hasFreshSabotageEvent(task: TaskInfo, state: GameState, lastTriggeredTick: number | null): boolean {
-    const taskNames = new Set([task.task_id, task.task_name].filter(Boolean));
-    return (state.new_events ?? []).some(evt => {
-      if (evt?.type !== 'task_sabotaged') return false;
-      const eventTick = this.numericTick(evt.tick);
-      if (lastTriggeredTick != null && eventTick != null && eventTick <= lastTriggeredTick) return false;
-      const eventTaskName = typeof evt.task_name === 'string' ? evt.task_name : '';
-      return taskNames.has(eventTaskName);
-    });
-  }
-
-  private numericTick(value: unknown): number | null {
-    return typeof value === 'number' && Number.isFinite(value) ? value : null;
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext): 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;
-    const nonTeammates = nonTeammatesVisible(state, ctx);
-
-    let msg = `[进度] 当前在${room}`;
-    if (nonTeammates.length === 0) {
-      msg += '，视野内没有落单目标，继续巡逻做任务。';
-    } else if (nonTeammates.length === 1) {
-      msg += `，视野内发现落单目标${nonTeammates[0].name}。`;
-      if (cd > 0) msg += `攻击冷却中(${cd}s)，先做任务、冷却好再下手。`;
-      if (killsRemaining === 0) msg += '出刀次数已用完，继续巡逻做任务。';
-    } else {
-      msg += `，视野内有${nonTeammates.length}人，不适合动手。`;
-    }
-
-    if (state.emergency) {
-      msg += ' 紧急警报进行中，往人少处找真正落单的目标，别在人前动手。';
-    }
-
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  approachOrDoTaskStep,
+  firstAvailableTask,
+  killCooldownSecs,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { LoneKillCore } from './lone-kill-core.js';
+import { LoneKillGoal } from './lone-kill-goal.js';
+import { WanderTaskGoal } from './wander-task-goal.js';
+import { EmergencyHuntGoal } from './emergency-hunt-goal.js';
+import { emitLeaf, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
+import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
+
+const SABOTAGE_ALARM_DEDUPE_MS = 90_000;
+
+/**
+ * 蟹的「破坏 + 落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 自上而下判定该走哪条分支、
+ * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子；URGENT/WANDER 优先级供 ConversationGoal 判断）：
+ *
+ * 0a. 反射·立刻出刀（crab-octopus-reflexes，URGENT）：落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀，
+ *     无视暂停窗口、不管自己是否正在做破坏任务。
+ * 0b. 反射·报尸（crab-octopus-reflexes，URGENT）：有尸体且附近有非队友 → 报警/靠近报警，不管尸体是谁造成的。
+ * 1a. 破坏完成 → 触发紧急警报（一次性动作，LeafGoal 承载，URGENT）。
+ * 1b. 去做真实破坏任务（到点遇阻返回 null → 回退去猎杀，故 LeafGoal 承载，WANDER）；破坏点紧挨已知尸体时跳过。
+ * 1c. 正在做任务（doing_task）→ 本 tick 不产决策，不撇下任务去猎杀（0a 的贴脸反射刀仍生效）。
+ * 2.  落单猎杀（LoneKillGoal，URGENT）：assess 判 hunt（刀好且有落单目标）→ 叶子 pursue；
+ *     刀在冷却时 assess 返回 idle，不追不等，直接下沉到破坏/任务/巡逻。
+ * 3.  紧急期搜猎（EmergencyHuntGoal，URGENT）：往人少处找真正落单的，永远有动作（不在人前乱杀）。
+ * 4.  任务伪装 / 巡逻（WanderTaskGoal，WANDER）：先真实任务再虾的伪装任务，跳过紧挨已知尸体的任务，没任务就巡逻。
+ */
+export class CrabSabotageTop extends Goal {
+  private readonly killCore = new LoneKillCore();
+  private readonly patrol = new PatrolState();
+  private readonly triggeredSabotageTasks = new Map<string, { at: number; tick: number | null }>();
+  private readonly loneKillGoal = new LoneKillGoal(this.killCore);
+  private readonly emergencyHuntGoal = new EmergencyHuntGoal(this.killCore, this.patrol);
+  private readonly wanderGoal = new WanderTaskGoal(
+    (state, ctx) =>
+      firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses)
+      ?? firstAvailableTask(ctx.taskData, t => this.isWorkableTask(t) && !!t.is_fake_shrimp, undefined, ctx.blockedMoveTarget, ctx.knownCorpses),
+    () => this.killCore.patrolStopOnPlayer(),
+    this.patrol,
+  );
+
+  onMeetingResume(): void {
+    this.killCore.reset();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    this.emitProgress(state, ctx);
+
+    const immediateKill = immediateLoneKillDecision(state, ctx);
+    if (immediateKill) return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+
+    const corpseReport = corpseReportWithNonTeammate(state, ctx);
+    if (corpseReport) return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+
+    // 1a. 破坏完成 → 触发紧急警报（紧急一次性动作）
+    const alarm = this.trySabotageAlarm(state, ctx);
+    if (alarm) return emitLeaf(this, alarm, URGENT_GOAL_PRIORITY);
+
+    // 1b. 去做真实破坏任务（游走类工作；到点遇阻返回 null → 下沉去猎杀，故可回退）
+    const crabTask = this.tryCrabTask(state, ctx);
+    if (crabTask) return emitLeaf(this, crabTask, WANDER_GOAL_PRIORITY);
+
+    if (state.you.doing_task) {
+      if (this.subGoal) this.removeSubGoal();
+      return [];
+    }
+
+    // 2. 落单猎杀（紧急；紧急期 bypass 暂停窗口持续盯防）
+    const target = this.killCore.assess(state, ctx, { bypassIgnoreWindow: !!ctx.emergency });
+    if (target.kind === 'hunt') {
+      this.loneKillGoal.setTarget(target.target);
+      return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
+    }
+
+    // 3. 紧急期搜猎（紧急）：虾群涌向维修点，蟹不做任务，往人少处找真正落单的（警报期照样会被举报，不在人前乱杀）
+    if (ctx.emergency) return setBehavior(this, this.emergencyHuntGoal, URGENT_GOAL_PRIORITY);
+
+    // 4. 任务伪装 / 巡逻（游走）
+    return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
+  }
+
+  // ── 1a. 破坏完成 → 触发紧急警报 ──
+  private trySabotageAlarm(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+    if (state.you.faction !== 'crab') return null;
+    if (ctx.emergency) return null;
+
+    const now = Date.now();
+    const completed = ctx.taskData.find(t =>
+      t.faction === 'crab'
+      && !t.is_fake_shrimp
+      && t.status === 'completed'
+      && this.shouldTriggerSabotageAlarm(t, state, now),
+    );
+    if (completed && !state.you.doing_task) {
+      this.markSabotageTriggered(completed, state, now);
+      ctx.alarmDone = true;
+      ctx.notifications.push('破坏任务完成，开启紧急警报！警报期照样会被举报，只清落单目标。');
+      return [{ action: Action.triggerAlarm() }];
+    }
+    return null;
+  }
+
+  // ── 1b. 去做真实破坏任务（破坏点紧挨已知尸体时跳过；到点遇阻返回 null，让上层回退去猎杀）──
+  private tryCrabTask(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+    if (state.you.faction !== 'crab') return null;
+    if (ctx.emergency) return null;
+    if (state.you.doing_task) return null;
+
+    const task = firstAvailableTask(
+      ctx.taskData,
+      t => t.faction === 'crab' && !t.is_fake_shrimp,
+      undefined,
+      ctx.blockedMoveTarget,
+      ctx.knownCorpses,
+    );
+    if (task) return approachOrDoTaskStep(state, ctx, task, false);
+    return null;
+  }
+
+  private isWorkableTask(task: TaskInfo): boolean {
+    return task.status !== 'emergency';
+  }
+
+  // ── 破坏警报去重（自旧实现原样保留）──
+
+  private sabotageTaskKey(task: TaskInfo): string {
+    const x = task.x == null ? '' : Math.round(task.x);
+    const y = task.y == null ? '' : Math.round(task.y);
+    return `${task.task_id || task.task_name}:${x}:${y}`;
+  }
+
+  private shouldTriggerSabotageAlarm(task: TaskInfo, state: GameState, now: number): boolean {
+    const record = this.triggeredSabotageTasks.get(this.sabotageTaskKey(task));
+    if (!record) return true;
+    if (now - record.at < SABOTAGE_ALARM_DEDUPE_MS) return false;
+    return this.hasFreshSabotageEvent(task, state, record.tick);
+  }
+
+  private markSabotageTriggered(task: TaskInfo, state: GameState, now: number): void {
+    this.triggeredSabotageTasks.set(this.sabotageTaskKey(task), {
+      at: now,
+      tick: this.numericTick(state.tick),
+    });
+  }
+
+  private hasFreshSabotageEvent(task: TaskInfo, state: GameState, lastTriggeredTick: number | null): boolean {
+    const taskNames = new Set([task.task_id, task.task_name].filter(Boolean));
+    return (state.new_events ?? []).some(evt => {
+      if (evt?.type !== 'task_sabotaged') return false;
+      const eventTick = this.numericTick(evt.tick);
+      if (lastTriggeredTick != null && eventTick != null && eventTick <= lastTriggeredTick) return false;
+      const eventTaskName = typeof evt.task_name === 'string' ? evt.task_name : '';
+      return taskNames.has(eventTaskName);
+    });
+  }
+
+  private numericTick(value: unknown): number | null {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext): 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;
+    const nonTeammates = nonTeammatesVisible(state, ctx);
+
+    let msg = `[进度] 当前在${room}`;
+    if (nonTeammates.length === 0) {
+      msg += '，视野内没有落单目标，继续巡逻做任务。';
+    } else if (nonTeammates.length === 1) {
+      msg += `，视野内发现落单目标${nonTeammates[0].name}。`;
+      if (cd > 0) msg += `攻击冷却中(${cd}s)，先做任务、冷却好再下手。`;
+      if (killsRemaining === 0) msg += '出刀次数已用完，继续巡逻做任务。';
+    } else {
+      msg += `，视野内有${nonTeammates.length}人，不适合动手。`;
+    }
+
+    if (state.emergency) {
+      msg += ' 紧急警报进行中，往人少处找真正落单的目标，别在人前动手。';
+    }
+
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/emergency-hunt-goal.ts

@@ -1,28 +1,28 @@
-import type { GameState } from '../../sdk/types.js';
-import { Action } from '../../sdk/action.js';
-import { nonTeammatesVisible, patrolStep, PatrolState, roomAwayFromPlayers } from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import type { LoneKillCore } from './lone-kill-core.js';
-
-/**
- * 紧急（自己触发破坏警报）期间的搜猎子目标（叶子，由上层以 URGENT 优先级挂载）：虾群涌向维修点，
- * 蟹不做任务，朝人少方向走去抓真正掉队的——警报期杀人照样会被举报，所以不在人前乱杀、只清落单；
- * 看不到非队友就按房间游走搜寻。永远有动作。
- * stop_on_player 复用 core.patrolStopOnPlayer()（身边只有队友时别撞着队友停下）。
- */
-export class EmergencyHuntGoal extends Goal {
-  constructor(
-    private readonly core: LoneKillCore,
-    private readonly patrol: PatrolState,
-  ) {
-    super();
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const crowd = nonTeammatesVisible(state, ctx);
-    const room = roomAwayFromPlayers(state, ctx, crowd);
-    if (room) return [{ action: Action.move({ x: room.x, y: room.y }, false) }];
-    return patrolStep(state, ctx, this.patrol, this.core.patrolStopOnPlayer());
-  }
-}
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import { nonTeammatesVisible, patrolStep, PatrolState, roomAwayFromPlayers } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import type { LoneKillCore } from './lone-kill-core.js';
+
+/**
+ * 紧急（自己触发破坏警报）期间的搜猎子目标（叶子，由上层以 URGENT 优先级挂载）：虾群涌向维修点，
+ * 蟹不做任务，朝人少方向走去抓真正掉队的——警报期杀人照样会被举报，所以不在人前乱杀、只清落单；
+ * 看不到非队友就按房间游走搜寻。永远有动作。
+ * stop_on_player 复用 core.patrolStopOnPlayer()（身边只有队友时别撞着队友停下）。
+ */
+export class EmergencyHuntGoal extends Goal {
+  constructor(
+    private readonly core: LoneKillCore,
+    private readonly patrol: PatrolState,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const crowd = nonTeammatesVisible(state, ctx);
+    const room = roomAwayFromPlayers(state, ctx, crowd);
+    if (room) return [{ action: Action.move({ x: room.x, y: room.y }, false) }];
+    return patrolStep(state, ctx, this.patrol, this.core.patrolStopOnPlayer());
+  }
+}