@myclaw163/clawclaw-cli 0.6.54

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

@@ -0,0 +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);
+  }
+}

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

@@ -0,0 +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');
+  });
+});

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

@@ -0,0 +1,121 @@
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { hasReachedRoomTarget, isKnowledgeThreat, isTargetAlive, matchesAnyTarget, PatrolState, PROGRESS_INTERVAL_MS } from '../game-utils.js';
+import type { BehaviorDecision, RoomTarget, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions, type ThreatResolver } from './keep-away-goal.js';
+import { MoveRoomGoal } from './move-room-goal.js';
+
+const PATROL_PRIORITY = 0.2;
+const FLEE_PRIORITY = 0.5;
+
+export class AvoidPlayersTop extends Goal {
+  private readonly patrol = new PatrolState();
+  private moveMode: 'patrol' | 'flee' | null = null;
+  private lastAvoidNoticeKey = '';
+
+  constructor(private readonly targets: string[]) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const threats = this.threats(state, ctx);
+
+    if (threats.length > 0) {
+      this.setKeepAway();
+      if (!this.emitAvoidNotice(ctx, threats)) this.emitAvoidProgress(state, ctx, threats);
+      return [];
+    }
+
+    this.lastAvoidNoticeKey = '';
+    let room = this.patrol.nextRoom(ctx);
+    if (!room) {
+      this.emitPatrolProgress(state, ctx, null);
+      return [];
+    }
+
+    if (hasReachedRoomTarget(state, room)) {
+      this.patrol.advance(ctx);
+      room = this.patrol.nextRoom(ctx);
+      if (!room) {
+        this.emitPatrolProgress(state, ctx, null);
+        return [];
+      }
+    }
+
+    this.setMoveGoal(room, PATROL_PRIORITY, 'patrol', false);
+    this.emitPatrolProgress(state, ctx, room);
+    return [];
+  }
+
+  /** 寻路躲避：用 KeepAwayGoal 推演逃点远离回避目标（不限距离，名单上的人始终要躲）。 */
+  private setKeepAway(): void {
+    const key = this.targets.length > 0 ? this.targets.join('|') : 'avoid-knowledge';
+    const resolve: ThreatResolver = (state, ctx) => this.threats(state, ctx);
+    const options: KeepAwayGoalOptions = { threatRadius: Infinity, noun: '回避目标' };
+    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, resolve, options), FLEE_PRIORITY);
+    this.moveMode = 'flee';
+  }
+
+  /** args 回避名单（活着的）∪ 知识里标记 suspect/hostile 的玩家。 */
+  private threats(state: GameState, ctx: StrategyContext): PlayerInfo[] {
+    const validTargets = this.targets.filter(target => isTargetAlive(state, target, ctx));
+    return state.players.filter(p => matchesAnyTarget(p, validTargets, ctx) || isKnowledgeThreat(p, ctx));
+  }
+
+  private setMoveGoal(room: RoomTarget, priority: number, mode: 'patrol' | 'flee', stopOnPlayer: boolean): 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, hasReachedRoomTarget, {
+      emitProgress: false,
+      stopOnPlayer,
+    }), priority);
+    this.moveMode = mode;
+  }
+
+  private emitAvoidNotice(ctx: StrategyContext, threats: PlayerInfo[]): boolean {
+    const names = threats.map(p => p.name).join('、');
+    const key = threats.map(p => p.name).sort().join('|');
+    if (key === this.lastAvoidNoticeKey) return false;
+    this.lastAvoidNoticeKey = key;
+
+    ctx.notifications.push(`发现回避目标${names}，正在寻路躲避。`);
+    return true;
+  }
+
+  private emitPatrolProgress(state: GameState, ctx: StrategyContext, target: RoomTarget | null): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const targetNames = this.targets.length > 0 ? this.targets.join(', ') : '(依据知识库)';
+
+    let msg = `[进度] 当前在${room}，巡逻中，回避名单: ${targetNames}`;
+    if (target) {
+      msg += `，正在前往${target.name}`;
+    }
+    msg += '。';
+    ctx.notifications.push(msg);
+  }
+
+  private emitAvoidProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    threats: PlayerInfo[],
+  ): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const here = state.you.room ?? '未知';
+    const names = threats.map(p => p.name).join('、');
+    ctx.notifications.push(`[进度] 当前在${here}，发现${names}，正在寻路躲避。`);
+  }
+}

package/src/strategies/goals/conversation-goal.ts

