@myclaw163/clawclaw-cli 0.6.56 → 0.6.57

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

@@ -1,242 +1,242 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import {
-  corpseAtScene,
-  dist,
-  firstAvailableTask,
-  hasKnownCorpse,
-  isKnowledgeThreat,
-  isKnowledgeTrusted,
-  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 { GreetingTracker } from '../greeting.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
-import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
-
-const SUB_PRIORITY = 0.5;
-/** 陌生人贴近到这个距离才触发拉开（B 档入口）。 */
-const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
-/** B 档 KeepAwayGoal 的交战兼结束半径：270 进 / 300 出，天然滞回。 */
-const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
-/** 目击者记忆 TTL；0 表示只按当前轮可见玩家判断。 */
-const WITNESS_MEMORY_MS = 0;
-/** 近期见过这么多个陌生人即豁免 B 档——蟹不敢当众动手，独处单个陌生人才危险。 */
-const WITNESS_EXEMPT_COUNT = 2;
-const TASK_RETURN_INERTIA_MS = 2_000;
-const FLEE_BAD_KEY = 'shrimp-flee-bad';
-const STRANGER_KEY = 'shrimp-stranger-distance';
-
-type Tier = 'flee-bad' | 'keep-distance' | 'task';
-
-/**
- * 普通虾·记忆进阶版（好人、不带刀）的核心 Goal，按行为表逐条判断，命中即执行：
- *
- * - P0 发现尸体：一律报警（reportCorpseDecision），必要时提示 Agent 更新尸体旁玩家记忆。
- * - P1 规避危险：
- *   · A 视野里有威胁（知识库 suspect/hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
- *   · B 无可信同伴且陌生人贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
- *     目击者豁免：当前见到 ≥2 个陌生人时不触发后撤（蟹不敢当众动手，独处才危险）；
- *     进行中的后撤也会重新判定，只有仍是单陌生人危险时才拉满到 300px。豁免期间陌生人也不算任务威胁点。
- * - P2 紧急任务：无危险时优先处理。
- * - P3 否则做任务 / 巡逻（SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
- *
- * 「认定坏人」「可信同伴」全部来自 ctx.knowledge（见 shrimp-memory.knowledge.md）。
- * 队友由游戏事实判定（nonTeammatesVisible）。有可信同伴在场时不对陌生人触发 B 档。
- */
-export class NormalShrimpTop extends Goal {
-  private readonly taskGoal = new SafeTaskOrPatrolGoal(
-    // 豁免期间陌生人不算威胁点（与 B 档不触发保持视野半径对齐），认定坏人始终算。
-    (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;
-  private readonly corpseWitnessNotified = new Set<string>();
-  private readonly greeting: GreetingTracker;
-
-  constructor(greetingPhrases: string[] = []) {
-    super();
-    this.greeting = new GreetingTracker(greetingPhrases);
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    this.updateWitnessMemory(visible, ctx);
-    const decisions: BehaviorDecision[] = [];
-    const greeting = this.greeting.tryGreeting(state);
-    if (greeting) decisions.push(greeting);
-
-    // ── P0 发现尸体 → 报警 ──
-    if (hasKnownCorpse(ctx)) {
-      // 「尸体旁目击者」只在此刻确实站在命案现场（当帧视野有尸体）时才标注——否则会把后来路上
-      // 遇见的人误报成目击者。报尸本身可以追着记忆里已离开视野的尸体走回去。
-      if (corpseAtScene(state)) this.notifyCorpseWitnesses(visible, ctx);
-      else this.corpseWitnessNotified.clear();
-      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
-      if (report) {
-        this.clearSub();
-        return [report, ...decisions];
-      }
-      // 报告短暂受阻时继续执行后续分支，避免在尸体旁空站。
-    } else {
-      this.corpseWitnessNotified.clear();
-    }
-
-    // ── P1-A 视野里有认定坏人 → 寻路躲避 ──
-    const threats = visible.filter(p => this.isThreat(p, ctx));
-    if (threats.length > 0) {
-      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
-      this.setKeepAway(FLEE_BAD_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
-        threatRadius: Infinity,
-        noun: '认定坏人',
-      });
-      this.emitProgress(state, ctx, visible, 'flee-bad');
-      return decisions;
-    }
-
-    // ── P1-B 无可信同伴且陌生人贴近 → 拉开距离再做任务 ──
-    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
-    if (!trustedVisible) {
-      const you = state.you;
-      const strangerClose = visible.some(p =>
-        !this.isTrusted(p, ctx) && (p.distance ?? dist(p.x, p.y, you.x, you.y)) <= STRANGER_TRIGGER_RADIUS);
-      const worker = this.subGoal;
-      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.setKeepAway(STRANGER_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => !this.isTrusted(p, c)), {
-          threatRadius: STRANGER_RELEASE_RADIUS,
-          noun: '陌生人',
-          planOpts: { steps: 4 },
-        });
-        this.emitProgress(state, ctx, visible, 'keep-distance');
-        return decisions;
-      }
-    }
-
-    // ── P2 紧急任务 ──
-    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
-    if (emergency) {
-      this.clearSub();
-      return [taskMoveDecision(state, ctx, emergency), ...decisions];
-    }
-
-    // ── P3 兜底 → 做任务 / 巡逻 ──
-    this.clearSub();
-    const work = this.taskGoal.tick(state, ctx);
-    this.emitProgress(state, ctx, visible, 'task');
-    return [...work, ...decisions];
-  }
-
-  /**
-   * 目击者豁免：用 TTL 记忆平滑陌生人计数；当前设为 0，只看本轮可见玩家。
-   */
-  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
-    const now = Date.now();
-    for (const p of visible) {
-      if (this.isTrusted(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;
-  }
-
-  /** 威胁：知识库 suspect/hostile，且未被标记为 trusted。 */
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
-  }
-
-  /** 可信同伴：知识库 trusted。 */
-  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeTrusted(p, ctx);
-  }
-
-  private setKeepAway(key: string, resolve: ThreatResolver, options: KeepAwayGoalOptions): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === key) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(key, resolve, options), SUB_PRIORITY);
-  }
-
-  private clearSub(): void {
-    if (this.subGoal) this.removeSubGoal();
-  }
-
-  private notifyCorpseWitnesses(visible: PlayerInfo[], ctx: StrategyContext): void {
-    const bad: string[] = [];
-    const paradise: string[] = [];
-    const unknown: string[] = [];
-    const trusted: string[] = [];
-
-    for (const player of visible) {
-      const key = player.name || String(player.seat ?? '');
-      if (!key || this.corpseWitnessNotified.has(key)) continue;
-      this.corpseWitnessNotified.add(key);
-
-      if (this.isThreat(player, ctx)) bad.push(player.name);
-      else if (this.isKnownParadiseFish(player, ctx)) paradise.push(player.name);
-      else if (this.isTrusted(player, ctx)) trusted.push(player.name);
-      else unknown.push(player.name);
-    }
-
-    if (bad.length > 0) ctx.notifications.push(`尸体旁发现认定坏人${bad.join('、')}，直接报警。`);
-    if (paradise.length > 0) ctx.notifications.push(`尸体旁发现天堂鱼${paradise.join('、')}，直接报警。`);
-    if (unknown.length > 0) ctx.notifications.push(`尸体旁发现身份不明者${unknown.join('、')}，直接报警；建议将其记忆为坏人。`);
-    if (trusted.length > 0) ctx.notifications.push(`尸体旁发现可信同伴${trusted.join('、')}，仍直接报警；建议重新怀疑并复核记忆。`);
-  }
-
-  private isKnownParadiseFish(p: PlayerInfo, ctx: StrategyContext): boolean {
-    const role = ctx.knowledge?.roleOf(p);
-    return role === 'neutral_paradise_fish'
-      || role === 'paradise_fish'
-      || role === '天堂鱼'
-      || (ctx.knowledge?.hasTag(p, 'paradise_fish') ?? false);
-  }
-
-  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: Tier): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
-    const total = ctx.taskData.filter(t => t.faction !== 'crab').length;
-    const current = this.taskGoal.currentTask;
-
-    let msg = `[进度] 当前在${room}`;
-    if (tier === 'flee-bad') {
-      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
-      msg += `，发现认定坏人${names}，正在远离。`;
-    } else if (tier === 'keep-distance') {
-      msg += `，陌生人靠得太近，先拉开距离再做任务。`;
-    } else if (visible.length === 0) {
-      msg += '，附近无人，做任务/巡逻。';
-    } else if (visible.some(p => this.isTrusted(p, ctx))) {
-      msg += `，附近有可信同伴，结伴做任务。`;
-    } else if (this.witnessExempt && visible.length >= 2) {
-      msg += `，附近${visible.length}个陌生人互为目击者，照常做任务。`;
-    } else {
-      msg += `，附近有${visible.length}人，继续做任务/巡逻。`;
-    }
-    if (current) {
-      msg += ` 当前任务目标：${current.room}「${current.task_name}」。`;
-    }
-    msg += ` 已完成 ${completed}/${total} 个任务。`;
-    if (state.emergency) {
-      msg += ` 紧急任务进行中！`;
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import {
+  corpseAtScene,
+  dist,
+  firstAvailableTask,
+  hasKnownCorpse,
+  isKnowledgeThreat,
+  isKnowledgeTrusted,
+  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 { GreetingTracker } from '../greeting.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
+import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
+
+const SUB_PRIORITY = 0.5;
+/** 陌生人贴近到这个距离才触发拉开（B 档入口）。 */
+const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
+/** B 档 KeepAwayGoal 的交战兼结束半径：270 进 / 300 出，天然滞回。 */
+const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
+/** 目击者记忆 TTL；0 表示只按当前轮可见玩家判断。 */
+const WITNESS_MEMORY_MS = 0;
+/** 近期见过这么多个陌生人即豁免 B 档——蟹不敢当众动手，独处单个陌生人才危险。 */
+const WITNESS_EXEMPT_COUNT = 2;
+const TASK_RETURN_INERTIA_MS = 2_000;
+const FLEE_BAD_KEY = 'shrimp-flee-bad';
+const STRANGER_KEY = 'shrimp-stranger-distance';
+
+type Tier = 'flee-bad' | 'keep-distance' | 'task';
+
+/**
+ * 普通虾·记忆进阶版（好人、不带刀）的核心 Goal，按行为表逐条判断，命中即执行：
+ *
+ * - P0 发现尸体：一律报警（reportCorpseDecision），必要时提示 Agent 更新尸体旁玩家记忆。
+ * - P1 规避危险：
+ *   · A 视野里有威胁（知识库 suspect/hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
+ *   · B 无可信同伴且陌生人贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
+ *     目击者豁免：当前见到 ≥2 个陌生人时不触发后撤（蟹不敢当众动手，独处才危险）；
+ *     进行中的后撤也会重新判定，只有仍是单陌生人危险时才拉满到 300px。豁免期间陌生人也不算任务威胁点。
+ * - P2 紧急任务：无危险时优先处理。
+ * - P3 否则做任务 / 巡逻（SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
+ *
+ * 「认定坏人」「可信同伴」全部来自 ctx.knowledge（见 shrimp-memory.knowledge.md）。
+ * 队友由游戏事实判定（nonTeammatesVisible）。有可信同伴在场时不对陌生人触发 B 档。
+ */
+export class NormalShrimpTop extends Goal {
+  private readonly taskGoal = new SafeTaskOrPatrolGoal(
+    // 豁免期间陌生人不算威胁点（与 B 档不触发保持视野半径对齐），认定坏人始终算。
+    (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;
+  private readonly corpseWitnessNotified = new Set<string>();
+  private readonly greeting: GreetingTracker;
+
+  constructor(greetingPhrases: string[] = []) {
+    super();
+    this.greeting = new GreetingTracker(greetingPhrases);
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    this.updateWitnessMemory(visible, ctx);
+    const decisions: BehaviorDecision[] = [];
+    const greeting = this.greeting.tryGreeting(state);
+    if (greeting) decisions.push(greeting);
+
+    // ── P0 发现尸体 → 报警 ──
+    if (hasKnownCorpse(ctx)) {
+      // 「尸体旁目击者」只在此刻确实站在命案现场（当帧视野有尸体）时才标注——否则会把后来路上
+      // 遇见的人误报成目击者。报尸本身可以追着记忆里已离开视野的尸体走回去。
+      if (corpseAtScene(state)) this.notifyCorpseWitnesses(visible, ctx);
+      else this.corpseWitnessNotified.clear();
+      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
+      if (report) {
+        this.clearSub();
+        return [report, ...decisions];
+      }
+      // 报告短暂受阻时继续执行后续分支，避免在尸体旁空站。
+    } else {
+      this.corpseWitnessNotified.clear();
+    }
+
+    // ── P1-A 视野里有认定坏人 → 寻路躲避 ──
+    const threats = visible.filter(p => this.isThreat(p, ctx));
+    if (threats.length > 0) {
+      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+      this.setKeepAway(FLEE_BAD_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
+        threatRadius: Infinity,
+        noun: '认定坏人',
+      });
+      this.emitProgress(state, ctx, visible, 'flee-bad');
+      return decisions;
+    }
+
+    // ── P1-B 无可信同伴且陌生人贴近 → 拉开距离再做任务 ──
+    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
+    if (!trustedVisible) {
+      const you = state.you;
+      const strangerClose = visible.some(p =>
+        !this.isTrusted(p, ctx) && (p.distance ?? dist(p.x, p.y, you.x, you.y)) <= STRANGER_TRIGGER_RADIUS);
+      const worker = this.subGoal;
+      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.setKeepAway(STRANGER_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => !this.isTrusted(p, c)), {
+          threatRadius: STRANGER_RELEASE_RADIUS,
+          noun: '陌生人',
+          planOpts: { steps: 4 },
+        });
+        this.emitProgress(state, ctx, visible, 'keep-distance');
+        return decisions;
+      }
+    }
+
+    // ── P2 紧急任务 ──
+    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
+    if (emergency) {
+      this.clearSub();
+      return [taskMoveDecision(state, ctx, emergency), ...decisions];
+    }
+
+    // ── P3 兜底 → 做任务 / 巡逻 ──
+    this.clearSub();
+    const work = this.taskGoal.tick(state, ctx);
+    this.emitProgress(state, ctx, visible, 'task');
+    return [...work, ...decisions];
+  }
+
+  /**
+   * 目击者豁免：用 TTL 记忆平滑陌生人计数；当前设为 0，只看本轮可见玩家。
+   */
+  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
+    const now = Date.now();
+    for (const p of visible) {
+      if (this.isTrusted(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;
+  }
+
+  /** 威胁：知识库 suspect/hostile，且未被标记为 trusted。 */
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  }
+
+  /** 可信同伴：知识库 trusted。 */
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  private setKeepAway(key: string, resolve: ThreatResolver, options: KeepAwayGoalOptions): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === key) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(key, resolve, options), SUB_PRIORITY);
+  }
+
+  private clearSub(): void {
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  private notifyCorpseWitnesses(visible: PlayerInfo[], ctx: StrategyContext): void {
+    const bad: string[] = [];
+    const paradise: string[] = [];
+    const unknown: string[] = [];
+    const trusted: string[] = [];
+
+    for (const player of visible) {
+      const key = player.name || String(player.seat ?? '');
+      if (!key || this.corpseWitnessNotified.has(key)) continue;
+      this.corpseWitnessNotified.add(key);
+
+      if (this.isThreat(player, ctx)) bad.push(player.name);
+      else if (this.isKnownParadiseFish(player, ctx)) paradise.push(player.name);
+      else if (this.isTrusted(player, ctx)) trusted.push(player.name);
+      else unknown.push(player.name);
+    }
+
+    if (bad.length > 0) ctx.notifications.push(`尸体旁发现认定坏人${bad.join('、')}，直接报警。`);
+    if (paradise.length > 0) ctx.notifications.push(`尸体旁发现天堂鱼${paradise.join('、')}，直接报警。`);
+    if (unknown.length > 0) ctx.notifications.push(`尸体旁发现身份不明者${unknown.join('、')}，直接报警；建议将其记忆为坏人。`);
+    if (trusted.length > 0) ctx.notifications.push(`尸体旁发现可信同伴${trusted.join('、')}，仍直接报警；建议重新怀疑并复核记忆。`);
+  }
+
+  private isKnownParadiseFish(p: PlayerInfo, ctx: StrategyContext): boolean {
+    const role = ctx.knowledge?.roleOf(p);
+    return role === 'neutral_paradise_fish'
+      || role === 'paradise_fish'
+      || role === '天堂鱼'
+      || (ctx.knowledge?.hasTag(p, 'paradise_fish') ?? false);
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: Tier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const completed = ctx.taskData.filter(t => t.status === 'completed').length;
+    const total = ctx.taskData.filter(t => t.faction !== 'crab').length;
+    const current = this.taskGoal.currentTask;
+
+    let msg = `[进度] 当前在${room}`;
+    if (tier === 'flee-bad') {
+      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
+      msg += `，发现认定坏人${names}，正在远离。`;
+    } else if (tier === 'keep-distance') {
+      msg += `，陌生人靠得太近，先拉开距离再做任务。`;
+    } else if (visible.length === 0) {
+      msg += '，附近无人，做任务/巡逻。';
+    } else if (visible.some(p => this.isTrusted(p, ctx))) {
+      msg += `，附近有可信同伴，结伴做任务。`;
+    } else if (this.witnessExempt && visible.length >= 2) {
+      msg += `，附近${visible.length}个陌生人互为目击者，照常做任务。`;
+    } else {
+      msg += `，附近有${visible.length}人，继续做任务/巡逻。`;
+    }
+    if (current) {
+      msg += ` 当前任务目标：${current.room}「${current.task_name}」。`;
+    }
+    msg += ` 已完成 ${completed}/${total} 个任务。`;
+    if (state.emergency) {
+      msg += ` 紧急任务进行中！`;
+    }
+    ctx.notifications.push(msg);
+  }
+}