@myclaw163/clawclaw-cli 0.6.70 → 0.6.74

package/src/strategies/goals/anchor-linger.ts

@@ -1,77 +1,77 @@
-import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { dist } from '../game-utils.js';
-
-export interface AnchorLingerOptions {
-  /** 游走环最小半径（px）。 */
-  min?: number;
-  /** 游走环最大半径（px）。 */
-  max?: number;
-  /** 走到离游走点这么近就算到达、换下一个点。 */
-  reached?: number;
-  /** 单个游走点最多停留这么久就强制换点，防止点落在墙里不可达时卡死。 */
-  dwellMs?: number;
-}
-
-/**
- * 围绕一个锚点 min-max px 的「粘性游走」：游走点一旦选定就粘住，直到走到 / 超时 / 换了锚点，
- * 不每 tick 重随机——否则主循环对「同一移动目标」的去重永不触发，会每轮打断上一次移动、在原地抖
- * 而走不出一条游走腿。有 avoid 目标时偏向锚点相对最近目标的对侧。贴尸游走（LingerCorpseGoal）
- * 与跟随同伴在其任务点假装做任务（FollowCompanionGoal）复用同一套游走机制。
- */
-export class AnchorLinger {
-  private target: Position | null = null;
-  private until = 0;
-  private key = '';
-  private readonly min: number;
-  private readonly max: number;
-  private readonly reached: number;
-  private readonly dwellMs: number;
-
-  constructor(options: AnchorLingerOptions = {}) {
-    this.min = options.min ?? 40;
-    this.max = options.max ?? 100;
-    this.reached = options.reached ?? 24;
-    this.dwellMs = options.dwellMs ?? 4000;
-  }
-
-  /** 丢弃当前游走点：离开锚点（尸体出视野、同伴起身走动）时调用，下次重新挑点。 */
-  reset(): void {
-    this.target = null;
-  }
-
-  /** 围绕 anchor 取下一个游走点；key 变了（换了锚点）会立即重挑。 */
-  step(state: GameState, key: string, anchor: Position, avoid: PlayerInfo[] = []): Position {
-    const now = Date.now();
-    const reached = this.target != null
-      && dist(state.you.x, state.you.y, this.target.x, this.target.y) <= this.reached;
-    if (this.target == null || this.key !== key || reached || now >= this.until) {
-      this.key = key;
-      this.target = this.pickOffset(state, anchor, avoid);
-      this.until = now + this.dwellMs;
-    }
-    return this.target;
-  }
-
-  private pickOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
-    return avoid.length > 0 ? this.farSideOffset(state, anchor, avoid) : this.randomOffset(anchor);
-  }
-
-  private farSideOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
-    const nearest = avoid.reduce((best, p) => {
-      const d = p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
-      const bestD = best.distance ?? dist(state.you.x, state.you.y, best.x, best.y);
-      return d < bestD ? p : best;
-    });
-    const vx = anchor.x - nearest.x;
-    const vy = anchor.y - nearest.y;
-    const len = Math.hypot(vx, vy);
-    if (len === 0) return this.randomOffset(anchor);
-    return { x: anchor.x + (vx / len) * this.max, y: anchor.y + (vy / len) * this.max };
-  }
-
-  private randomOffset(anchor: Position): Position {
-    const angle = Math.random() * 2 * Math.PI;
-    const radius = this.min + Math.random() * (this.max - this.min);
-    return { x: anchor.x + Math.cos(angle) * radius, y: anchor.y + Math.sin(angle) * radius };
-  }
-}
+import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
+import { dist } from '../game-utils.js';
+
+export interface AnchorLingerOptions {
+  /** 游走环最小半径（px）。 */
+  min?: number;
+  /** 游走环最大半径（px）。 */
+  max?: number;
+  /** 走到离游走点这么近就算到达、换下一个点。 */
+  reached?: number;
+  /** 单个游走点最多停留这么久就强制换点，防止点落在墙里不可达时卡死。 */
+  dwellMs?: number;
+}
+
+/**
+ * 围绕一个锚点 min-max px 的「粘性游走」：游走点一旦选定就粘住，直到走到 / 超时 / 换了锚点，
+ * 不每 tick 重随机——否则主循环对「同一移动目标」的去重永不触发，会每轮打断上一次移动、在原地抖
+ * 而走不出一条游走腿。有 avoid 目标时偏向锚点相对最近目标的对侧。贴尸游走（LingerCorpseGoal）
+ * 与跟随同伴在其任务点假装做任务（FollowCompanionGoal）复用同一套游走机制。
+ */
+export class AnchorLinger {
+  private target: Position | null = null;
+  private until = 0;
+  private key = '';
+  private readonly min: number;
+  private readonly max: number;
+  private readonly reached: number;
+  private readonly dwellMs: number;
+
+  constructor(options: AnchorLingerOptions = {}) {
+    this.min = options.min ?? 40;
+    this.max = options.max ?? 100;
+    this.reached = options.reached ?? 24;
+    this.dwellMs = options.dwellMs ?? 4000;
+  }
+
+  /** 丢弃当前游走点：离开锚点（尸体出视野、同伴起身走动）时调用，下次重新挑点。 */
+  reset(): void {
+    this.target = null;
+  }
+
+  /** 围绕 anchor 取下一个游走点；key 变了（换了锚点）会立即重挑。 */
+  step(state: GameState, key: string, anchor: Position, avoid: PlayerInfo[] = []): Position {
+    const now = Date.now();
+    const reached = this.target != null
+      && dist(state.you.x, state.you.y, this.target.x, this.target.y) <= this.reached;
+    if (this.target == null || this.key !== key || reached || now >= this.until) {
+      this.key = key;
+      this.target = this.pickOffset(state, anchor, avoid);
+      this.until = now + this.dwellMs;
+    }
+    return this.target;
+  }
+
+  private pickOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
+    return avoid.length > 0 ? this.farSideOffset(state, anchor, avoid) : this.randomOffset(anchor);
+  }
+
+  private farSideOffset(state: GameState, anchor: Position, avoid: PlayerInfo[]): Position {
+    const nearest = avoid.reduce((best, p) => {
+      const d = p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
+      const bestD = best.distance ?? dist(state.you.x, state.you.y, best.x, best.y);
+      return d < bestD ? p : best;
+    });
+    const vx = anchor.x - nearest.x;
+    const vy = anchor.y - nearest.y;
+    const len = Math.hypot(vx, vy);
+    if (len === 0) return this.randomOffset(anchor);
+    return { x: anchor.x + (vx / len) * this.max, y: anchor.y + (vy / len) * this.max };
+  }
+
+  private randomOffset(anchor: Position): Position {
+    const angle = Math.random() * 2 * Math.PI;
+    const radius = this.min + Math.random() * (this.max - this.min);
+    return { x: anchor.x + Math.cos(angle) * radius, y: anchor.y + Math.sin(angle) * radius };
+  }
+}

