@myclaw163/clawclaw-cli 0.6.56 → 0.6.58

package/src/runtime/owner-control.ts

@@ -0,0 +1,150 @@
+import { createHash, randomBytes } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { connect, createServer, type Server } from 'net';
+
+export const GAME_START_RUNTIME_FILE = 'game-start.json';
+export const OWNER_CONTROL_TIMEOUT_MS = 2000;
+
+export type OwnerControlType = 'stop' | 'quit' | 'leave' | 'switch_strategy' | 'stop_strategy' | 'snapshot';
+
+export interface OwnerControlInfo {
+  kind: 'node-net-socket';
+  path: string;
+}
+
+export interface OwnerControlRequest {
+  token?: string;
+  type?: OwnerControlType;
+  strategy?: string;
+  args?: string[];
+}
+
+export interface OwnerControlResponse {
+  ok: boolean;
+  type?: string;
+  error?: string;
+  message?: string;
+  [key: string]: any;
+}
+
+export interface OwnerControlServer {
+  control: OwnerControlInfo;
+  token: string;
+  close: () => Promise<void>;
+}
+
+export function gameStartRuntimePath(stateDir: string): string {
+  return join(stateDir, GAME_START_RUNTIME_FILE);
+}
+
+export function readGameStartRuntime(stateDir: string): Record<string, any> | null {
+  const runtimePath = gameStartRuntimePath(stateDir);
+  if (!existsSync(runtimePath)) return null;
+  try {
+    return JSON.parse(readFileSync(runtimePath, 'utf8'));
+  } catch {}
+  return null;
+}
+
+function ownerControlPath(stateDir: string, pid: number): string {
+  const hash = createHash('sha1').update(stateDir).digest('hex').slice(0, 12);
+  if (process.platform === 'win32') return `\\\\.\\pipe\\clawclaw-${hash}-${pid}`;
+  const dir = join(tmpdir(), 'clawclaw');
+  mkdirSync(dir, { recursive: true });
+  return join(dir, `${hash}-${pid}.sock`);
+}
+
+export async function startOwnerControlServer(
+  stateDir: string,
+  onRequest: (request: OwnerControlRequest) => Promise<OwnerControlResponse> | OwnerControlResponse,
+): Promise<OwnerControlServer> {
+  const token = randomBytes(24).toString('hex');
+  const path = ownerControlPath(stateDir, process.pid);
+  if (process.platform !== 'win32') {
+    try { unlinkSync(path); } catch {}
+  }
+  const server: Server = createServer((socket) => {
+    let buffer = '';
+    socket.setEncoding('utf8');
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      const nl = buffer.indexOf('\n');
+      if (nl < 0) return;
+      const line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + 1);
+      void (async () => {
+        try {
+          const request = JSON.parse(line) as OwnerControlRequest;
+          if (request.token !== token) {
+            socket.end(JSON.stringify({ ok: false, error: 'invalid_token' }) + '\n');
+            return;
+          }
+          const response = await onRequest(request);
+          socket.end(JSON.stringify(response) + '\n');
+        } catch (err: any) {
+          socket.end(JSON.stringify({ ok: false, error: err?.message ?? String(err) }) + '\n');
+        }
+      })();
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(path, () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+  return {
+    control: { kind: 'node-net-socket', path },
+    token,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+    }),
+  };
+}
+
+export function sendOwnerControlRequest(
+  stateDir: string,
+  type: OwnerControlType,
+  payload: Record<string, any> = {},
+  timeoutMs = OWNER_CONTROL_TIMEOUT_MS,
+): Promise<OwnerControlResponse | null> {
+  const info = readGameStartRuntime(stateDir);
+  const path = typeof info?.control?.path === 'string' ? info.control.path : '';
+  const token = typeof info?.control_token === 'string' ? info.control_token : '';
+  if (!path || !token) return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    const socket = connect(path);
+    let buffer = '';
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error('owner_control_timeout'));
+    }, timeoutMs);
+    socket.setEncoding('utf8');
+    socket.on('connect', () => {
+      socket.write(JSON.stringify({ token, type, ...payload }) + '\n');
+    });
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      const nl = buffer.indexOf('\n');
+      if (nl < 0) return;
+      clearTimeout(timer);
+      socket.end();
+      try {
+        resolve(JSON.parse(buffer.slice(0, nl)));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    socket.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    socket.on('close', () => {
+      clearTimeout(timer);
+      if (!buffer) resolve(null);
+    });
+  });
+}

