@myclaw163/clawclaw-cli 0.6.67 → 0.6.68

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

@@ -1,5 +1,6 @@
 import type { GameState } from '../../sdk/types.js';
 import {
+  emergencyRushDecision,
   firstAvailableTask,
   killCooldownSecs,
   nonTeammatesVisible,
@@ -11,7 +12,7 @@ import { Goal } from './goal.js';
 import { LoneKillCore } from './lone-kill-core.js';
 import { LoneKillGoal } from './lone-kill-goal.js';
 import { WanderTaskGoal } from './wander-task-goal.js';
-import { emitLeaf, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
+import { emitLeaf, EMERGENCY_GOAL_PRIORITY, setBehavior, URGENT_GOAL_PRIORITY, WANDER_GOAL_PRIORITY } from './leaf-goal.js';
 import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-octopus-reflexes.js';
 
 /**
@@ -22,7 +23,9 @@ import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-o
  *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
  * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
  *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。
- * 2. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务；章鱼不能提交紧急维修任务，
+ * 2. 残局抢修紧急任务（EMERGENCY，仅已知存活≤6）：低于落单猎杀（击杀优先），高于伪装任务——
+ *    紧急任务超时则蟹阵营直接获胜，中立章鱼靠活到最后取胜，故残局抢着把维修做掉、掐断蟹的破坏取胜线。
+ * 3. 任务伪装 / 巡逻（WanderTaskGoal，WANDER）：做已分配的伪装任务（排除当前紧急任务，那个走第 2 步），
  *    跳过紧挨已知尸体（含看见过、已离开视野的）的任务，没任务就按房间巡逻，绝不停在原地。
  */
 export class LoneKillTaskTop extends Goal {
@@ -30,7 +33,14 @@ export class LoneKillTaskTop extends Goal {
   private readonly patrol = new PatrolState();
   private readonly loneKillGoal = new LoneKillGoal(this.killCore);
   private readonly wanderGoal = new WanderTaskGoal(
-    (state, ctx) => firstAvailableTask(ctx.taskData, () => true, undefined, ctx.blockedMoveTarget, ctx.knownCorpses),
+    // 排除当前紧急任务：它由 tick 里的残局抢修分支按 EMERGENCY 优先级处理，不在此当普通伪装任务做。
+    (state, ctx) => firstAvailableTask(
+      ctx.taskData,
+      t => t.task_name !== ctx.emergency?.task_name,
+      undefined,
+      ctx.blockedMoveTarget,
+      ctx.knownCorpses,
+    ),
     () => this.killCore.patrolStopOnPlayer(),
     this.patrol,
   );
@@ -40,28 +50,49 @@ export class LoneKillTaskTop extends Goal {
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
-    this.emitProgress(state, ctx);
-
     const immediateKill = immediateLoneKillDecision(state, ctx);
-    if (immediateKill) return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+    if (immediateKill) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, immediateKill, URGENT_GOAL_PRIORITY);
+    }
 
     const corpseReport = corpseReportWithNonTeammate(state, ctx);
-    if (corpseReport) return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+    if (corpseReport) {
+      this.emitProgress(state, ctx, false);
+      return emitLeaf(this, corpseReport, URGENT_GOAL_PRIORITY);
+    }
 
     const target = this.killCore.assess(state, ctx);
     if (target.kind === 'hunt') {
+      this.emitProgress(state, ctx, false);
       this.loneKillGoal.setTarget(target.target);
       return setBehavior(this, this.loneKillGoal, URGENT_GOAL_PRIORITY);
     }
+
+    // 残局抢修紧急任务（已知存活≤6）：高于伪装任务，低于上面的落单猎杀/反射。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.emitProgress(state, ctx, true);
+      return emitLeaf(this, [emergency], EMERGENCY_GOAL_PRIORITY);
+    }
+
+    this.emitProgress(state, ctx, false);
     return setBehavior(this, this.wanderGoal, WANDER_GOAL_PRIORITY);
   }
 
-  private emitProgress(state: GameState, ctx: StrategyContext): void {
+  private emitProgress(state: GameState, ctx: StrategyContext, emergencyRush: boolean): void {
     const now = Date.now();
     if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
     ctx.lastProgressNotifyAt = now;
 
     const room = state.you.room ?? '未知';
+    if (emergencyRush) {
+      const name = ctx.emergency?.task_name ?? '紧急维修';
+      ctx.notifications.push(
+        `[进度] 当前在${room}，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`,
+      );
+      return;
+    }
     const cd = killCooldownSecs(state);
     const killsRemaining = state.you.kills_remaining;
     const nonTeammates = nonTeammatesVisible(state, ctx);

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

@@ -4,7 +4,7 @@ import {
   dist,
   firstAvailableTask,
   hasKnownCorpse,
-  isKnowledgeThreat,
+  isKnowledgeHostile,
   isKnowledgeTrusted,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -39,8 +39,8 @@ type Tier = 'flee-bad' | 'keep-distance' | 'task';
  *
  * - P0 发现尸体：一律报警（reportCorpseDecision），必要时提示 Agent 更新尸体旁玩家记忆。
  * - P1 规避危险：
- *   · A 视野里有威胁（知识库 suspect/hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
- *   · B 无可信同伴且陌生人贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
+ *   · A 视野里有坏人（知识库 hostile）→ 寻路躲避（KeepAwayGoal，不限距离）。
+ *   · B 无可信同伴且被怀疑者（未标记 = 默认被怀疑）贴近（≤270px）→ 先拉开距离（KeepAwayGoal，拉开到 300px 即回任务）。
  *     目击者豁免：当前见到 ≥2 个陌生人时不触发后撤（蟹不敢当众动手，独处才危险）；
  *     进行中的后撤也会重新判定，只有仍是单陌生人危险时才拉满到 300px。豁免期间陌生人也不算任务威胁点。
  * - P2 紧急任务：无危险时优先处理。
@@ -54,7 +54,7 @@ export class NormalShrimpTop extends Goal {
     // 豁免期间陌生人不算威胁点（与 B 档不触发保持视野半径对齐），认定坏人始终算。
     (s, c) => nonTeammatesVisible(s, c)
       .filter(p => !this.isTrusted(p, c))
-      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
+      .filter(p => this.isHostile(p, c) || !this.witnessExempt)
       .map(p => ({ x: p.x, y: p.y })),
   );
   private readonly strangerSeenAt = new Map<string, number>();
@@ -91,10 +91,10 @@ export class NormalShrimpTop extends Goal {
     }
 
     // ── P1-A 视野里有认定坏人 → 寻路躲避 ──
-    const threats = visible.filter(p => this.isThreat(p, ctx));
+    const threats = visible.filter(p => this.isHostile(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)), {
+      this.setKeepAway(FLEE_BAD_KEY, (s, c) => nonTeammatesVisible(s, c).filter(p => this.isHostile(p, c)), {
         threatRadius: Infinity,
         noun: '认定坏人',
       });
@@ -153,9 +153,9 @@ export class NormalShrimpTop extends Goal {
     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);
+  /** 坏人：知识库 hostile（明确敌对）。被怀疑者（未标记）不在此列，走 B 档保持距离。 */
+  private isHostile(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeHostile(p, ctx);
   }
 
   /** 可信同伴：知识库 trusted。 */
@@ -185,7 +185,7 @@ export class NormalShrimpTop extends Goal {
       if (!key || this.corpseWitnessNotified.has(key)) continue;
       this.corpseWitnessNotified.add(key);
 
-      if (this.isThreat(player, ctx)) bad.push(player.name);
+      if (this.isHostile(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);
@@ -217,7 +217,7 @@ export class NormalShrimpTop extends Goal {
 
     let msg = `[进度] 当前在${room}`;
     if (tier === 'flee-bad') {
-      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
+      const names = visible.filter(p => this.isHostile(p, ctx)).map(p => p.name).join('、');
       msg += `，发现认定坏人${names}，正在远离。`;
     } else if (tier === 'keep-distance') {
       msg += `，陌生人靠得太近，先拉开距离再做任务。`;

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

@@ -1,8 +1,9 @@
 import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
 import {
   corpseAtScene,
+  emergencyRushDecision,
   hasKnownCorpse,
-  isKnowledgeThreat,
+  isKnowledgeHostile,
   isKnowledgeTrusted,
   nonTeammatesVisible,
   PatrolState,
@@ -20,7 +21,7 @@ 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';
+type Tier = 'emergency' | 'corpse' | 'flee-bad' | 'keep-distance' | 'huddle' | 'wander';
 
 export class ParadiseFishTop extends Goal {
   private readonly linger = new LingerCorpseGoal((state, ctx) => this.visibleAvoidTargets(state, ctx));
@@ -39,16 +40,16 @@ export class ParadiseFishTop extends Goal {
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
     const visible = nonTeammatesVisible(state, ctx);
-    const threatTargets = visible.filter(p => this.isThreat(p, ctx));
+    const threatTargets = visible.filter(p => this.isHostile(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)), {
+      const decisions: BehaviorDecision[] = [];
+      const greeting = this.greeting.tryGreeting(state);
+      if (greeting) decisions.push(greeting);
+      this.setKeepAway('pf-flee-bad', (s, c) => nonTeammatesVisible(s, c).filter(p => this.isHostile(p, c)), {
         threatRadius: Infinity,
         noun: '认定带刀坏人',
       });
@@ -56,6 +57,18 @@ export class ParadiseFishTop extends Goal {
       return decisions;
     }
 
+    // 残局抢修紧急任务（已知存活≤6）：仅次于躲避带刀坏人，先于保持距离/贴尸/抱团。
+    const emergency = emergencyRushDecision(state, ctx);
+    if (emergency) {
+      this.clearSub();
+      this.emitProgress(state, ctx, visible, 'emergency');
+      return [emergency];
+    }
+
+    const decisions: BehaviorDecision[] = [];
+    const greeting = this.greeting.tryGreeting(state);
+    if (greeting) decisions.push(greeting);
+
     if (strangerAvoidTargets.length > 0) {
       this.setKeepAway('pf-keep-distance', (s, c) => this.strangerAvoidTargets(nonTeammatesVisible(s, c), c), {
         threatRadius: Infinity,
@@ -91,8 +104,9 @@ export class ParadiseFishTop extends Goal {
     return [...this.wander(state, ctx), ...decisions];
   }
 
-  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
-    return isKnowledgeThreat(p, ctx) && !this.isTrusted(p, ctx);
+  /** 坏人：知识库 hostile（明确敌对带刀者）。被怀疑者（未标记）走下面的保持距离档。 */
+  private isHostile(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeHostile(p, ctx);
   }
 
   private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
@@ -101,14 +115,14 @@ export class ParadiseFishTop extends Goal {
 
   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));
+    const nonBad = visible.filter(p => !this.isHostile(p, ctx));
     if (nonBad.length >= WITNESS_EXEMPT_COUNT) return [];
-    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isThreat(p, ctx));
+    return visible.filter(p => !this.isTrusted(p, ctx) && !this.isHostile(p, ctx));
   }
 
   private visibleAvoidTargets(state: GameState, ctx: StrategyContext): PlayerInfo[] {
     const visible = nonTeammatesVisible(state, ctx);
-    const threats = visible.filter(p => this.isThreat(p, ctx));
+    const threats = visible.filter(p => this.isHostile(p, ctx));
     return threats.length > 0 ? threats : this.strangerAvoidTargets(visible, ctx);
   }
 
@@ -132,7 +146,7 @@ export class ParadiseFishTop extends Goal {
         this.recentAvoidPoints.delete(key);
         continue;
       }
-      const threat = this.isThreat(p, ctx);
+      const threat = this.isHostile(p, ctx);
       if (!threat && !avoidNonThreat) {
         this.recentAvoidPoints.delete(key);
         continue;
@@ -183,7 +197,10 @@ export class ParadiseFishTop extends Goal {
 
     const room = state.you.room ?? '未知';
     let msg = `[进度] 当前在${room}`;
-    if (tier === 'corpse') {
+    if (tier === 'emergency') {
+      const name = ctx.emergency?.task_name ?? '紧急维修';
+      msg += `，残局仅剩${state.alive_count}人，抢着去做紧急任务「${name}」，阻止蟹靠破坏倒计时取胜。`;
+    } else if (tier === 'corpse') {
       // corpseAtScene=已贴近尸体(≤150px)；仅凭记忆走向尸体房间、人还没到时别谎报「在尸体附近游走」。
       if (!corpseAtScene(state)) {
         msg += '，记得有尸体，正前往尸体处（不报警）。';
@@ -193,7 +210,7 @@ export class ParadiseFishTop extends Goal {
           : '，发现尸体，附近无人，贴着尸体游走制造嫌疑（不报警）。';
       }
     } else if (tier === 'flee-bad') {
-      const names = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name).join('、');
+      const names = visible.filter(p => this.isHostile(p, ctx)).map(p => p.name).join('、');
       msg += `，发现认定带刀坏人${names}，正在远离。`;
     } else if (tier === 'keep-distance') {
       msg += `，附近有${visible.length}人但无可信同伴，保持距离中。`;

package/src/strategies/goals/warrior-shrimp-top.test.ts

@@ -29,7 +29,7 @@ function state(): GameState {
   };
 }
 
-function knowledge(mark: 'suspect' | 'hostile' | 'trusted') {
+function knowledge(mark: 'hostile' | 'trusted') {
   const ts = Date.now();
   const file: KnowledgeFile = {
     version: 1,
@@ -68,10 +68,11 @@ function context(overrides: Partial<StrategyContext> = {}): StrategyContext {
 }
 
 describe('WarriorShrimpTop knowledge tiers', () => {
-  it('avoids a suspect even when the weapon is ready', () => {
+  it('keeps distance from an unmarked (suspected-by-default) player even when the weapon is ready', () => {
     const top = new WarriorShrimpTop();
 
-    top.tick(state(), context({ knowledge: knowledge('suspect') }));
+    // 不打任何标记：未标记 = 默认被怀疑 → 只保持距离，刀好也不主动出刀。
+    top.tick(state(), context());
 
     expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
   });