package/src/strategies/goals/avoid-lone-top.ts

@@ -1,168 +1,168 @@
-import type { GameState, PlayerInfo } from '../../sdk/types.js';
-import { dist, hasReachedRoomTarget, PatrolState, PROGRESS_INTERVAL_MS, pursueVisibleTarget } from '../game-utils.js';
-import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
-import { Goal } from './goal.js';
-import { KeepAwayGoal, type ThreatResolver } from './keep-away-goal.js';
-import { MoveRoomGoal, type RoomArrival } from './move-room-goal.js';
-
-const PATROL_PRIORITY = 0.2;
-const MOVE_PRIORITY = 0.5;
-const EMPTY_GRACE_MS = 8_000;
-// 次近玩家落在这个范围内就原地待着；超出才迈步靠近。须 < 视野半径，留边缘余量。
-const GATHER_FOLLOW_DISTANCE = 200;
-
-type MoveMode = 'patrol' | 'flee' | 'gather';
-
-export class AvoidLoneTop extends Goal {
-  private readonly patrol = new PatrolState();
-  private emptySince: number | null = null;
-  private moveMode: MoveMode | null = null;
-  private lastNoticeKey = '';
-
-  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const now = Date.now();
-    const visible = state.players;
-
-    if (visible.length === 0) {
-      if (this.emptySince == null) this.emptySince = now;
-      // 有「上一条移动」要守护时就尊重 8 秒空视野宽限：flee 靠子目标续命（KeepAwayGoal），
-      // gather 是内联返回的跟随 move（无子目标），靠 moveMode==='gather' 标记守护——
-      // 否则人短暂出视野会被立刻改判巡逻、覆盖掉刚发出的跟随移动。
-      const hasMoveToHold = this.subGoal != null || this.moveMode === 'gather';
-      if (!hasMoveToHold || now - this.emptySince >= EMPTY_GRACE_MS) {
-        this.setPatrolGoal(state, ctx);
-        this.emitProgress(state, ctx, 'patrol', null, visible);
-      } else {
-        this.emitProgress(state, ctx, this.moveMode, null, visible); // 宽限期内维持原目标
-      }
-      return [];
-    }
-
-    this.emptySince = null;
-
-    if (visible.length === 1) {
-      const lone = visible[0].name;
-      this.setKeepAway(`single:${lone}`,
-        currentState => currentState.players.filter(player => player.name === lone));
-      if (!this.emitNotice(ctx, `flee:${lone}`,
-        `视野内只有${lone}，正在寻路避免落单。`))
-        this.emitProgress(state, ctx, 'flee', null, visible);
-      return [];
-    }
-
-    // 2+ 人：跟住「次近」的人。最近的人本就贴着、最不会掉出视野；真正卡在
-    // 「≥2 人 / 跌回 1 人独处」临界点上的是第二近的人，盯住他、保持在视野舒适范围内即可维持人数。
-    this.clearGoal();
-    this.moveMode = 'gather';
-    const anchor = [...visible].sort((a, b) => this.distOf(state, a) - this.distOf(state, b))[1]; // length>=2 必存在
-    const decision = pursueVisibleTarget(state, anchor, { kill: false, followDistance: GATHER_FOLLOW_DISTANCE });
-    if (decision) {
-      if (!this.emitNotice(ctx, `gather:follow:${anchor.name}`,
-        `视野内${visible.length}人，正在靠近${anchor.name}维持人数。`))
-        this.emitProgress(state, ctx, 'gather', null, visible);
-      return [{
-        action: decision.action.withThinking(
-          `跟住次近的${anchor.name}，维持视野内至少两人，避免落单。`,
-        ),
-      }];
-    }
-    if (!this.emitNotice(ctx, `gather:hold:${visible.length}`,
-      `视野内${visible.length}人，已和大家在一起保持安全。`))
-      this.emitProgress(state, ctx, 'gather', null, visible);
-    return [];
-  }
-
-  private distOf(state: GameState, p: PlayerInfo): number {
-    return p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
-  }
-
-  private setPatrolGoal(state: GameState, ctx: StrategyContext): void {
-    let room = this.patrol.nextRoom(ctx);
-    if (!room) {
-      this.clearGoal();
-      return;
-    }
-
-    if (hasReachedRoomTarget(state, room)) {
-      this.patrol.advance(ctx);
-      room = this.patrol.nextRoom(ctx);
-      if (!room) {
-        this.clearGoal();
-        return;
-      }
-    }
-
-    this.setMoveGoal(room, 'patrol', true, PATROL_PRIORITY);
-    this.lastNoticeKey = '';
-  }
-
-  /**
-   * 寻路躲避：用 KeepAwayGoal 推演逃点远离这个唯一可见的人（不限距离，避免落单）。
-   * finishWhenClear:false——人短暂丢失视野时子目标不自我结束，交由父层 8 秒空视野宽限
-   * 决定何时转巡逻，否则一丢视野就同轮被清、下一 tick 立刻 patrol，宽限只剩一帧会来回摇摆。
-   */
-  private setKeepAway(key: string, resolveThreats: ThreatResolver): void {
-    const worker = this.subGoal;
-    if (worker instanceof KeepAwayGoal && worker.key === key) {
-      this.moveMode = 'flee';
-      return;
-    }
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new KeepAwayGoal(key, resolveThreats, {
-      threatRadius: Infinity,
-      finishWhenClear: false,
-      noun: '',
-    }), MOVE_PRIORITY);
-    this.moveMode = 'flee';
-  }
-
-  private setMoveGoal(
-    room: RoomTarget,
-    mode: MoveMode,
-    stopOnPlayer: boolean,
-    priority = MOVE_PRIORITY,
-    hasArrived: RoomArrival = hasReachedRoomTarget,
-  ): void {
-    const worker = this.subGoal;
-    if (worker instanceof MoveRoomGoal && worker.room === room.name && this.moveMode === mode) return;
-    if (this.subGoal) this.removeSubGoal();
-    this.setSubGoal(new MoveRoomGoal(room.name, hasArrived, {
-      emitProgress: false,
-      stopOnPlayer,
-    }), priority);
-    this.moveMode = mode;
-  }
-
-  private clearGoal(): void {
-    if (this.subGoal) this.removeSubGoal();
-    this.moveMode = null;
-  }
-
-  private emitNotice(ctx: StrategyContext, key: string, message: string): boolean {
-    if (key === this.lastNoticeKey) return false;
-    this.lastNoticeKey = key;
-    ctx.notifications.push(message);
-    return true;
-  }
-
-  private emitProgress(
-    state: GameState,
-    ctx: StrategyContext,
-    mode: MoveMode | null,
-    target: RoomTarget | null,
-    visible: PlayerInfo[],
-  ): void {
-    const now = Date.now();
-    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
-    ctx.lastProgressNotifyAt = now;
-
-    const room = state.you.room ?? '未知';
-    let msg = `[进度] 当前在${room}，视野内${visible.length}人`;
-    if (mode === 'gather') msg += '，正在跟随人群';
-    else if (mode === 'flee') msg += '，正在避免落单风险';
-    else msg += '，正在巡逻寻找人群';
-    if (target) msg += `，前往${target.name}`;
-    msg += '。';
-    ctx.notifications.push(msg);
-  }
-}
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { dist, hasReachedRoomTarget, PatrolState, PROGRESS_INTERVAL_MS, pursueVisibleTarget } from '../game-utils.js';
+import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type ThreatResolver } from './keep-away-goal.js';
+import { MoveRoomGoal, type RoomArrival } from './move-room-goal.js';
+
+const PATROL_PRIORITY = 0.2;
+const MOVE_PRIORITY = 0.5;
+const EMPTY_GRACE_MS = 8_000;
+// 次近玩家落在这个范围内就原地待着；超出才迈步靠近。须 < 视野半径，留边缘余量。
+const GATHER_FOLLOW_DISTANCE = 200;
+
+type MoveMode = 'patrol' | 'flee' | 'gather';
+
+export class AvoidLoneTop extends Goal {
+  private readonly patrol = new PatrolState();
+  private emptySince: number | null = null;
+  private moveMode: MoveMode | null = null;
+  private lastNoticeKey = '';
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const now = Date.now();
+    const visible = state.players;
+
+    if (visible.length === 0) {
+      if (this.emptySince == null) this.emptySince = now;
+      // 有「上一条移动」要守护时就尊重 8 秒空视野宽限：flee 靠子目标续命（KeepAwayGoal），
+      // gather 是内联返回的跟随 move（无子目标），靠 moveMode==='gather' 标记守护——
+      // 否则人短暂出视野会被立刻改判巡逻、覆盖掉刚发出的跟随移动。
+      const hasMoveToHold = this.subGoal != null || this.moveMode === 'gather';
+      if (!hasMoveToHold || now - this.emptySince >= EMPTY_GRACE_MS) {
+        this.setPatrolGoal(state, ctx);
+        this.emitProgress(state, ctx, 'patrol', null, visible);
+      } else {
+        this.emitProgress(state, ctx, this.moveMode, null, visible); // 宽限期内维持原目标
+      }
+      return [];
+    }
+
+    this.emptySince = null;
+
+    if (visible.length === 1) {
+      const lone = visible[0].name;
+      this.setKeepAway(`single:${lone}`,
+        currentState => currentState.players.filter(player => player.name === lone));
+      if (!this.emitNotice(ctx, `flee:${lone}`,
+        `视野内只有${lone}，正在寻路避免落单。`))
+        this.emitProgress(state, ctx, 'flee', null, visible);
+      return [];
+    }
+
+    // 2+ 人：跟住「次近」的人。最近的人本就贴着、最不会掉出视野；真正卡在
+    // 「≥2 人 / 跌回 1 人独处」临界点上的是第二近的人，盯住他、保持在视野舒适范围内即可维持人数。
+    this.clearGoal();
+    this.moveMode = 'gather';
+    const anchor = [...visible].sort((a, b) => this.distOf(state, a) - this.distOf(state, b))[1]; // length>=2 必存在
+    const decision = pursueVisibleTarget(state, anchor, { kill: false, followDistance: GATHER_FOLLOW_DISTANCE });
+    if (decision) {
+      if (!this.emitNotice(ctx, `gather:follow:${anchor.name}`,
+        `视野内${visible.length}人，正在靠近${anchor.name}维持人数。`))
+        this.emitProgress(state, ctx, 'gather', null, visible);
+      return [{
+        action: decision.action.withThinking(
+          `跟住次近的${anchor.name}，维持视野内至少两人，避免落单。`,
+        ),
+      }];
+    }
+    if (!this.emitNotice(ctx, `gather:hold:${visible.length}`,
+      `视野内${visible.length}人，已和大家在一起保持安全。`))
+      this.emitProgress(state, ctx, 'gather', null, visible);
+    return [];
+  }
+
+  private distOf(state: GameState, p: PlayerInfo): number {
+    return p.distance ?? dist(state.you.x, state.you.y, p.x, p.y);
+  }
+
+  private setPatrolGoal(state: GameState, ctx: StrategyContext): void {
+    let room = this.patrol.nextRoom(ctx);
+    if (!room) {
+      this.clearGoal();
+      return;
+    }
+
+    if (hasReachedRoomTarget(state, room)) {
+      this.patrol.advance(ctx);
+      room = this.patrol.nextRoom(ctx);
+      if (!room) {
+        this.clearGoal();
+        return;
+      }
+    }
+
+    this.setMoveGoal(room, 'patrol', true, PATROL_PRIORITY);
+    this.lastNoticeKey = '';
+  }
+
+  /**
+   * 寻路躲避：用 KeepAwayGoal 推演逃点远离这个唯一可见的人（不限距离，避免落单）。
+   * finishWhenClear:false——人短暂丢失视野时子目标不自我结束，交由父层 8 秒空视野宽限
+   * 决定何时转巡逻，否则一丢视野就同轮被清、下一 tick 立刻 patrol，宽限只剩一帧会来回摇摆。
+   */
+  private setKeepAway(key: string, resolveThreats: ThreatResolver): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === key) {
+      this.moveMode = 'flee';
+      return;
+    }
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(key, resolveThreats, {
+      threatRadius: Infinity,
+      finishWhenClear: false,
+      noun: '',
+    }), MOVE_PRIORITY);
+    this.moveMode = 'flee';
+  }
+
+  private setMoveGoal(
+    room: RoomTarget,
+    mode: MoveMode,
+    stopOnPlayer: boolean,
+    priority = MOVE_PRIORITY,
+    hasArrived: RoomArrival = hasReachedRoomTarget,
+  ): void {
+    const worker = this.subGoal;
+    if (worker instanceof MoveRoomGoal && worker.room === room.name && this.moveMode === mode) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new MoveRoomGoal(room.name, hasArrived, {
+      emitProgress: false,
+      stopOnPlayer,
+    }), priority);
+    this.moveMode = mode;
+  }
+
+  private clearGoal(): void {
+    if (this.subGoal) this.removeSubGoal();
+    this.moveMode = null;
+  }
+
+  private emitNotice(ctx: StrategyContext, key: string, message: string): boolean {
+    if (key === this.lastNoticeKey) return false;
+    this.lastNoticeKey = key;
+    ctx.notifications.push(message);
+    return true;
+  }
+
+  private emitProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    mode: MoveMode | null,
+    target: RoomTarget | null,
+    visible: PlayerInfo[],
+  ): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    let msg = `[进度] 当前在${room}，视野内${visible.length}人`;
+    if (mode === 'gather') msg += '，正在跟随人群';
+    else if (mode === 'flee') msg += '，正在避免落单风险';
+    else msg += '，正在巡逻寻找人群';
+    if (target) msg += `，前往${target.name}`;
+    msg += '。';
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/goals/avoid-players-top.test.ts

