@myclaw163/clawclaw-cli 0.6.65 → 0.6.66

package/src/strategies/goals/paradise-fish-top.test.ts

@@ -1,126 +1,126 @@
-import { describe, expect, it } from 'vitest';
-import type { GameState } from '../../sdk/types.js';
-import type { StrategyContext } from '../types.js';
-import { KeepAwayGoal } from './keep-away-goal.js';
-import { ParadiseFishTop } from './paradise-fish-top.js';
-
-function state(overrides: Partial<GameState> = {}): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'paradise',
-      x: 1502,
-      y: 2002,
-      room: 'control',
-      role: 'neutral_paradise_fish',
-      faction: 'neutral',
-      is_alive: true,
-    },
-    your_tasks: [],
-    players: [],
-    corpses: [],
-    stale: false,
-    ...overrides,
-  };
-}
-
-function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
-  return {
-    taskData: [],
-    emergency: null,
-    taskLocalBlockedUntil: 0,
-    reportCorpseTarget: null,
-    reportBlockedUntil: 0,
-    notifications: [],
-    lastProgressNotifyAt: Date.now(),
-    teammates: new Set(),
-    alarmDone: false,
-    rooms: [
-      { name: 'danger-route', x: 1602, y: 1402 },
-      { name: 'safe-route', x: 2602, y: 586 },
-    ],
-    playerNamesBySeat: {},
-    forcePatrolAdvance: false,
-    blockedMoveTarget: null,
-    mySeat: 1,
-    speechNotifications: [],
-    agentAlerts: [],
-    ...overrides,
-  };
-}
-
-describe('ParadiseFishTop patrol routing', () => {
-  it('keeps recent avoid points when selecting a patrol target after losing sight', () => {
-    const top = new ParadiseFishTop();
-    const ctx = context();
-
-    top.tick(state({
-      you: { ...state().you, x: 2418, y: 590 },
-      players: [{ name: 'stranger', x: 1986, y: 994, room: 'control', distance: 591 }],
-    }), ctx);
-
-    const decisions = top.tick(state({
-      you: { ...state().you, x: 2418, y: 590 },
-    }), ctx);
-
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.type).toBe('move');
-    expect(decisions[0].action.payload).toMatchObject({ target_x: 2602, target_y: 586 });
-  });
-
-  it('backs away before lingering near a corpse when only one non-bad player is visible', () => {
-    const top = new ParadiseFishTop();
-    const ctx = context({
-      knownCorpses: [{ name: 'body', room: 'control', x: 2100, y: 1800 }],
-    });
-
-    const decisions = top.tick(state({
-      players: [{ name: 'stranger', x: 1986, y: 994, room: 'control', distance: 591 }],
-    }), ctx);
-
-    expect(decisions).toEqual([]);
-    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
-  });
-
-  it('does not back away from two visible non-bad players and can still linger near a corpse', () => {
-    const top = new ParadiseFishTop();
-    const corpse = { name: 'body', room: 'control', x: 2100, y: 1800 };
-    const ctx = context({ knownCorpses: [corpse] });
-
-    const decisions = top.tick(state({
-      players: [
-        { name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 },
-        { name: 'stranger-b', x: 2300, y: 1200, room: 'control', distance: 650 },
-      ],
-    }), ctx);
-
-    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.type).toBe('move');
-    const { target_x: x, target_y: y } = decisions[0].action.payload;
-    expect(Math.hypot(x - corpse.x, y - corpse.y)).toBeLessThanOrEqual(100);
-  });
-
-  it('clears non-bad route avoidance once a second non-bad witness appears', () => {
-    const top = new ParadiseFishTop();
-    const ctx = context();
-
-    top.tick(state({
-      you: { ...state().you, x: 2418, y: 590 },
-      players: [{ name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 }],
-    }), ctx);
-
-    const decisions = top.tick(state({
-      you: { ...state().you, x: 2418, y: 590 },
-      players: [
-        { name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 },
-        { name: 'stranger-b', x: 2600, y: 900, room: 'control', distance: 350 },
-      ],
-    }), ctx);
-
-    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.payload).toMatchObject({ target_x: 1602, target_y: 1402 });
-  });
-});
+import { describe, expect, it } from 'vitest';
+import type { GameState } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+import { ParadiseFishTop } from './paradise-fish-top.js';
+
+function state(overrides: Partial<GameState> = {}): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'paradise',
+      x: 1502,
+      y: 2002,
+      room: 'control',
+      role: 'neutral_paradise_fish',
+      faction: 'neutral',
+      is_alive: true,
+    },
+    your_tasks: [],
+    players: [],
+    corpses: [],
+    stale: false,
+    ...overrides,
+  };
+}
+
+function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
+  return {
+    taskData: [],
+    emergency: null,
+    taskLocalBlockedUntil: 0,
+    reportCorpseTarget: null,
+    reportBlockedUntil: 0,
+    notifications: [],
+    lastProgressNotifyAt: Date.now(),
+    teammates: new Set(),
+    alarmDone: false,
+    rooms: [
+      { name: 'danger-route', x: 1602, y: 1402 },
+      { name: 'safe-route', x: 2602, y: 586 },
+    ],
+    playerNamesBySeat: {},
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('ParadiseFishTop patrol routing', () => {
+  it('keeps recent avoid points when selecting a patrol target after losing sight', () => {
+    const top = new ParadiseFishTop();
+    const ctx = context();
+
+    top.tick(state({
+      you: { ...state().you, x: 2418, y: 590 },
+      players: [{ name: 'stranger', x: 1986, y: 994, room: 'control', distance: 591 }],
+    }), ctx);
+
+    const decisions = top.tick(state({
+      you: { ...state().you, x: 2418, y: 590 },
+    }), ctx);
+
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.type).toBe('move');
+    expect(decisions[0].action.payload).toMatchObject({ target_x: 2602, target_y: 586 });
+  });
+
+  it('backs away before lingering near a corpse when only one non-bad player is visible', () => {
+    const top = new ParadiseFishTop();
+    const ctx = context({
+      knownCorpses: [{ name: 'body', room: 'control', x: 2100, y: 1800 }],
+    });
+
+    const decisions = top.tick(state({
+      players: [{ name: 'stranger', x: 1986, y: 994, room: 'control', distance: 591 }],
+    }), ctx);
+
+    expect(decisions).toEqual([]);
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+  });
+
+  it('does not back away from two visible non-bad players and can still linger near a corpse', () => {
+    const top = new ParadiseFishTop();
+    const corpse = { name: 'body', room: 'control', x: 2100, y: 1800 };
+    const ctx = context({ knownCorpses: [corpse] });
+
+    const decisions = top.tick(state({
+      players: [
+        { name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 },
+        { name: 'stranger-b', x: 2300, y: 1200, room: 'control', distance: 650 },
+      ],
+    }), ctx);
+
+    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.type).toBe('move');
+    const { target_x: x, target_y: y } = decisions[0].action.payload;
+    expect(Math.hypot(x - corpse.x, y - corpse.y)).toBeLessThanOrEqual(100);
+  });
+
+  it('clears non-bad route avoidance once a second non-bad witness appears', () => {
+    const top = new ParadiseFishTop();
+    const ctx = context();
+
+    top.tick(state({
+      you: { ...state().you, x: 2418, y: 590 },
+      players: [{ name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 }],
+    }), ctx);
+
+    const decisions = top.tick(state({
+      you: { ...state().you, x: 2418, y: 590 },
+      players: [
+        { name: 'stranger-a', x: 1986, y: 994, room: 'control', distance: 591 },
+        { name: 'stranger-b', x: 2600, y: 900, room: 'control', distance: 350 },
+      ],
+    }), ctx);
+
+    expect(top.subGoal).not.toBeInstanceOf(KeepAwayGoal);
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.payload).toMatchObject({ target_x: 1602, target_y: 1402 });
+  });
+});