package/src/runtime/runtime-logger.ts

@@ -1,5 +1,5 @@
 /**
- * Runtime Logger — structured, leveled logging for the daemon and CLI.
+ * Runtime Logger — structured, leveled logging for the game runtime and CLI.
  *
  * Log format:  [Runtime:<LEVEL>] <EVENT_TAG> <message>
  *
@@ -10,6 +10,8 @@
  *   ERROR — failures that need attention (map load failed, tick error)
  *
  * Control via env var CLAWCLAW_LOG_LEVEL (default: DEBUG).
+ * Console output is disabled by default so game runtime diagnostics do not
+ * leak into Monitor streams. Set CLAWCLAW_RUNTIME_LOG_TO_CONSOLE=1 to print.
  */
 
 export enum LogLevel {
@@ -36,11 +38,17 @@ function parseLogLevel(raw: string | undefined): LogLevel {
   }
 }
 
+function isTrue(value: string | undefined): boolean {
+  return typeof value === 'string' && value.trim().toLowerCase() === 'true';
+}
+
 export class RuntimeLogger {
   private minLevel: LogLevel;
+  private logToConsole: boolean;
 
   constructor() {
     this.minLevel = parseLogLevel(process.env.CLAWCLAW_LOG_LEVEL);
+    this.logToConsole = isTrue(process.env.CLAWCLAW_RUNTIME_LOG_TO_CONSOLE);
   }
 
   // ─── Core log methods ────────────────────────────────────────────────────
@@ -60,8 +68,7 @@ export class RuntimeLogger {
   error(tag: string, msg: string, err?: unknown): void {
     const suffix = err instanceof Error ? ` err=${err.message}` : (err ? ` err=${err}` : '');
     this.log(LogLevel.ERROR, tag, msg + suffix);
-    // Print full stack trace for Error objects (preserves diagnostics from original console.error)
-    if (err instanceof Error && err.stack) {
+    if (this.logToConsole && err instanceof Error && err.stack) {
       console.error(err.stack);
     }
   }
@@ -82,6 +89,7 @@ export class RuntimeLogger {
 
   private log(level: LogLevel, tag: string, msg: string): void {
     if (level < this.minLevel) return;
+    if (!this.logToConsole) return;
     const prefix = `[Runtime:${LEVEL_NAMES[level]}]`;
     const line = `${prefix} ${tag} ${msg}`;
     switch (level) {

package/src/runtime/ws-client.test.ts

@@ -44,4 +44,61 @@ describe('WsClient', () => {
     wsMock.constructed[0].instance.onopen?.({});
     await connected;
   });
+
+  it('dispatches state.new_events before the _state snapshot', async () => {
+    const { WsClient } = await import('./ws-client.js');
+    const client = new WsClient({
+      url: 'wss://host.example/api/v1/game/stream',
+      apiKey: 'claw_secret',
+    });
+    const seen: Record<string, any>[] = [];
+    client.on('*', (event) => seen.push(event));
+
+    (client as any).handleMessage({
+      type: 'state',
+      data: {
+        phase: 'wandering',
+        tick: 20,
+        new_events: [{ type: 'game_over', tick: 20, winner: 'crab' }],
+      },
+    });
+
+    expect(seen).toEqual([
+      { type: 'game_over', tick: 20, winner: 'crab' },
+      {
+        type: '_state',
+        phase: 'wandering',
+        tick: 20,
+        new_events: [{ type: 'game_over', tick: 20, winner: 'crab' }],
+      },
+    ]);
+  });
+
+  it('dispatches a _state snapshot when phase is game_over without new_events', async () => {
+    const { WsClient } = await import('./ws-client.js');
+    const client = new WsClient({
+      url: 'wss://host.example/api/v1/game/stream',
+      apiKey: 'claw_secret',
+    });
+    const seen: Record<string, any>[] = [];
+    client.on('*', (event) => seen.push(event));
+
+    (client as any).handleMessage({
+      type: 'state',
+      data: {
+        phase: 'game_over',
+        tick: 21,
+        new_events: [],
+      },
+    });
+
+    expect(seen).toEqual([
+      {
+        type: '_state',
+        phase: 'game_over',
+        tick: 21,
+        new_events: [],
+      },
+    ]);
+  });
 });

package/src/runtime/ws-client.ts

@@ -1,6 +1,6 @@
 // src/runtime/ws-client.ts
 // Internal WebSocket client — NOT exported from index.ts
-// Used only by Runtime and daemon internally.
+// Used only by runtime listeners internally.
 
 import WebSocket from 'ws';
 import { WsConnectionState } from '../sdk/types.js';
@@ -129,7 +129,7 @@ export class WsClient {
       }
       return;
     }
-    // state: always dispatch the full snapshot as _state for daemon feed tracking
+    // state: always dispatch the full snapshot as _state for runtime feed tracking
     // (current_speaker, sub_phase, vote progress, etc. update without necessarily
     // shipping a new event). Process new_events with tick-based dedup if present.
     if (msg.type === 'state' && msg.data) {

package/src/sdk/index.ts

@@ -20,10 +20,10 @@
  *   · game-utils: dist / firstAvailableTask / nearestKnownCorpse / nearestKnownCorpseNav /
  *     hasKnownCorpse / corpseAtScene / nearestReportableCorpse / safePatrolStep /
  *     nonTeammatesVisible / matchesTarget / isTargetAlive / nearestVisibleTarget /
- *     pursueVisibleTarget / killCooldownSecs / hasKillUseRemaining / canUseKill /
+ *     pursueVisibleTarget / killCooldownSecs / hasKillUseRemaining / canUseKill / killRangeFor / killCommitRange /
  *     isKnowledgeHostile / isKnowledgeThreat / isKnowledgeTrusted
  *     (含 @deprecated 别名 isKnowledgeKillTarget / isKnowledgeAvoid / isKnowledgeProtected) /
- *     PatrolState / SafeTaskOptions / SafePatrolOptions + 常量(TASK_SUBMIT_RADIUS / KILL_RANGE /
+ *     PatrolState / SafeTaskOptions / SafePatrolOptions + 常量(TASK_SUBMIT_RADIUS /
  *     SHRIMP_VISION_RANGE / SHRIMP_VISION_EXIT_BUFFER / SHRIMP_VISION_RELEASE_RANGE /
  *     FOLLOW_RANGE / PATROL_REACHED_DISTANCE / PROGRESS_INTERVAL_MS)
  *   · Knowledge (ctx.knowledge): KnowledgeView / SubjectEntry / FactMeta /
@@ -56,11 +56,11 @@ export {
   safePatrolStep,
   nonTeammatesVisible, matchesTarget, isTargetAlive,
   nearestVisibleTarget, pursueVisibleTarget,
-  killCooldownSecs, hasKillUseRemaining, canUseKill,
+  killCooldownSecs, hasKillUseRemaining, canUseKill, killRangeFor, killCommitRange,
   isKnowledgeHostile, isKnowledgeThreat, isKnowledgeTrusted,
   isKnowledgeKillTarget, isKnowledgeAvoid, isKnowledgeProtected,
   PatrolState,
-  TASK_SUBMIT_RADIUS, KILL_RANGE, SHRIMP_VISION_RANGE, SHRIMP_VISION_EXIT_BUFFER, SHRIMP_VISION_RELEASE_RANGE,
+  TASK_SUBMIT_RADIUS, SHRIMP_VISION_RANGE, SHRIMP_VISION_EXIT_BUFFER, SHRIMP_VISION_RELEASE_RANGE,
   FOLLOW_RANGE, PATROL_REACHED_DISTANCE,
   PROGRESS_INTERVAL_MS,
 } from '../strategies/game-utils.js';

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { GameState, TaskInfo } from '../sdk/types.js';
 import type { StrategyContext } from './types.js';
-import { CorpseMemory, firstAvailableTask, PatrolState, safePatrolStep } from './game-utils.js';
+import { CorpseMemory, firstAvailableTask, nearestSafeTask, PatrolState, safePatrolStep } from './game-utils.js';
 
 function state(overrides: Partial<GameState> = {}): GameState {
   return {
@@ -162,3 +162,29 @@ describe('safePatrolStep', () => {
     expect(second[0].action.payload).toMatchObject({ target_x: 2602, target_y: 586 });
   });
 });
+
+describe('nearestSafeTask', () => {
+  // 威胁贴在起点旁（视野内 ~52px），唯一安全任务远在反方向、离威胁 556px（> 端点
+  // 排除半径 500）。修复前 pathNearAny 会因起点采样紧贴威胁把整条「背向威胁」的路线判危，
+  // 返回 null（虚假僵住）；修复后起点邻域被豁免，路线不再判危，应选中该任务。
+  // 坐标在真实可走网格上验证：start/threat/task 均吸附可走格、任务可达，
+  // 且去任务点的测地路径在起点 350px 邻域之外不再靠近威胁 350px 内。
+  it('returns a far safe task when a threat hugs the start', () => {
+    const routeState = state({ you: { ...state().you, x: 2514, y: 226 } });
+    const task = taskAt(2514, 730);
+    const threat = { x: 2514, y: 174 };
+
+    const result = nearestSafeTask(
+      routeState,
+      [task],
+      () => true,
+      null,
+      null,
+      null,
+      { threatPoints: [threat] },
+    );
+
+    expect(result).not.toBeNull();
+    expect(result).toMatchObject({ x: 2514, y: 730 });
+  });
+});

package/src/strategies/game-utils.ts

@@ -5,7 +5,10 @@ import { emptyKnowledgeView } from '../lib/knowledge-store.js';
 import { assessRoutes } from './pathfind/escape-planner.js';
 
 export const TASK_SUBMIT_RADIUS = 12;
-export const KILL_RANGE = 50;
+/** 蟹/章鱼/兜底角色的服务端击杀距离（= 后端全局 kill_range）。 */
+export const BASE_KILL_RANGE = 80;
+/** 武士虾/枪虾的服务端击杀距离（带刀好人，射程是蟹/章鱼的两倍）。 */
+export const SHRIMP_KILL_RANGE = 160;
 export const REPORT_RANGE = 150;
 export const SHRIMP_VISION_RANGE = 270;
 export const SHRIMP_VISION_EXIT_BUFFER = 30;
@@ -34,6 +37,19 @@ export function canUseKill(state: GameState): boolean {
   return hasKillUseRemaining(state) && killCooldownSecs(state) <= 0;
 }
 
+const KILL_COMMIT_FACTOR = 0.9;
+const LONG_RANGE_KILL_ROLES = new Set(['shrimp_warrior', 'shrimp_pistol']);
+
+/** 角色的服务端实际击杀距离，镜像后端 effective_kill_range。武士虾/枪虾 160，其余 80。 */
+export function killRangeFor(role: string | undefined): number {
+  return role && LONG_RANGE_KILL_ROLES.has(role) ? SHRIMP_KILL_RANGE : BASE_KILL_RANGE;
+}
+
+/** 机器人主动出刀的距离阈值：服务端击杀距离打 9 折（80→72，160→144），留余量避免目标在边界漂移导致空刀。 */
+export function killCommitRange(role: string | undefined): number {
+  return killRangeFor(role) * KILL_COMMIT_FACTOR;
+}
+
 export function dist(x1: number, y1: number, x2: number, y2: number): number {
   return Math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2);
 }
@@ -64,6 +80,10 @@ export function firstAvailableTask(
   }) ?? null;
 }
 
+// 路径半径可以 > 视野(270)：pathNearAny 已豁免「起点 radiusPx 邻域」，逃跑那刻起点紧贴
+// 威胁不再把整条背向路线判危，所以恢复成真正的「绕开把守者」避让距离。端点半径
+// TASK_THREAT_EXCLUDE_RANGE 只看任务点离威胁多近、与起点采样无关，按玩法风险单独取值。
+// 约束靠 game-utils.test.ts 的路线场景测试钉死（不加数值断言，因为旧的「< 视野」断言现在反而是错的）。
 /** 任务点离任一威胁点多近就算「在威胁旁」而被硬排除（欧氏即可——隔薄墙的威胁照样危险）。 */
 export const TASK_THREAT_EXCLUDE_RANGE = 500;
 /** 测地路径离任一威胁点多近就算「必经之路有危险」而被硬排除（治路上有人把守时的来回逡巡）。 */
@@ -231,7 +251,10 @@ function nextSafePatrolRoom(
   const viable = routes == null
     ? endpointSafe
     : endpointSafe.filter((_room, i) => !routes[i].nearThreat);
-  const selected = viable[0] ?? null;
+  // 所有路线被路径闸判危时退回端点已安全的 endpointSafe[0]（端点远离威胁、仅路线稍擦威胁边，
+  // 对「游荡制造嫌疑」已足够），而非 null 触发上层静默僵住；绝不退回不带过滤的 patrolStep
+  //（会径直走向正在躲的陌生人）。
+  const selected = viable[0] ?? endpointSafe[0] ?? null;
   if (!selected) return null;
   movePatrolToRoom(ctx, patrol, current, selected);
   return selected;
@@ -422,7 +445,7 @@ export class CorpseMemory {
 
   /**
    * 从任意事件数组补全 corpse_spotted 坐标——供 action 结果里的 new_events 用，绕开主循环 state.new_events
-   * 的共享游标竞态（daemon 可能先通过 WS 消费掉该事件，strategy 的 HTTP 轮询就再也看不到，尸体坐标永远进
+   * 的共享游标竞态（runtime WS listener 可能先通过 WS 消费掉该事件，strategy 的 HTTP 轮询就再也看不到，尸体坐标永远进
    * 不了记忆，导航类策略只能巡逻走开）。
    */
   ingestEvents(events: any[] | undefined): void {
@@ -585,7 +608,7 @@ export function pursueVisibleTarget(
 ): BehaviorDecision | null {
   const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
   if (opts.kill && !hasKillUseRemaining(state)) return null;
-  if (opts.kill && d <= KILL_RANGE && canUseKill(state)) {
+  if (opts.kill && d <= killCommitRange(state.you.role) && canUseKill(state)) {
     return { action: Action.kill(target.name) };
   }
   if (d > opts.followDistance) {

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

@@ -4,7 +4,7 @@ import {
   canUseKill,
   corpseAtScene,
   dist,
-  KILL_RANGE,
+  killCommitRange,
   nearestReportableCorpse,
   nonTeammatesVisible,
   reportCorpseDecision,
@@ -15,7 +15,7 @@ import type { BehaviorDecision, StrategyContext } from '../types.js';
  * 蟹（坏人）/ 章鱼（中立带刀）默认策略共享的「反射动作」——由 CrabSabotageTop 与 LoneKillTaskTop
  * 在各自 tick() 的**最前面**调用，抢在破坏/任务/落单猎杀编排之前先处理两类即时机会：
  *
- * - immediateLoneKillDecision：唯一一个落单非队友就贴在脸上(≤KILL_RANGE)且刀好 → 立刻出刀。它无视
+ * - immediateLoneKillDecision：唯一一个落单非队友就贴在脸上(出刀范围内)且刀好 → 立刻出刀。它无视
  *   LoneKillCore 的「暂停窗口」，也不管自己是否正在做破坏任务——只要能原地一刀就先杀。
  * - corpseReportWithNonTeammate：地上有尸体且附近有非队友 → 报警（够不着先靠近）。不管尸体是谁
  *   造成的（含队友的杀），靠主动报警伪装好人 / 把嫌疑栽到在场者身上。
@@ -58,7 +58,7 @@ export function corpseReportWithNonTeammate(state: GameState, ctx: StrategyConte
   }];
 }
 
-/** 唯一一个落单非队友贴脸(≤KILL_RANGE)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
+/** 唯一一个落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀；否则 null。无视暂停窗口、不管在做什么任务。 */
 export function immediateLoneKillDecision(state: GameState, ctx: StrategyContext): BehaviorDecision[] | null {
   if (!canUseKill(state)) return null;
 
@@ -67,7 +67,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 > KILL_RANGE) return null;
+  if (distance > killCommitRange(state.you.role)) return null;
 
   ctx.notifications.push(`发现落单目标${target.name}就在身边，立刻出刀！`);
   return [{ action: Action.kill(target.name) }];

package/src/strategies/goals/crab-sabotage-top.ts

@@ -23,7 +23,7 @@ const SABOTAGE_ALARM_DEDUPE_MS = 90_000;
  * 蟹的「破坏 + 落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 自上而下判定该走哪条分支、
  * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子；URGENT/WANDER 优先级供 ConversationGoal 判断）：
  *
- * 0a. 反射·立刻出刀（crab-octopus-reflexes，URGENT）：落单非队友贴脸(≤KILL_RANGE)且刀好 → 立刻出刀，
+ * 0a. 反射·立刻出刀（crab-octopus-reflexes，URGENT）：落单非队友贴脸(出刀范围内)且刀好 → 立刻出刀，
  *     无视暂停窗口、不管自己是否正在做破坏任务。
  * 0b. 反射·报尸（crab-octopus-reflexes，URGENT）：有尸体且附近有非队友 → 报警/靠近报警，不管尸体是谁造成的。
  * 1a. 破坏完成 → 触发紧急警报（一次性动作，LeafGoal 承载，URGENT）。

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

@@ -1,12 +1,11 @@
 import { Action } from '../../sdk/action.js';
 import type { GameState, PlayerInfo, Position } from '../../sdk/types.js';
-import { dist } from '../game-utils.js';
+import { dist, SHRIMP_KILL_RANGE } from '../game-utils.js';
 import { assessEscapeTarget, planEscape, type EscapeOptions } from '../pathfind/escape-planner.js';
 import { loadWalkableGrid } from '../pathfind/walkable-grid.js';
 import type { BehaviorDecision, StrategyContext } from '../types.js';
 import { Goal } from './goal.js';
 
-const DEFAULT_THREAT_RADIUS = 420;
 const PANIC_RADIUS = 190;
 const CRITICAL_RADIUS = 100;
 const REACHED_DISTANCE = 28;
@@ -22,8 +21,8 @@ const FALLBACK_ANGLE_OFFSETS = [0, Math.PI / 6, -Math.PI / 6, Math.PI / 3, -Math
 export type ThreatResolver = (state: GameState, ctx: StrategyContext) => PlayerInfo[];
 
 export interface KeepAwayGoalOptions {
-  /** 交战兼结束半径（px），默认 420；Infinity = resolver 返回的全算威胁。 */
-  threatRadius?: number;
+  /** 交战兼结束半径（px）；Infinity = resolver 返回的全算威胁。所有调用点必须显式传，无默认值。 */
+  threatRadius: number;
   /** 半径内无威胁时 isFinish=true，供父节点自然回收；独立 keep-away 策略作为顶层须传 false，否则每个安静 tick 被 GoalManager 清掉再重建、idle 通知刷屏。 */
   finishWhenClear?: boolean;
   /** 无威胁时的 idle/coast 通知；作为子目标默认关闭（父节点自有进度播报）。 */
@@ -98,11 +97,15 @@ export class KeepAwayGoal extends Goal {
   constructor(
     public readonly key: string,
     private readonly resolveThreats: ThreatResolver,
-    private readonly options: KeepAwayGoalOptions = {},
+    private readonly options: KeepAwayGoalOptions,
   ) {
     super();
-    this.threatRadius = options.threatRadius ?? DEFAULT_THREAT_RADIUS;
-    this.planOpts = { ...PLAN_OPTS, ...options.planOpts };
+    this.threatRadius = options.threatRadius;
+    // 逃跑推演对「会不会被追上」用保守击杀距离：威胁在本层只有坐标、没有角色（resolver 返回
+    // 的是可见非队友的裸位置，本游戏看不到他人身份），无法逐威胁取 killRangeFor(role)，故统一用
+    // 武士虾/枪虾的 SHRIMP_KILL_RANGE(160) 兜底，宁可对蟹/章鱼多拉开距离也不对带刀好人少逃。
+    // escape-planner 自身默认 80（服务端 base kill_range），此处刻意覆盖。
+    this.planOpts = { killRange: SHRIMP_KILL_RANGE, ...PLAN_OPTS, ...options.planOpts };
   }
 
   tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {

package/src/strategies/goals/kill-frenzy-top.ts

@@ -2,7 +2,7 @@ import type { GameState, PlayerInfo } from '../../sdk/types.js';
 import {
   dist,
   killCooldownSecs,
-  KILL_RANGE,
+  killCommitRange,
   LONE_FOLLOW_DISTANCE,
   nearestPlayerByDistance,
   nonTeammatesVisible,
@@ -19,9 +19,9 @@ import { Goal } from './goal.js';
  * 与 kill-lone 不同——周围人多也照杀，绝不因人多而暂停。
  *
  * 逐 tick：
- * - 视野内有非队友 → 锁定最近那个，贴上去：50 内且冷却好就出刀，
+ * - 视野内有非队友 → 锁定最近那个，贴上去：出刀范围内且冷却好就出刀，
  *   冷却中保持 LONE_FOLLOW_DISTANCE 贴身跟随等待。
- * - 否则 → 按房间顺序巡逻找猎物（遇人即停）。永不停手。
+ * - 否则 → 按房间顺序巡逻找猎物。永不停手。
  *
  * 与 kill-target 复用同一套「锁定后追/砍/等冷却」体验（pursueVisibleTarget，
  * kill=true、followDistance=LONE_FOLLOW_DISTANCE），仅目标选取规则不同：
@@ -38,14 +38,14 @@ export class KillFrenzyTop extends Goal {
         ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
       } else {
         const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-        if (d > KILL_RANGE) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
+        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
       }
       this.emitProgress(state, ctx);
       return decision ? [decision] : [];
     }
 
     this.emitProgress(state, ctx);
-    return patrolStep(state, ctx, this.patrol, true);
+    return patrolStep(state, ctx, this.patrol, false);
   }
 
   private nearestVictim(state: GameState, ctx: StrategyContext): PlayerInfo | null {

package/src/strategies/goals/kill-target-goal.ts

@@ -5,7 +5,7 @@ import {
   dist,
   hasKillUseRemaining,
   isKnowledgeTrusted,
-  KILL_RANGE,
+  killCommitRange,
   LONE_FOLLOW_DISTANCE,
   matchesAnyTarget,
   nonTeammatesVisible,
@@ -29,7 +29,7 @@ export class KillVisibleTargetGoal extends Goal {
 
     const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
 
-    if (d <= KILL_RANGE) {
+    if (d <= killCommitRange(state.you.role)) {
       if (canUseKill(state)) {
         ctx.notifications.push(`发现追杀目标${target.name}，出刀！`);
         return [{ action: Action.kill(target.name) }];

package/src/strategies/goals/kill-target-top.ts

@@ -4,7 +4,7 @@ import {
   killCooldownSecs,
   isTargetAlive,
   isRecentlyKilledTarget,
-  KILL_RANGE,
+  killCommitRange,
   LONE_FOLLOW_DISTANCE,
   LONE_IGNORE_MS,
   matchesTarget,
@@ -54,7 +54,7 @@ export class KillTargetTop extends Goal {
         ctx.notifications.push(`发现目标${target.name}在攻击范围内，出刀！`);
       } else {
         const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-        if (d > KILL_RANGE) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
+        if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现目标${target.name}，正在靠近！`);
       }
       this.emitProgress(state, ctx);
       return decision ? [decision] : [];

package/src/strategies/goals/lone-kill-core.ts

@@ -3,7 +3,7 @@ import { Action } from '../../sdk/action.js';
 import {
   canUseKill,
   dist,
-  KILL_RANGE,
+  killCommitRange,
   LONE_IGNORE_MS,
   nonTeammatesVisible,
 } from '../game-utils.js';
@@ -72,11 +72,11 @@ export class LoneKillCore {
 
   pursue(state: GameState, ctx: StrategyContext, target: PlayerInfo): BehaviorDecision {
     const d = target.distance ?? dist(state.you.x, state.you.y, target.x, target.y);
-    if (d <= KILL_RANGE && canUseKill(state)) {
+    if (d <= killCommitRange(state.you.role) && canUseKill(state)) {
       ctx.notifications.push(`发现落单目标${target.name}，出刀！`);
       return { action: Action.kill(target.name) };
     }
-    if (d > KILL_RANGE) ctx.notifications.push(`发现落单目标${target.name}，正在靠近！`);
+    if (d > killCommitRange(state.you.role)) ctx.notifications.push(`发现落单目标${target.name}，正在靠近！`);
     return { action: Action.move({ x: target.x, y: target.y }) };
   }
 }

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

@@ -18,7 +18,7 @@ import { corpseReportWithNonTeammate, immediateLoneKillDecision } from './crab-o
  * 章鱼（中立带刀）的「落单猎杀 + 任务伪装」编排 top。本身不产决策，每 tick 只判定该走哪个行为、
  * 把对应**叶子子目标**挂为唯一子目标（产出动作的是叶子，优先级标注紧急/游走，供 ConversationGoal 判断）：
  *
- * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(≤KILL_RANGE)且刀好 →
+ * 0. 反射（crab-octopus-reflexes，URGENT，抢在落单猎杀编排之前）：落单非队友贴脸(出刀范围内)且刀好 →
  *    立刻出刀；否则有尸体且附近有非队友 → 报警/靠近报警（不管尸体是谁造成的）。
  * 1. 落单猎杀（LoneKillGoal，URGENT）：core.assess() 判 hunt（刀好且有落单目标）→ 叶子 pursue() 靠近 / 出刀。
  *    刀在冷却时 assess 返回 idle，不追不等，直接下沉到任务伪装。

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

@@ -7,7 +7,7 @@ import {
   hasKillUseRemaining,
   isTargetAlive,
   killCooldownSecs,
-  KILL_RANGE,
+  killCommitRange,
   LONE_FOLLOW_DISTANCE,
   matchesTarget,
   PROGRESS_INTERVAL_MS,
@@ -54,12 +54,12 @@ export class TaskKillReportTop extends Goal {
         ctx.notifications.push(`发现嫌疑目标${nearest.player.name}！`);
       }
 
-      if (nearest.dist <= KILL_RANGE && killReady) {
+      if (nearest.dist <= killCommitRange(state.you.role) && killReady) {
         ctx.notifications.push(`嫌疑目标${nearest.player.name}在攻击范围内，出刀！`);
         return this.emitDecisions(state, ctx, [{ action: Action.kill(nearest.player.name) }], URGENT_GOAL_PRIORITY);
       }
 
-      if (nearest.dist > KILL_RANGE && killReady) {
+      if (nearest.dist > killCommitRange(state.you.role) && killReady) {
         return this.emitDecisions(
           state,
           ctx,

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

@@ -10,7 +10,7 @@ import {
   isKnowledgeThreat,
   isKnowledgeTrusted,
   killCooldownSecs,
-  KILL_RANGE,
+  killCommitRange,
   matchesAnyTarget,
   nonTeammatesVisible,
   PROGRESS_INTERVAL_MS,
@@ -172,7 +172,7 @@ export class WarriorShrimpTop extends Goal {
     return visible
       .filter(p => !this.isTrusted(p, ctx))
       .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
-      .filter(x => x.d <= KILL_RANGE)
+      .filter(x => x.d <= killCommitRange(state.you.role))
       .sort((a, b) => a.d - b.d)[0]?.p ?? null;
   }