@myclaw163/clawclaw-cli 0.6.68 → 0.6.70

package/src/runtime/event-daemon.ts

@@ -33,6 +33,26 @@ function cleanObject<T extends Record<string, any>>(obj: T): T {
   return obj;
 }
 
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value);
+}
+
+function playersFromMap(mapData: any): Array<{ name: string; seat: number }> {
+  if (!mapData || typeof mapData !== 'object' || !Array.isArray(mapData.all_players)) return [];
+  const players: Array<{ name: string; seat: number }> = [];
+  for (const player of mapData.all_players) {
+    if (typeof player?.name !== 'string' || !isFiniteNumber(player.seat)) continue;
+    players.push({ name: player.name, seat: player.seat });
+  }
+  return players;
+}
+
+function seatMapFromPlayers(players: Array<{ name: string; seat: number }>): Record<string, number> {
+  const seats: Record<string, number> = {};
+  for (const player of players) seats[player.name] = player.seat;
+  return seats;
+}
+
 function isGameOverState(data: Record<string, any>): boolean {
   return data.phase === 'game_over';
 }
@@ -112,6 +132,8 @@ export class EventRuntime {
   private currentYou: Record<string, any> = {};
   private currentGame: Record<string, any> = {};
   private currentUrgent: Record<string, any> = {};
+  private currentAllPlayers: Array<{ name: string; seat: number }> = [];
+  private currentSeatMap: Record<string, number> = {};
   private mapCacheLoaded = false;
   private mapCachePromise: Promise<void> | null = null;
   private currentMeetingRound = 0;
@@ -217,8 +239,24 @@ export class EventRuntime {
     this.mapCachePromise = this.client.getMap()
       .then((mapData) => {
         if (!mapData || typeof mapData !== 'object') return;
+        const players = playersFromMap(mapData);
+        if (players.length > 0) {
+          this.currentAllPlayers = players;
+          this.currentSeatMap = seatMapFromPlayers(players);
+          this.currentGame = cleanObject({
+            ...this.currentGame,
+            all_players: this.currentAllPlayers,
+            all_seats: this.currentSeatMap,
+          });
+          const myName = this.currentYou.name ?? this.profileName;
+          const mySeat = typeof myName === 'string' ? this.currentSeatMap[myName] : undefined;
+          if (mySeat !== undefined) {
+            this.currentYou = { ...this.currentYou, seat: this.currentYou.seat ?? mySeat };
+          }
+          this.writeFeed();
+        }
         this.playerHistory?.updateMapCache(mapData);
-        this.mapCacheLoaded = true;
+        if (players.length > 0) this.mapCacheLoaded = true;
       })
       .catch(() => {})
       .finally(() => {
@@ -268,11 +306,18 @@ export class EventRuntime {
     const stateSaysGameOver = isGameOverState(s);
     this.currentPhase = s.phase ?? this.currentPhase;
     this.currentYou = s.you ? { ...s.you } : this.currentYou;
-    this.currentGame = {
+    const myName = this.currentYou.name ?? this.profileName;
+    const mySeat = typeof myName === 'string' ? this.currentSeatMap[myName] : undefined;
+    if (this.currentYou.seat === undefined && mySeat !== undefined) {
+      this.currentYou = { ...this.currentYou, seat: mySeat };
+    }
+    this.currentGame = cleanObject({
       game_id: s.game_id,
       alive_count: s.alive_count,
       task_progress: s.task_progress,
-    };
+      all_players: this.currentAllPlayers.length > 0 ? this.currentAllPlayers : undefined,
+      all_seats: Object.keys(this.currentSeatMap).length > 0 ? this.currentSeatMap : undefined,
+    });
     if (this.currentPhase !== 'lobby') this.refreshPlayerHistoryMapCache();
 
     if (s.meeting) {
@@ -375,6 +420,9 @@ export class EventRuntime {
         this.refreshPlayerHistoryMapCache();
         this.playerHistory?.recordPlayerSpotted(data);
       }
+      if (data.type === 'role_assigned' || data.type === 'game_started' || data.type === 'crab_teammates') {
+        this.refreshPlayerHistoryMapCache();
+      }
 
       if (data.type === 'meeting_start' || data.type === 'meeting_started') {
         this.currentMeetingRound += 1;

package/src/sdk/index.ts

@@ -52,7 +52,7 @@ export type {
 // Game utilities (for user strategies)
 export {
   dist, firstAvailableTask, nearestKnownCorpse, nearestKnownCorpseNav, hasKnownCorpse, corpseAtScene, nearestReportableCorpse,
-  emergencyRushDecision, EMERGENCY_RUSH_ALIVE_THRESHOLD,
+  emergencyRushDecision, activeEmergencyRushTask, killYieldsToEmergencyRepair, EMERGENCY_RUSH_ALIVE_THRESHOLD,
   safePatrolStep,
   nonTeammatesVisible, matchesTarget, isTargetAlive,
   nearestVisibleTarget, pursueVisibleTarget,

package/src/strategies/avoid-lone.ts

@@ -4,6 +4,7 @@ import { AvoidLoneTop } from './goals/avoid-lone-top.js';
 
 export const strategy: StrategyEntry = {
   id: 'avoid-lone',
+  name: '结伴',
   description: '避免落单。视野里只有一个人时寻路躲避主动避开（推演逃点、持续远离）；视野里有两人以上时跟住次近的玩家、把可见人数维持在 ≥2（最近的人本就贴着不会丢，次近的人才是跌回一对一的临界）；持续无人或没有当前目标时巡逻。',
   create() {
     return new GoalRootStrategy('avoid-lone', () => new AvoidLoneTop(), { resetOnMeetingResume: false });

package/src/strategies/avoid-players.ts

@@ -5,6 +5,7 @@ import { parseTargetArgs } from './player-targets.js';
 
 export const strategy: StrategyEntry = {
   id: 'avoid-players',
+  name: '避人',
   description: '回避玩家：按房间顺序巡逻，视野里出现回避目标就寻路躲避（推演逃点、持续远离），威胁消失后恢复巡逻。回避名单 = 启动参数（座位号或名字，可多人，可省略）∪ 知识库中标记为 hostile（坏人）的玩家；trusted 与未标记的被怀疑者都不自动回避（要躲就标 hostile 或用启动参数点名）。Agent 可用 `ccl knowledge mark` 动态改判，免重启。',
   create(args?: string[]) {
     const targets = args ? parseTargetArgs(args) : [];

package/src/strategies/corpse-patrol.ts

@@ -15,6 +15,7 @@ class CorpsePatrolStrategy extends GoalRootStrategy {
 
 export const strategy: StrategyEntry = {
   id: 'corpse-patrol',
+  name: '守尸',
   description: '发现尸体就在附近40至100距离内随机游荡，但不报告——故意在尸体旁出没制造嫌疑感。没有尸体时巡逻各房间。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。不做任务，不杀人；但残局（已知存活≤6）出现紧急维修任务时例外，会最高优先级抢着去做，阻止蟹靠破坏倒计时取胜。（天堂鱼默认；进阶版见 paradise-fish）参数：可选：1~3 条打招呼话术。',
   create(args?: string[]) {
     return new CorpsePatrolStrategy(parseGreetingArgs(args, 'corpse-patrol'));

package/src/strategies/crab-sabotage.ts

@@ -6,6 +6,7 @@ import { SpeechModule, getSpeechConfigForRole } from './speech-module.js';
 
 export const strategy: StrategyEntry = {
   id: 'crab-sabotage',
+  name: '破坏蟹',
   description: '优先完成蟹的真实破坏任务（破坏点紧挨已知尸体时会跳过）；做完立刻触发紧急警报；警报期照样会被举报、不乱杀，只清真正落单的目标。有紧急事件时跳过破坏流程。视野里只有一个非队友且冷却可用就靠近，进入50距离就立刻出刀，即使正在做破坏任务；刀在冷却时不追不等、改做低优先级任务伪装，冷却好且目标仍落单可见再出刀；正在做任务时不会撇下任务去追猎（贴脸且刀好仍会立刻出刀）。发现尸体且附近有非队友、但当前不能原地出刀时，会靠近并报告尸体。视野里出现两人以上时，暂停攻击10秒并做任务伪装，先做真实任务再做虾的伪装任务；选任务时会跳过紧挨已知尸体（含看见过、已离开视野的）的任务。没有可做任务时按房间巡逻，绝不停在原地。（普通蟹默认）',
   create(args?: string[]) {
     const role = args?.[0] ?? 'crab_generic';

package/src/strategies/custom-module.test.ts

@@ -73,6 +73,7 @@ class TestCustomModuleStrategy implements Strategy {
 
 const testEntry: StrategyEntry = {
   id: 'test-custom-module',
+  name: 'test-custom-module',
   description: 'Internal test strategy for CustomModule verification.',
   create() {
     return new TestCustomModuleStrategy();

package/src/strategies/find-player.ts

@@ -5,6 +5,7 @@ import { parseTargetArgs } from './player-targets.js';
 
 export const strategy: StrategyEntry = {
   id: 'find-player',
+  name: '盯人',
   description: '全力寻找并贴身跟踪一个指定目标（座位号或名字，单个）。看到就贴上去近距离尾随（约40距离）；跟丢就先奔向最后出现的位置，再按房间顺序不停巡逻直到目标重新出现，绝不放弃。只跟踪、不出刀、不做任务、不报告；目标死亡即停。',
   create(args?: string[]) {
     const targets = args ? parseTargetArgs(args) : [];

package/src/strategies/game-utils.test.ts

@@ -1,7 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import type { GameState, TaskInfo } from '../sdk/types.js';
 import type { StrategyContext } from './types.js';
-import { CorpseMemory, firstAvailableTask, nearestSafeTask, PatrolState, safePatrolStep } from './game-utils.js';
+import {
+  CorpseMemory,
+  emergencyRushDecision,
+  firstAvailableTask,
+  killYieldsToEmergencyRepair,
+  nearestSafeTask,
+  PatrolState,
+  safePatrolStep,
+} from './game-utils.js';
 
 function state(overrides: Partial<GameState> = {}): GameState {
   return {
@@ -163,6 +171,50 @@ describe('safePatrolStep', () => {
   });
 });
 
+describe('emergency repair kill yielding', () => {
+  function emergencyContext(overrides: Partial<StrategyContext> = {}): StrategyContext {
+    return context({
+      emergency: {
+        task_id: 'repair',
+        task_name: 'repair',
+        room: 'control',
+        status: 'emergency',
+        x: 100,
+        y: 0,
+        remaining_secs: 45,
+      },
+      ...overrides,
+    });
+  }
+
+  it('yields near the repair task at one player above the rush threshold', () => {
+    const repairState = state({ alive_count: 7 });
+    const ctx = emergencyContext();
+
+    expect(killYieldsToEmergencyRepair(
+      repairState,
+      ctx,
+      { room: 'control', x: 130, y: 0 },
+    )).toBe(true);
+    expect(emergencyRushDecision(repairState, ctx)).toBeNull();
+  });
+
+  it('does not yield before the one-player buffer', () => {
+    expect(killYieldsToEmergencyRepair(
+      state({ alive_count: 8 }),
+      emergencyContext(),
+      { room: 'control', x: 130, y: 0 },
+    )).toBe(false);
+  });
+
+  it('still rushes the repair task at the endgame threshold', () => {
+    const decision = emergencyRushDecision(state({ alive_count: 6 }), emergencyContext());
+
+    expect(decision?.action.type).toBe('move');
+    expect(decision?.action.payload).toMatchObject({ target_x: 100, target_y: 0 });
+  });
+});
+
 describe('nearestSafeTask', () => {
   // 威胁贴在起点旁（视野内 ~52px），唯一安全任务远在反方向、离威胁 556px（> 端点
   // 排除半径 500）。修复前 pathNearAny 会因起点采样紧贴威胁把整条「背向威胁」的路线判危，

package/src/strategies/game-utils.ts

@@ -65,23 +65,33 @@ function normalizeRoom(room?: string): string {
 }
 
 /**
- * 任务点是否落在「尸体回避区」，供做任务伪装的角色跳过命案房间的任务。命中其一即算：
- * 1. **同房间**：任务与任一已知尸体在同一个（非走廊）房间——房间级回避，自动随房间尺寸缩放，
- *    这样坏人杀完不会回到陈尸的那个房间里做任务，哪怕任务点离尸体有大半个房间远。
- * 2. **距离兜底**：欧氏距离 ≤ CORPSE_TASK_AVOID_RANGE——覆盖尸体贴门跨到隔壁房间、或尸体/任务
- *    缺房间标签（走廊命案、坐标未回填）的情形。
+ * 两点是否「紧挨」——命中其一即算：
+ * 1. **同房间**：两者在同一个（非走廊）房间——房间级判据，自动随房间尺寸缩放。
+ * 2. **距离兜底**：欧氏距离 ≤ range——覆盖贴门跨到隔壁房间、或缺房间标签（走廊、坐标未回填）的情形。
+ * 供「避开尸体做任务」「残局维修点附近不杀人」等「某点是否紧挨某参照点」的判断统一复用。
+ */
+export function sameRoomOrWithinRange(
+  a: { x?: number; y?: number; room?: string },
+  b: { x?: number; y?: number; room?: string },
+  range: number,
+): boolean {
+  const ar = normalizeRoom(a.room);
+  if (ar && ar === normalizeRoom(b.room)) return true;
+  return a.x != null && a.y != null && b.x != null && b.y != null
+    && dist(a.x, a.y, b.x, b.y) <= range;
+}
+
+/**
+ * 任务点是否落在「尸体回避区」，供做任务伪装的角色跳过命案房间的任务。命中其一即算（同房间 / 欧氏
+ * 距离 ≤ CORPSE_TASK_AVOID_RANGE，见 sameRoomOrWithinRange）：这样坏人杀完不会回到陈尸的那个房间里
+ * 做任务，哪怕任务点离尸体有大半个房间远；距离兜底覆盖尸体贴门跨房、或尸体/任务缺房间标签的情形。
  */
 export function taskNearKnownCorpse(
   task: { x?: number; y?: number; room?: string },
   avoidCorpses?: CorpseInfo[] | null,
 ): boolean {
   if (!avoidCorpses || avoidCorpses.length === 0) return false;
-  const taskRoom = normalizeRoom(task.room);
-  return avoidCorpses.some(c => {
-    if (taskRoom && normalizeRoom(c.room) === taskRoom) return true;
-    return c.x != null && c.y != null && task.x != null && task.y != null
-      && dist(task.x, task.y, c.x, c.y) <= CORPSE_TASK_AVOID_RANGE;
-  });
+  return avoidCorpses.some(c => sameRoomOrWithinRange(task, c, CORPSE_TASK_AVOID_RANGE));
 }
 
 export function firstAvailableTask(
@@ -330,21 +340,63 @@ export function taskMoveDecision(state: GameState, ctx: StrategyContext, task: T
 /** 已知存活人数 ≤ 此值才触发「残局抢修紧急任务」。 */
 export const EMERGENCY_RUSH_ALIVE_THRESHOLD = 6;
 
+/** 当前是否有「进行中、带坐标」的紧急维修任务（不看存活人数门槛）。 */
+function pendingEmergencyRepair(ctx: StrategyContext): EmergencyInfo | null {
+  const e = ctx.emergency;
+  if (!e || e.status === 'completed' || e.x == null || e.y == null) return null;
+  return e;
+}
+
 /**
- * 残局抢修紧急维修任务的「靠近 → 到点提交」决策：已知存活人数（state.alive_count，含本玩家尚未目睹其
- * 死亡者）≤ EMERGENCY_RUSH_ALIVE_THRESHOLD 且当前有进行中的紧急任务时返回该单步决策，否则返回 null
+ * 残局抢修是否「该生效」：已知存活人数（state.alive_count，含本玩家尚未目睹其死亡者）≤
+ * EMERGENCY_RUSH_ALIVE_THRESHOLD 且当前有进行中、带坐标的紧急维修任务时返回该任务，否则 null。
+ * 这是 emergencyRushDecision「奔去维修」的门槛；「维修点附近不杀人」（killYieldsToEmergencyRepair）
+ * 共用同一个紧急任务判定，但存活门槛比这里高一人，原因见该函数注释。
+ */
+export function activeEmergencyRushTask(state: GameState, ctx: StrategyContext): EmergencyInfo | null {
+  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD) return null;
+  return pendingEmergencyRepair(ctx);
+}
+
+/**
+ * 残局抢修紧急维修任务的「靠近 → 到点提交」单步决策：activeEmergencyRushTask 生效时返回该决策，否则 null
  * （行为不触发，调用方按自身原优先级继续）。
  *
  * 背景：紧急任务超时则蟹阵营直接获胜（后端倒计时），而中立的章鱼/天堂鱼要靠活到最后取胜，因此残局应抢着
  * 把维修做掉、掐断蟹的破坏取胜线。服务端已放开中立/蟹阵营提交紧急任务。紧急任务被任意玩家完成 / 开会 /
- * 超时后，服务端会清空 state.emergency（→ ctx.emergency 为 null），本函数随之自动返回 null。
+ * 超时后，服务端会清空 state.emergency（→ ctx.emergency 为 null），activeEmergencyRushTask 随之自动返回 null。
  */
 export function emergencyRushDecision(state: GameState, ctx: StrategyContext): BehaviorDecision | null {
-  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD) {
+  const task = activeEmergencyRushTask(state, ctx);
+  if (!task) return null;
+  // 维修点恰是上一帧被挡的移动目标 → 本帧让出（与旧 firstAvailableTask 的 blocked 兜底一致），别对着堵点空撞。
+  if (ctx.blockedMoveTarget && dist(task.x!, task.y!, ctx.blockedMoveTarget.x, ctx.blockedMoveTarget.y) <= 10) {
     return null;
   }
-  const emergency = firstAvailableTask([], () => true, ctx.emergency, ctx.blockedMoveTarget);
-  return emergency ? taskMoveDecision(state, ctx, emergency) : null;
+  return taskMoveDecision(state, ctx, task);
+}
+
+/**
+ * 残局抢修期，落单目标是否「紧挨紧急维修点」而该让位于维修、不该追杀。
+ *
+ * 存活门槛比抢修本身（activeEmergencyRushTask，≤EMERGENCY_RUSH_ALIVE_THRESHOLD）**高一人**，因为出一刀
+ * 会让存活−1：alive_count == THRESHOLD+1 时此刻把这个落单目标杀掉，下一帧就跌进抢修档、又奔回这同一个维修点，
+ * 正好踩在自己刚造的尸体 + 涌来的虾群里，自证清白极难。所以 alive_count ≤ THRESHOLD+1 就让位。注意：把抢修
+ * 门槛整体抬到 7 治不了这个——边界只会平移到 8→7 复现同样的「杀完立刻奔回去维修」；真正的修法是让位档恒比
+ * 抢修档高 1。
+ *
+ * 命中还需有进行中带坐标的紧急维修、且目标与维修点同房间或在 CORPSE_TASK_AVOID_RANGE 内（复用做任务伪装时
+ * 「避开尸体」的同房间+距离判据）。远离维修点的落单目标不受影响，照常猎杀（抢修仍低于猎杀的设定不变）。
+ */
+export function killYieldsToEmergencyRepair(
+  state: GameState,
+  ctx: StrategyContext,
+  target: { x?: number; y?: number; room?: string },
+): boolean {
+  if (typeof state.alive_count !== 'number' || state.alive_count > EMERGENCY_RUSH_ALIVE_THRESHOLD + 1) return false;
+  const e = pendingEmergencyRepair(ctx);
+  if (!e) return false;
+  return sameRoomOrWithinRange(target, { x: e.x, y: e.y, room: e.room }, CORPSE_TASK_AVOID_RANGE);
 }
 
 export function nearestReportableCorpse(state: GameState): GameState['corpses'][number] | null {

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

@@ -1,4 +1,4 @@
-import type { GameState } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import { Action } from '../../sdk/action.js';
 import {
   canUseKill,
@@ -58,8 +58,15 @@ export function corpseReportWithNonTeammate(state: GameState, ctx: StrategyConte
   }];
 }
 
-/** 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
-export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
+/**
+ * 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。
+ * 可选 skipTarget：返回 true 的目标本帧不出刀（章鱼残局抢修期用它放过紧挨紧急维修点的目标）。
+ */
+export function immediateLoneKillDecision(
+  state: GameState,
+  ctx: StrategyContext,
+  skipTarget?: (target: PlayerInfo) => boolean,
+): BehaviorDecision[] | null {
   if (!canUseKill(state)) return null;
 
   const targets = nonTeammatesVisible(state, ctx);
@@ -68,6 +75,7 @@ export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext
   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;
+  if (skipTarget?.(target)) return null;
 
   ctx.notifications.push(`发现落单目标${target.name}就在身边，立刻出刀！`);
   return [{ action: Action.kill(target.name) }];

package/src/strategies/goals/keep-away-goal.ts

@@ -18,7 +18,7 @@ const PANIC_REPLAN_TARGET_SHIFT = 220;
  * keep-away 逃跑推演基线参数。各档（FLEE 不覆盖；陌生人覆盖 steps:4）在此基础上合并 options.planOpts。
  * killRange 取 SHRIMP_KILL_RANGE(160) 而非 planner 默认 80：本层威胁只有坐标、没有角色（resolver
  * 返回可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor，故统一用带刀虾兜底，
- * 宁可对蟹/章鱼多拉开也不对带刀好人少逃。武士虾自卫判定（warrior-shrimp-top）复用它，保证「避不开」口径一致。
+ * 宁可对蟹/章鱼多拉开也不对带刀好人少逃；带刀好人遇到未确认对象也只复用这一层做回避，不再自卫出刀。
  */
 export const KEEP_AWAY_BASE_PLAN_OPTS: EscapeOptions = {
   killRange: SHRIMP_KILL_RANGE,
@@ -39,8 +39,9 @@ export interface KeepAwayGoalOptions {
   finishWhenClear?: boolean;
   /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
   idleNotices?: boolean;
-  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。 */
-  noun?: string;
+  /** 通知措辞里威胁的称呼：发现{noun}{names}，{verb}到 (x, y)。传字符串则所有威胁共用一个称呼；传函数则
+   *  逐个威胁按其真实身份标注（如坏人/被怀疑者分别措辞），避免把混在一起躲的被怀疑者也一律叫成坏人。 */
+  noun?: string | ((p: PlayerInfo, ctx: StrategyContext) => string);
   /** 覆盖 planEscape 参数（与 PLAN_OPTS 合并）。 */
   planOpts?: EscapeOptions;
 }
@@ -201,11 +202,14 @@ export class KeepAwayGoal extends Goal {
     this.committed = target;
     this.lastCommitAt = Date.now();
     this.lastCommitWasPanic = panic;
-    const names = threats.map(p => p.name).join('、');
+    const noun = this.options.noun;
+    const body = typeof noun === 'function'
+      ? threats.map(p => `${noun(p, ctx)}${p.name}`).join('、')
+      : `${noun ?? ''}${threats.map(p => p.name).join('、')}`;
     this.notice(
       ctx,
       `${verb}:${targetKey(target)}`,
-      `发现${this.options.noun ?? ''}${names}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
+      `发现${body}，${verb}到 (${Math.round(target.x)}, ${Math.round(target.y)})。${detail}`,
     );
   }
 

package/src/strategies/goals/lone-kill-task-top.ts

@@ -1,8 +1,9 @@
-import type { GameState } from '../../sdk/types.js';
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import {
   emergencyRushDecision,
   firstAvailableTask,
   killCooldownSecs,
+  killYieldsToEmergencyRepair,
   nonTeammatesVisible,
   PatrolState,
   PROGRESS_INTERVAL_MS,
@@ -22,7 +23,9 @@ import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-o
  * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(出刀范围内)且刀好 →
  *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
  * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
- *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。
+ *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。**残局抢修期例外**：落单目标紧挨紧急维修点
+ *    （同房间或避尸距离内，killYieldsToEmergencyRepair）时跳过反射刀/落单猎杀，让位给第 2 步去修——虾群都
+ *    涌向维修点，在那儿动手必被围观、还会撇下维修把破坏倒计时取胜线让给蟹；远离维修点的目标照常猎杀。
  * 2. 残局抢修紧急任务（EMERGENCY，仅已知存活≤6）：低于落单猎杀（击杀优先），高于伪装任务——
  *    紧急任务超时则蟹阵营直接获胜，中立章鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
  * 3. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务（排除当前紧急任务，那个走第 2 步），
@@ -50,7 +53,12 @@ export class LoneKillTaskTop extends Goal {
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    const immediateKill = immediateLoneKillDecision(state, ctx);
+    // 残局抢修期：紧急维修点附近不杀人。虾群都涌向维修点，在那儿动手必被围观、还会撇下维修把破坏
+    // 倒计时取胜线让给蟹。落单目标紧挨维修点（同房间或避尸距离内）时跳过反射刀与落单猎杀，让位给下面
+    // 的抢修分支；远离维修点的目标照常猎杀（抢修仍低于猎杀的设定不变）。
+    const yieldsToRepair = (t: PlayerInfo) => killYieldsToEmergencyRepair(state, ctx, t);
+
+    const immediateKill = immediateLoneKillDecision(state, ctx, yieldsToRepair);
     if (immediateKill) {
       this.emitProgress(state, ctx, false);
       return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
@@ -63,7 +71,8 @@ export class LoneKillTaskTop extends Goal {
     }
 
     const target = this.killCore.assess(state, ctx);
-    if (target.kind === 'hunt') {
+    const sparedNearRepair = target.kind === 'hunt' && yieldsToRepair(target.target);
+    if (target.kind === 'hunt' && !sparedNearRepair) {
       this.emitProgress(state, ctx, false);
       this.loneKillGoal.setTarget(target.target);
       return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
@@ -72,7 +81,7 @@ export class LoneKillTaskTop extends Goal {
     // 残局抢修紧急任务（已知存活≤6）：高于伪装任务，低于上面的落单猎杀/反射。
     const emergency = emergencyRushDecision(state, ctx);
     if (emergency) {
-      this.emitProgress(state, ctx, true);
+      this.emitProgress(state, ctx, true, sparedNearRepair ? target.target.name : null);
       return emitLeaf(this, [emergency], EMERGENCY_GOAL_PRIORITY);
     }
 
@@ -80,7 +89,12 @@ export class LoneKillTaskTop extends Goal {
     return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
   }
 
-  private emitProgress(state: GameState, ctx: StrategyContext, emergencyRush: boolean): void {
+  private emitProgress(
+    state: GameState,
+    ctx: StrategyContext,
+    emergencyRush: boolean,
+    sparedNearRepair: string | null = null,
+  ): void {
     const now = Date.now();
     if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
     ctx.lastProgressNotifyAt = now;
@@ -88,9 +102,11 @@ export class LoneKillTaskTop extends Goal {
     const room = state.you.room ?? '未知';
     if (emergencyRush) {
       const name = ctx.emergency?.task_name ?? '紧急维修';
-      ctx.notifications.push(
-        `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`,
-      );
+      let msg = `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
+      if (sparedNearRepair) {
+        msg += ` 落单目标${sparedNearRepair}就在维修点附近，先修不杀，免得在虾群涌入的维修点暴露自己。`;
+      }
+      ctx.notifications.push(msg);
       return;
     }
     const cd = killCooldownSecs(state);