@@ -0,0 +1,51 @@
+import type { GameState } from '../../sdk/types.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { GoalManager } from './goal-manager.js';
+import { URGENT_GOAL_PRIORITY } from './leaf-goal.js';
+import type { SpeechModule } from '../speech-module.js';
+
+export class ConversationGoal extends Goal {
+  private readonly innerMgr = new GoalManager();
+
+  constructor(
+    private readonly makeInner: () => Goal,
+    private readonly speech: SpeechModule,
+  ) {
+    super();
+    this.innerMgr.setTop(makeInner());
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (this.innerMgr.getTop() === null) this.innerMgr.setTop(this.makeInner());
+    const innerDecisions = this.innerMgr.tick(state, ctx);
+
+    const interruptible = this.innerLeafPriority() < URGENT_GOAL_PRIORITY;
+    const primaryIsMove = innerDecisions[0]?.action.type === 'move';
+    const result = this.speech.evaluate(state, ctx, {
+      allowAutoGreet: interruptible && primaryIsMove,
+    });
+    for (const msg of result.notifications) ctx.speechNotifications.push(msg);
+
+    return innerDecisions;
+  }
+
+  onMeetingResume(): void {
+    this.speech.resetMeetingState();
+    this.innerMgr.getTop()?.onMeetingResume();
+  }
+
+  updateConfig(role: string): void {
+    this.speech.updateConfig(role);
+  }
+
+  private innerLeafPriority(): number {
+    let node: Goal | null = this.innerMgr.getTop();
+    let priority = 0;
+    while (node) {
+      priority = node.priority;
+      node = node.subGoal;
+    }
+    return priority;
+  }
+}

package/src/strategies/goals/corpse-patrol-top.ts

@@ -0,0 +1,91 @@
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  corpseAtScene,
+  nearestKnownCorpseNav,
+  patrolStep,
+  PatrolState,
+  PROGRESS_INTERVAL_MS,
+} from '../game-utils.js';
+import type { BehaviorDecision, CorpseTarget, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { LingerCorpseGoal } from './linger-corpse-goal.js';
+
+const GREETING_COOLDOWN_MS = 120_000;
+
+export class CorpsePatrolTop extends Goal {
+  private readonly patrol = new PatrolState();
+  private readonly linger = new LingerCorpseGoal();
+  private lastCorpseNotified = false;
+  private lastGreetingAt: number | null = null;
+
+  constructor(private readonly greetingPhrases: string[]) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const decisions: BehaviorDecision[] = [];
+
+    const greetingDecision = this.tryGreeting(state);
+    if (greetingDecision) decisions.push(greetingDecision);
+
+    const corpse = nearestKnownCorpseNav(state, ctx);
+    const canMove = !state.you.doing_task;
+
+    if (corpse) {
+      if (!this.lastCorpseNotified) {
+        this.lastCorpseNotified = true;
+        const label = corpse.name ? `${corpse.name}的尸体` : '尸体';
+        // corpseAtScene=已站在尸体旁(≤150px)；仅凭记忆/房间锚点导航过去时人还没到，别谎报「在附近徘徊」。
+        ctx.notifications.push(
+          corpseAtScene(state) ? `发现${label}！在附近徘徊观察。` : `发现${label}！正前往查看。`,
+        );
+      }
+      if (canMove) decisions.push(...this.linger.tick(state, ctx));
+    } else {
+      this.lastCorpseNotified = false;
+      if (canMove) decisions.push(...patrolStep(state, ctx, this.patrol, false));
+    }
+
+    this.emitProgress(state, ctx, corpse);
+    return decisions;
+  }
+
+  private tryGreeting(state: GameState): BehaviorDecision | null {
+    if (this.greetingPhrases.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.greetingPhrases[Math.floor(Math.random() * this.greetingPhrases.length)];
+    this.lastGreetingAt = now;
+    return { action: Action.speech(text) };
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, corpse: CorpseTarget | null): 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 (corpse) {
+      const label = corpse.name ?? '未知';
+      msg += corpseAtScene(state)
+        ? `，在${label}的尸体附近徘徊。`
+        : `，正前往${label}的尸体所在位置。`;
+    } else {
+      const target = this.patrol.nextRoom(ctx);
+      if (target) {
+        msg += `，巡逻中，正在前往${target.name}。`;
+      } else {
+        msg += `，巡逻中。`;
+      }
+    }
+    msg += ` 共${ctx.rooms.length}个房间。`;
+
+    ctx.notifications.push(msg);
+  }
+}

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

@@ -0,0 +1,93 @@
+import type { GameState } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  corpseAtScene,
+  dist,
+  KILL_RANGE,
+  nearestReportableCorpse,
+  nonTeammatesVisible,
+  reportCorpseDecision,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+
+/**
+ * 蟹（坏人）/ 章鱼（中立带刀）默认策略共享的「反射动作」——由 CrabSabotageTop 与 LoneKillTaskTop
+ * 在各自 tick() 的**最前面**调用，抢在破坏/任务/落单猎杀编排之前先处理两类即时机会：
+ *
+ * - immediateLoneKillDecision：唯一一个落单非队友就贴在脸上(≤KILL_RANGE)且刀好 → 立刻出刀。它无视
+ *   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}在场，靠近尸体准备报告自证。`),
+  }];
+}
+
+/** 唯一一个落单非队友贴脸(≤KILL_RANGE)且刀好 → 立刻出刀；否则 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 > KILL_RANGE) 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;
+}