@@ -1,83 +1,83 @@
-import { describe, expect, it } from 'vitest';
-import type { GameState } from '../../sdk/types.js';
-import type { StrategyContext } from '../types.js';
-import { AvoidPlayersTop } from './avoid-players-top.js';
-
-function state(overrides: Partial<GameState> = {}): GameState {
-  return {
-    phase: 'wandering',
-    tick: 1,
-    you: {
-      name: 'self',
-      x: 0,
-      y: 0,
-      room: 'start',
-      role: 'neutral_octopus',
-      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: 'patrol', x: 500, y: 0 }],
-    playerNamesBySeat: {},
-    forcePatrolAdvance: false,
-    blockedMoveTarget: null,
-    mySeat: 1,
-    speechNotifications: [],
-    agentAlerts: [],
-    ...overrides,
-  };
-}
-
-describe('AvoidPlayersTop', () => {
-  it('patrols without stop_on_player when the avoid list has no active threat', () => {
-    const top = new AvoidPlayersTop([]);
-    const ctx = context();
-    const current = state({
-      players: [{ name: 'roadie', x: 200, y: 0, room: 'start' }],
-    });
-
-    top.tick(current, ctx);
-    const decisions = top.subGoal?.tick(current, ctx) ?? [];
-
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.type).toBe('move');
-    expect(decisions[0].action.payload).toMatchObject({ target_x: 500, target_y: 0 });
-    expect(decisions[0].action.payload).not.toHaveProperty('stop_on_player');
-  });
-
-  it('patrols without stop_on_player when the configured avoid target is dead', () => {
-    const top = new AvoidPlayersTop(['dead-target']);
-    const ctx = context();
-    const current = state({
-      players: [{ name: 'roadie', x: 200, y: 0, room: 'start' }],
-      all_players: [
-        { name: 'dead-target', role: 'lobster', is_alive: false, seat: 2 },
-        { name: 'roadie', role: 'lobster', is_alive: true, seat: 3 },
-      ],
-    });
-
-    top.tick(current, ctx);
-    const decisions = top.subGoal?.tick(current, ctx) ?? [];
-
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0].action.payload).not.toHaveProperty('stop_on_player');
-  });
-});
+import { describe, expect, it } from 'vitest';
+import type { GameState } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { AvoidPlayersTop } from './avoid-players-top.js';
+
+function state(overrides: Partial<GameState> = {}): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'self',
+      x: 0,
+      y: 0,
+      room: 'start',
+      role: 'neutral_octopus',
+      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: 'patrol', x: 500, y: 0 }],
+    playerNamesBySeat: {},
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('AvoidPlayersTop', () => {
+  it('patrols without stop_on_player when the avoid list has no active threat', () => {
+    const top = new AvoidPlayersTop([]);
+    const ctx = context();
+    const current = state({
+      players: [{ name: 'roadie', x: 200, y: 0, room: 'start' }],
+    });
+
+    top.tick(current, ctx);
+    const decisions = top.subGoal?.tick(current, ctx) ?? [];
+
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.type).toBe('move');
+    expect(decisions[0].action.payload).toMatchObject({ target_x: 500, target_y: 0 });
+    expect(decisions[0].action.payload).not.toHaveProperty('stop_on_player');
+  });
+
+  it('patrols without stop_on_player when the configured avoid target is dead', () => {
+    const top = new AvoidPlayersTop(['dead-target']);
+    const ctx = context();
+    const current = state({
+      players: [{ name: 'roadie', x: 200, y: 0, room: 'start' }],
+      all_players: [
+        { name: 'dead-target', role: 'lobster', is_alive: false, seat: 2 },
+        { name: 'roadie', role: 'lobster', is_alive: true, seat: 3 },
+      ],
+    });
+
+    top.tick(current, ctx);
+    const decisions = top.subGoal?.tick(current, ctx) ?? [];
+
+    expect(decisions).toHaveLength(1);
+    expect(decisions[0].action.payload).not.toHaveProperty('stop_on_player');
+  });
+});