package/src/strategies/goals/paradise-fish-top.ts

@@ -1,207 +1,207 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import {
-  corpseAtScene,
-  hasKnownCorpse,
-  isKnowledgeThreat,
-  isKnowledgeTrusted,
-  nonTeammatesVisible,
-  PatrolState,
-  PROGRESS_INTERVAL_MS,
-  safePatrolStep,
-} from '../game-utils.js';
-import type { BehaviorDecision, StrategyContext } from '../types.js';
-import { GreetingTracker } from '../greeting.js';
-import { FollowCompanionGoal } from './follow-companion-goal.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
-import { LingerCorpseGoal } from './linger-corpse-goal.js';
-
-const SUB_PRIORITY = 0.5;
-const AVOID_ROUTE_MEMORY_MS = 10_000;
-const WITNESS_EXEMPT_COUNT = 2;
-
-type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
-
-export class ParadiseFishTop extends Goal {
-  private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
-  private readonly follow = new FollowCompanionGoal(
-    (state, ctx) => nonTeammatesVisible(state, ctx).filter(p => this.isTrusted(p, ctx)),
-    (state, ctx) => this.visibleAvoidTargets(state, ctx),
-  );
-  private readonly patrol = new PatrolState();
-  private readonly greeting: GreetingTracker;
-  private readonly recentAvoidPoints = new Map<string, { point: Position; until: number; threat: boolean }>();
-
-  constructor(greetingPhrases: string[] = []) {
-    super();
-    this.greeting = new GreetingTracker(greetingPhrases);
-  }
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
-    const trustedTargets = visible.filter(p => this.isTrusted(p, ctx));
-    const strangerAvoidTargets = this.strangerAvoidTargets(visible, ctx);
-    this.rememberAvoidPoints(visible, ctx, strangerAvoidTargets.length > 0);
-    const decisions: BehaviorDecision[] = [];
-    const greeting = this.greeting.tryGreeting(state);
-    if (greeting) decisions.push(greeting);
-
-    if (threatTargets.length > 0) {
-      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
-        threatRadius: Infinity,
-        noun: '认定带刀坏人',
-      });
-      this.emitProgress(state, ctx, visible, 'flee-bad');
-      return decisions;
-    }
-
-    if (strangerAvoidTargets.length > 0) {
-      this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
-        threatRadius: Infinity,
-        noun: '陌生人',
-        planOpts: { steps: 4 },
-      });
-      this.emitProgress(state, ctx, visible, 'keep-distance');
-      return decisions;
-    }
-
-    // 贴尸游走制造嫌疑是「往尸体处移动」的导航行为（不灭口/不报警/不栽赃），与 corpse-patrol 一致用记忆
-    // 驱动：记得某处有尸体就走回去徘徊，尸体离开视野也不丢，直到开会清场（LingerCorpseGoal 内部按
-    // nearestKnownCorpseNav 导航——有坐标就贴尸 40-100 游走，只记得房间没坐标时先走向房间锚点，
-    // 人进视野后坐标自然补全，再切到贴尸游走）。
-    if (hasKnownCorpse(ctx)) {
-      this.clearSub();
-      const linger = this.linger.tick(state, ctx);
-      if (linger.length > 0) {
-        this.emitProgress(state, ctx, visible, 'corpse');
-        return [...linger, ...decisions];
-      }
-    }
-
-    if (trustedTargets.length > 0) {
-      this.clearSub();
-      const follow = this.follow.tick(state, ctx);
-      this.emitProgress(state, ctx, visible, 'huddle');
-      return [...follow, ...decisions];
-    }
-
-    this.clearSub();
-    this.emitProgress(state, ctx, visible, 'wander');
-    return [...this.wander(state, ctx), ...decisions];
-  }
-
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
-  }
-
-  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeTrusted(p, ctx);
-  }
-
-  private strangerAvoidTargets(visible: PlayerInfo[], ctx: StrategyContext): PlayerInfo[] {
-    if (visible.some(p => this.isTrusted(p, ctx))) return [];
-    const nonBad = visible.filter(p => !this.isThreat(p, ctx));
-    if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
-    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
-  }
-
-  private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
-    const visible = nonTeammatesVisible(state, ctx);
-    const threats = visible.filter(p => this.isThreat(p, ctx));
-    return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
-  }
-
-  private wander(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    return safePatrolStep(state, ctx, this.patrol, false, {
-      threatPoints: this.activeAvoidPoints(),
-    });
-  }
-
-  private rememberAvoidPoints(visible: PlayerInfo[], ctx: StrategyContext, avoidNonThreat: boolean): void {
-    const now = Date.now();
-    if (visible.length > 0 && !avoidNonThreat) {
-      for (const [key, item] of this.recentAvoidPoints) {
-        if (!item.threat) this.recentAvoidPoints.delete(key);
-      }
-    }
-    for (const p of visible) {
-      const key = this.playerKey(p);
-      if (!key) continue;
-      if (this.isTrusted(p, ctx)) {
-        this.recentAvoidPoints.delete(key);
-        continue;
-      }
-      const threat = this.isThreat(p, ctx);
-      if (!threat && !avoidNonThreat) {
-        this.recentAvoidPoints.delete(key);
-        continue;
-      }
-      this.recentAvoidPoints.set(key, {
-        point: { x: p.x, y: p.y },
-        until: now + AVOID_ROUTE_MEMORY_MS,
-        threat,
-      });
-    }
-    for (const [key, item] of this.recentAvoidPoints) {
-      if (item.until <= now) this.recentAvoidPoints.delete(key);
-    }
-  }
-
-  private activeAvoidPoints(): Position[] {
-    const now = Date.now();
-    const points: Position[] = [];
-    for (const [key, item] of this.recentAvoidPoints) {
-      if (item.until <= now) {
-        this.recentAvoidPoints.delete(key);
-      } else {
-        points.push(item.point);
-      }
-    }
-    return points;
-  }
-
-  private playerKey(p: PlayerInfo): string {
-    return p.name || (p.seat != null ? String(p.seat) : `${Math.round(p.x)},${Math.round(p.y)}`);
-  }
-
-  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 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 ?? '未知';
-    let msg = `[进度] 当前在${room}`;
-    if (tier === 'corpse') {
-      // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
-      if (!corpseAtScene(state)) {
-        msg += '，记得有尸体，正前往尸体处（不报警）。';
-      } else {
-        msg += visible.length > 0
-          ? '，发现尸体，远离旁人但仍在尸体附近游走（不报警）。'
-          : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
-      }
-    } else 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 += `，附近有${visible.length}人但无可信同伴，保持距离中。`;
-    } else if (tier === 'huddle') {
-      msg += '，附近有可信同伴，抱团假装做任务。';
-    } else {
-      msg += '，附近无人，四处游荡。';
-    }
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import {
+  corpseAtScene,
+  hasKnownCorpse,
+  isKnowledgeThreat,
+  isKnowledgeTrusted,
+  nonTeammatesVisible,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+  safePatrolStep,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { GreetingTracker } from '../greeting.js';
+import { FollowCompanionGoal } from './follow-companion-goal.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
+import { LingerCorpseGoal } from './linger-corpse-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const AVOID_ROUTE_MEMORY_MS = 10_000;
+const WITNESS_EXEMPT_COUNT = 2;
+
+type Tier = 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
+
+export class ParadiseFishTop extends Goal {
+  private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
+  private readonly follow = new FollowCompanionGoal(
+    (state, ctx) => nonTeammatesVisible(state, ctx).filter(p => this.isTrusted(p, ctx)),
+    (state, ctx) => this.visibleAvoidTargets(state, ctx),
+  );
+  private readonly patrol = new PatrolState();
+  private readonly greeting: GreetingTracker;
+  private readonly recentAvoidPoints = new Map<string, { point: Position; until: number; threat: boolean }>();
+
+  constructor(greetingPhrases: string[] = []) {
+    super();
+    this.greeting = new GreetingTracker(greetingPhrases);
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
+    const trustedTargets = visible.filter(p => this.isTrusted(p, ctx));
+    const strangerAvoidTargets = this.strangerAvoidTargets(visible, ctx);
+    this.rememberAvoidPoints(visible, ctx, strangerAvoidTargets.length > 0);
+    const decisions: BehaviorDecision[] = [];
+    const greeting = this.greeting.tryGreeting(state);
+    if (greeting) decisions.push(greeting);
+
+    if (threatTargets.length > 0) {
+      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)), {
+        threatRadius: Infinity,
+        noun: '认定带刀坏人',
+      });
+      this.emitProgress(state, ctx, visible, 'flee-bad');
+      return decisions;
+    }
+
+    if (strangerAvoidTargets.length > 0) {
+      this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
+        threatRadius: Infinity,
+        noun: '陌生人',
+        planOpts: { steps: 4 },
+      });
+      this.emitProgress(state, ctx, visible, 'keep-distance');
+      return decisions;
+    }
+
+    // 贴尸游走制造嫌疑是「往尸体处移动」的导航行为（不灭口/不报警/不栽赃），与 corpse-patrol 一致用记忆
+    // 驱动：记得某处有尸体就走回去徘徊，尸体离开视野也不丢，直到开会清场（LingerCorpseGoal 内部按
+    // nearestKnownCorpseNav 导航——有坐标就贴尸 40-100 游走，只记得房间没坐标时先走向房间锚点，
+    // 人进视野后坐标自然补全，再切到贴尸游走）。
+    if (hasKnownCorpse(ctx)) {
+      this.clearSub();
+      const linger = this.linger.tick(state, ctx);
+      if (linger.length > 0) {
+        this.emitProgress(state, ctx, visible, 'corpse');
+        return [...linger, ...decisions];
+      }
+    }
+
+    if (trustedTargets.length > 0) {
+      this.clearSub();
+      const follow = this.follow.tick(state, ctx);
+      this.emitProgress(state, ctx, visible, 'huddle');
+      return [...follow, ...decisions];
+    }
+
+    this.clearSub();
+    this.emitProgress(state, ctx, visible, 'wander');
+    return [...this.wander(state, ctx), ...decisions];
+  }
+
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  }
+
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  private strangerAvoidTargets(visible: PlayerInfo[], ctx: StrategyContext): PlayerInfo[] {
+    if (visible.some(p => this.isTrusted(p, ctx))) return [];
+    const nonBad = visible.filter(p => !this.isThreat(p, ctx));
+    if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
+    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
+  }
+
+  private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    const threats = visible.filter(p => this.isThreat(p, ctx));
+    return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
+  }
+
+  private wander(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    return safePatrolStep(state, ctx, this.patrol, false, {
+      threatPoints: this.activeAvoidPoints(),
+    });
+  }
+
+  private rememberAvoidPoints(visible: PlayerInfo[], ctx: StrategyContext, avoidNonThreat: boolean): void {
+    const now = Date.now();
+    if (visible.length > 0 && !avoidNonThreat) {
+      for (const [key, item] of this.recentAvoidPoints) {
+        if (!item.threat) this.recentAvoidPoints.delete(key);
+      }
+    }
+    for (const p of visible) {
+      const key = this.playerKey(p);
+      if (!key) continue;
+      if (this.isTrusted(p, ctx)) {
+        this.recentAvoidPoints.delete(key);
+        continue;
+      }
+      const threat = this.isThreat(p, ctx);
+      if (!threat && !avoidNonThreat) {
+        this.recentAvoidPoints.delete(key);
+        continue;
+      }
+      this.recentAvoidPoints.set(key, {
+        point: { x: p.x, y: p.y },
+        until: now + AVOID_ROUTE_MEMORY_MS,
+        threat,
+      });
+    }
+    for (const [key, item] of this.recentAvoidPoints) {
+      if (item.until <= now) this.recentAvoidPoints.delete(key);
+    }
+  }
+
+  private activeAvoidPoints(): Position[] {
+    const now = Date.now();
+    const points: Position[] = [];
+    for (const [key, item] of this.recentAvoidPoints) {
+      if (item.until <= now) {
+        this.recentAvoidPoints.delete(key);
+      } else {
+        points.push(item.point);
+      }
+    }
+    return points;
+  }
+
+  private playerKey(p: PlayerInfo): string {
+    return p.name || (p.seat != null ? String(p.seat) : `${Math.round(p.x)},${Math.round(p.y)}`);
+  }
+
+  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 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 ?? '未知';
+    let msg = `[进度] 当前在${room}`;
+    if (tier === 'corpse') {
+      // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
+      if (!corpseAtScene(state)) {
+        msg += '，记得有尸体，正前往尸体处（不报警）。';
+      } else {
+        msg += visible.length > 0
+          ? '，发现尸体，远离旁人但仍在尸体附近游走（不报警）。'
+          : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
+      }
+    } else 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 += `，附近有${visible.length}人但无可信同伴，保持距离中。`;
+    } else if (tier === 'huddle') {
+      msg += '，附近有可信同伴，抱团假装做任务。';
+    } else {
+      msg += '，附近无人，四处游荡。';
+    }
+    ctx.notifications.push(msg);
+  }
+}