@myclaw163/clawclaw-cli 0.6.76 → 0.6.78

package/src/strategies/new-events-backfill.ts

@@ -1,98 +1,98 @@
-import { closeSync, existsSync, openSync, readSync, statSync } from 'fs';
-import { extractNewEvents } from '../pipeline/event-store.js';
-
-const SUPPLEMENTAL_TYPES = new Set([
-  'corpse_spotted', 'crab_teammates',
-  'meeting_ended', 'meeting_result_pending', 'meeting_start', 'meeting_started',
-  'move_end', 'move_interrupted',
-  'wandering_speech',
-]);
-
-const KEY_FIELDS = [
-  'type', 'tick', 'actor_name', 'spotted_name', 'killer_name', 'result_target',
-  'target_name', 'corpse_name', 'task_name', 'reason', 'text', 'content',
-];
-
-export function createStrategyNewEventsBackfill(eventLogPath: string): {
-  correct(stateNewEvents: any): Record<string, any>[];
-} {
-  let pos = sizeOf(eventLogPath);
-
-  return {
-    correct(stateNewEvents: any): Record<string, any>[] {
-      const httpEvents = extractNewEvents(stateNewEvents);
-      const httpKeys = new Set(httpEvents.map(eventKey));
-      const out: Array<{ event: Record<string, any>; order: number }> = [];
-      const seen = new Set<string>();
-      let order = 0;
-      const add = (evt: any, supplemental = false) => {
-        if (!evt || typeof evt !== 'object' || typeof evt.type !== 'string' || evt.synthetic) return;
-        if (supplemental && !SUPPLEMENTAL_TYPES.has(evt.type)) return;
-        const key = eventKey(evt);
-        if (supplemental && httpKeys.has(key)) return;
-        if (seen.has(key)) return;
-        seen.add(key);
-        out.push({ event: evt, order: order++ });
-      };
-
-      for (const line of readNewLines()) {
-        const events = extractNewEvents(line);
-        for (const evt of events.length > 0 ? events : [line]) add(evt, true);
-      }
-      for (const evt of httpEvents) add(evt);
-      return out.sort(compareEvents).map(item => item.event);
-    },
-  };
-
-  function readNewLines(): Record<string, any>[] {
-    if (!existsSync(eventLogPath)) { pos = 0; return []; }
-    let stat;
-    try { stat = statSync(eventLogPath); } catch { return []; }
-    if (stat.size < pos) pos = 0;
-    if (stat.size === pos) return [];
-
-    let fd: number;
-    try { fd = openSync(eventLogPath, 'r'); } catch { return []; }
-    const buf = Buffer.alloc(stat.size - pos);
-    try {
-      readSync(fd, buf, 0, buf.length, pos);
-    } finally {
-      closeSync(fd);
-    }
-
-    const cut = buf.lastIndexOf(0x0A);
-    if (cut < 0) return [];
-    const chunk = buf.subarray(0, cut).toString('utf8');
-    pos += cut + 1;
-    return chunk.split('\n').flatMap(parseLine);
-  }
-}
-
-function eventKey(evt: Record<string, any>): string {
-  return evt.tick == null ? JSON.stringify(evt) : KEY_FIELDS.map(k => evt[k] ?? '').join('|');
-}
-
-function compareEvents(a: { event: Record<string, any>; order: number }, b: { event: Record<string, any>; order: number }): number {
-  const at = typeof a.event.tick === 'number' && Number.isFinite(a.event.tick) ? a.event.tick : null;
-  const bt = typeof b.event.tick === 'number' && Number.isFinite(b.event.tick) ? b.event.tick : null;
-  if (at != null && bt != null && at !== bt) return at - bt;
-  return a.order - b.order;
-}
-
-function parseLine(line: string): Record<string, any>[] {
-  if (!line.trim()) return [];
-  try {
-    const obj = JSON.parse(line);
-    return obj && typeof obj === 'object' ? [obj] : [];
-  } catch {
-    return [];
-  }
-}
-
-function sizeOf(path: string): number {
-  try {
-    return existsSync(path) ? statSync(path).size : 0;
-  } catch {
-    return 0;
-  }
-}
+import { closeSync, existsSync, openSync, readSync, statSync } from 'fs';
+import { extractNewEvents } from '../pipeline/event-store.js';
+
+const SUPPLEMENTAL_TYPES = new Set([
+  'corpse_spotted', 'crab_teammates',
+  'meeting_ended', 'meeting_result_pending', 'meeting_start', 'meeting_started',
+  'move_end', 'move_interrupted',
+  'wandering_speech',
+]);
+
+const KEY_FIELDS = [
+  'type', 'tick', 'actor_name', 'spotted_name', 'killer_name', 'result_target',
+  'target_name', 'corpse_name', 'task_name', 'reason', 'text', 'content',
+];
+
+export function createStrategyNewEventsBackfill(eventLogPath: string): {
+  correct(stateNewEvents: any): Record<string, any>[];
+} {
+  let pos = sizeOf(eventLogPath);
+
+  return {
+    correct(stateNewEvents: any): Record<string, any>[] {
+      const httpEvents = extractNewEvents(stateNewEvents);
+      const httpKeys = new Set(httpEvents.map(eventKey));
+      const out: Array<{ event: Record<string, any>; order: number }> = [];
+      const seen = new Set<string>();
+      let order = 0;
+      const add = (evt: any, supplemental = false) => {
+        if (!evt || typeof evt !== 'object' || typeof evt.type !== 'string' || evt.synthetic) return;
+        if (supplemental && !SUPPLEMENTAL_TYPES.has(evt.type)) return;
+        const key = eventKey(evt);
+        if (supplemental && httpKeys.has(key)) return;
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push({ event: evt, order: order++ });
+      };
+
+      for (const line of readNewLines()) {
+        const events = extractNewEvents(line);
+        for (const evt of events.length > 0 ? events : [line]) add(evt, true);
+      }
+      for (const evt of httpEvents) add(evt);
+      return out.sort(compareEvents).map(item => item.event);
+    },
+  };
+
+  function readNewLines(): Record<string, any>[] {
+    if (!existsSync(eventLogPath)) { pos = 0; return []; }
+    let stat;
+    try { stat = statSync(eventLogPath); } catch { return []; }
+    if (stat.size < pos) pos = 0;
+    if (stat.size === pos) return [];
+
+    let fd: number;
+    try { fd = openSync(eventLogPath, 'r'); } catch { return []; }
+    const buf = Buffer.alloc(stat.size - pos);
+    try {
+      readSync(fd, buf, 0, buf.length, pos);
+    } finally {
+      closeSync(fd);
+    }
+
+    const cut = buf.lastIndexOf(0x0A);
+    if (cut < 0) return [];
+    const chunk = buf.subarray(0, cut).toString('utf8');
+    pos += cut + 1;
+    return chunk.split('\n').flatMap(parseLine);
+  }
+}
+
+function eventKey(evt: Record<string, any>): string {
+  return evt.tick == null ? JSON.stringify(evt) : KEY_FIELDS.map(k => evt[k] ?? '').join('|');
+}
+
+function compareEvents(a: { event: Record<string, any>; order: number }, b: { event: Record<string, any>; order: number }): number {
+  const at = typeof a.event.tick === 'number' && Number.isFinite(a.event.tick) ? a.event.tick : null;
+  const bt = typeof b.event.tick === 'number' && Number.isFinite(b.event.tick) ? b.event.tick : null;
+  if (at != null && bt != null && at !== bt) return at - bt;
+  return a.order - b.order;
+}
+
+function parseLine(line: string): Record<string, any>[] {
+  if (!line.trim()) return [];
+  try {
+    const obj = JSON.parse(line);
+    return obj && typeof obj === 'object' ? [obj] : [];
+  } catch {
+    return [];
+  }
+}
+
+function sizeOf(path: string): number {
+  try {
+    return existsSync(path) ? statSync(path).size : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/strategies/off-route-points.ts

@@ -1,105 +1,105 @@
-import type { Position } from '../sdk/types.js';
-import { dist } from './game-utils.js';
-import { assessRoutes } from './pathfind/escape-planner.js';
-
-/**
- * 离线从烘焙地图算出的「离路点」：远离任务点/出生点、避开走廊与枢纽的低人流坐标
- * （世界像素，与 GameState / 可行走网格同坐标系）。HIDE_SPOTS（藏身角落）是它的具体集合，
- * 共用下面的选点器。
- */
-export interface OffRoutePoint extends Position {
-  /** 所在房间，仅供日志/调试。 */
-  room: string;
-}
-
-export interface NearestSafePointOptions<T extends Position = Position> {
-  /** 点离任一威胁多近就硬排除。 */
-  threatExcludeRadius: number;
-  /** 去该点的测地路径经过威胁这个距离内也排除（避免走向把守者）。 */
-  pathThreatRadius: number;
-  /** 当前已选点：仍是合法候选就保持不变，杜绝等距摇摆。 */
-  stickyTo?: T | null;
-  /** 被标记为不可达的移动目标：在其附近的点跳过。 */
-  blockedTarget?: Position | null;
-}
-
-const BLOCKED_RADIUS = 12;
-
-function samePoint(a: Position, b: Position): boolean {
-  return a.x === b.x && a.y === b.y;
-}
-
-/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
-function farthestFromThreats<T extends Position>(
-  points: readonly T[],
-  threatPoints: Position[],
-  blocked?: Position | null,
-): T | null {
-  let best: T | null = null;
-  let bestMin = -Infinity;
-  for (const s of points) {
-    if (blocked && dist(s.x, s.y, blocked.x, blocked.y) <= BLOCKED_RADIUS) continue;
-    const minD = threatPoints.length === 0 ? 0 : Math.min(...threatPoints.map(p => dist(s.x, s.y, p.x, p.y)));
-    if (minD > bestMin) {
-      bestMin = minD;
-      best = s;
-    }
-  }
-  return best;
-}
-
-/**
- * 从离线点集里选「测地最近的安全点」：威胁旁的点硬排除、去路经过威胁附近的点排除，余者取测地最近
- * （distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。全部被威胁封死
- * 时退回「离威胁最远」的点。nearestSafeHideSpot 复用此选点器。
- */
-export function nearestSafePoint<T extends Position>(
-  points: readonly T[],
-  from: Position,
-  threatPoints: Position[],
-  opts: NearestSafePointOptions<T>,
-): T | null {
-  const excludeR = opts.threatExcludeRadius;
-  const blocked = opts.blockedTarget ?? null;
-
-  const candidates = points.filter(s =>
-    (!blocked || dist(s.x, s.y, blocked.x, blocked.y) > BLOCKED_RADIUS)
-    && !threatPoints.some(p => dist(s.x, s.y, p.x, p.y) <= excludeR));
-
-  if (candidates.length === 0) return farthestFromThreats(points, threatPoints, blocked);
-
-  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
-  if (opts.stickyTo && threatPoints.length === 0) {
-    const sticky = candidates.find(c => samePoint(c, opts.stickyTo!));
-    if (sticky) return sticky;
-  }
-
-  const routes = assessRoutes(
-    from,
-    candidates.map(c => ({ x: c.x, y: c.y })),
-    threatPoints,
-    opts.pathThreatRadius,
-  );
-  const indexed = candidates.map((c, i) => ({ c, i }));
-  const viable = routes == null ? indexed : indexed.filter(({ i }) => !routes[i].nearThreat);
-  const pool = viable.length > 0 ? viable : indexed;
-
-  if (opts.stickyTo) {
-    const sticky = pool.find(({ c }) => samePoint(c, opts.stickyTo!));
-    if (sticky) return sticky.c;
-  }
-
-  // 测地最近（distance-field 距离；测地不可达按欧氏垫底）。
-  let best = pool[0].c;
-  let bestScore = Infinity;
-  for (const { c, i } of pool) {
-    const euclid = dist(from.x, from.y, c.x, c.y);
-    const geo = routes?.[i].distancePx;
-    const score = geo == null ? euclid : geo !== Infinity ? geo : euclid + 1e6;
-    if (score < bestScore) {
-      bestScore = score;
-      best = c;
-    }
-  }
-  return best;
-}
+import type { Position } from '../sdk/types.js';
+import { dist } from './game-utils.js';
+import { assessRoutes } from './pathfind/escape-planner.js';
+
+/**
+ * 离线从烘焙地图算出的「离路点」：远离任务点/出生点、避开走廊与枢纽的低人流坐标
+ * （世界像素，与 GameState / 可行走网格同坐标系）。HIDE_SPOTS（藏身角落）是它的具体集合，
+ * 共用下面的选点器。
+ */
+export interface OffRoutePoint extends Position {
+  /** 所在房间，仅供日志/调试。 */
+  room: string;
+}
+
+export interface NearestSafePointOptions<T extends Position = Position> {
+  /** 点离任一威胁多近就硬排除。 */
+  threatExcludeRadius: number;
+  /** 去该点的测地路径经过威胁这个距离内也排除（避免走向把守者）。 */
+  pathThreatRadius: number;
+  /** 当前已选点：仍是合法候选就保持不变，杜绝等距摇摆。 */
+  stickyTo?: T | null;
+  /** 被标记为不可达的移动目标：在其附近的点跳过。 */
+  blockedTarget?: Position | null;
+}
+
+const BLOCKED_RADIUS = 12;
+
+function samePoint(a: Position, b: Position): boolean {
+  return a.x === b.x && a.y === b.y;
+}
+
+/** 所有点都被威胁封死时的兜底：离威胁最远的点（仍好过原地等死）。 */
+function farthestFromThreats<T extends Position>(
+  points: readonly T[],
+  threatPoints: Position[],
+  blocked?: Position | null,
+): T | null {
+  let best: T | null = null;
+  let bestMin = -Infinity;
+  for (const s of points) {
+    if (blocked && dist(s.x, s.y, blocked.x, blocked.y) <= BLOCKED_RADIUS) continue;
+    const minD = threatPoints.length === 0 ? 0 : Math.min(...threatPoints.map(p => dist(s.x, s.y, p.x, p.y)));
+    if (minD > bestMin) {
+      bestMin = minD;
+      best = s;
+    }
+  }
+  return best;
+}
+
+/**
+ * 从离线点集里选「测地最近的安全点」：威胁旁的点硬排除、去路经过威胁附近的点排除，余者取测地最近
+ * （distance-field 一次扫描；测地不可达按欧氏垫底），带粘性（当前点仍合法就不换）。全部被威胁封死
+ * 时退回「离威胁最远」的点。nearestSafeHideSpot 复用此选点器。
+ */
+export function nearestSafePoint<T extends Position>(
+  points: readonly T[],
+  from: Position,
+  threatPoints: Position[],
+  opts: NearestSafePointOptions<T>,
+): T | null {
+  const excludeR = opts.threatExcludeRadius;
+  const blocked = opts.blockedTarget ?? null;
+
+  const candidates = points.filter(s =>
+    (!blocked || dist(s.x, s.y, blocked.x, blocked.y) > BLOCKED_RADIUS)
+    && !threatPoints.some(p => dist(s.x, s.y, p.x, p.y) <= excludeR));
+
+  if (candidates.length === 0) return farthestFromThreats(points, threatPoints, blocked);
+
+  // 无威胁时粘性可零成本短路（不必为路径检查扫距离场）。
+  if (opts.stickyTo && threatPoints.length === 0) {
+    const sticky = candidates.find(c => samePoint(c, opts.stickyTo!));
+    if (sticky) return sticky;
+  }
+
+  const routes = assessRoutes(
+    from,
+    candidates.map(c => ({ x: c.x, y: c.y })),
+    threatPoints,
+    opts.pathThreatRadius,
+  );
+  const indexed = candidates.map((c, i) => ({ c, i }));
+  const viable = routes == null ? indexed : indexed.filter(({ i }) => !routes[i].nearThreat);
+  const pool = viable.length > 0 ? viable : indexed;
+
+  if (opts.stickyTo) {
+    const sticky = pool.find(({ c }) => samePoint(c, opts.stickyTo!));
+    if (sticky) return sticky.c;
+  }
+
+  // 测地最近（distance-field 距离；测地不可达按欧氏垫底）。
+  let best = pool[0].c;
+  let bestScore = Infinity;
+  for (const { c, i } of pool) {
+    const euclid = dist(from.x, from.y, c.x, c.y);
+    const geo = routes?.[i].distancePx;
+    const score = geo == null ? euclid : geo !== Infinity ? geo : euclid + 1e6;
+    if (score < bestScore) {
+      bestScore = score;
+      best = c;
+    }
+  }
+  return best;
+}

package/src/strategies/paradise-fish.knowledge.md

@@ -1,19 +1,19 @@
-# paradise-fish 知识契约
-
-`paradise-fish` 只读取两档玩家标记，**未标记的一律默认「被怀疑」**：
-
-| 标记 | 行为 |
-|------|------|
-| `hostile`（坏人） | 敌对带刀者：无尸体时进入视野便硬寻路远离 |
-| `trusted`（好人） | 可信：可与其抱团、靠近站定伪装做任务 |
-| 未标记（被怀疑） | 无尸体、无可信同伴且单人贴近时保持距离；多人互为目击者则照常活动 |
-
-天堂鱼不出刀，因此坏人与被怀疑者都表现为回避（坏人硬躲、被怀疑者按目击者规则保持距离）。发现尸体时仍优先执行尸体旁游走逻辑，不报警。
-
-```bash
-ccl knowledge mark 5 hostile --note "确认危险"
-ccl knowledge mark 3 trusted --note "可以抱团"
-ccl knowledge del player 5            # 取消标记 → 回到默认「被怀疑」
-```
-
-`role` 是纯身份事实，不直接控制策略。
+# paradise-fish 知识契约
+
+`paradise-fish` 只读取两档玩家标记，**未标记的一律默认「被怀疑」**：
+
+| 标记 | 行为 |
+|------|------|
+| `hostile`（坏人） | 敌对带刀者：无尸体时进入视野便硬寻路远离 |
+| `trusted`（好人） | 可信：可与其抱团、靠近站定伪装做任务 |
+| 未标记（被怀疑） | 无尸体、无可信同伴且单人贴近时保持距离；多人互为目击者则照常活动 |
+
+天堂鱼不出刀，因此坏人与被怀疑者都表现为回避（坏人硬躲、被怀疑者按目击者规则保持距离）。发现尸体时仍优先执行尸体旁游走逻辑，不报警。
+
+```bash
+ccl knowledge mark 5 hostile --note "确认危险"
+ccl knowledge mark 3 trusted --note "可以抱团"
+ccl knowledge del player 5            # 取消标记 → 回到默认「被怀疑」
+```
+
+`role` 是纯身份事实，不直接控制策略。

package/src/strategies/paradise-fish.ts

@@ -1,26 +1,26 @@
-import type { StrategyEntry } from './types.js';
-import { GoalRootStrategy } from './goals/goal-root-strategy.js';
-import { ParadiseFishTop } from './goals/paradise-fish-top.js';
-import { parseGreetingArgs } from './greeting.js';
-
-class ParadiseFishStrategy extends GoalRootStrategy {
-  constructor(private readonly greetingPhrases: string[]) {
-    super('paradise-fish', () => new ParadiseFishTop(greetingPhrases), {
-      resetOnMeetingResume: false,
-    });
-  }
-
-  speechWarmupTexts(): string[] {
-    return this.greetingPhrases;
-  }
-}
-
-export const strategy: StrategyEntry = {
-  id: 'paradise-fish',
-  name: '天堂鱼',
-  description:
-    '天堂鱼·进阶版（中立，不报警、不做任务，靠被投票出局取胜；corpse-patrol 的带记忆升级）。读取 ccl knowledge 两档标记（hostile=坏人 / trusted=好人），未标记的一律默认被怀疑：hostile 视为危险硬寻路远离，被怀疑者按目击者规则保持距离，trusted 视为可抱团的可信同伴。发现尸体绝不报警，贴着尸体游走制造嫌疑；附近有人时远离那人但仍在尸体附近活动。残局（已知存活≤6）出现紧急维修任务时，会在没有带刀坏人需要躲避时优先抢着去做（先于对陌生人保持距离/贴尸/抱团），阻止蟹靠破坏倒计时取胜。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。',
-  create(args?: string[]) {
-    return new ParadiseFishStrategy(parseGreetingArgs(args, 'paradise-fish'));
-  },
-};
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { ParadiseFishTop } from './goals/paradise-fish-top.js';
+import { parseGreetingArgs } from './greeting.js';
+
+class ParadiseFishStrategy extends GoalRootStrategy {
+  constructor(private readonly greetingPhrases: string[]) {
+    super('paradise-fish', () => new ParadiseFishTop(greetingPhrases), {
+      resetOnMeetingResume: false,
+    });
+  }
+
+  speechWarmupTexts(): string[] {
+    return this.greetingPhrases;
+  }
+}
+
+export const strategy: StrategyEntry = {
+  id: 'paradise-fish',
+  name: '天堂鱼',
+  description:
+    '天堂鱼·进阶版（中立，不报警、不做任务，靠被投票出局取胜；corpse-patrol 的带记忆升级）。读取 ccl knowledge 两档标记（hostile=坏人 / trusted=好人），未标记的一律默认被怀疑：hostile 视为危险硬寻路远离，被怀疑者按目击者规则保持距离，trusted 视为可抱团的可信同伴。发现尸体绝不报警，贴着尸体游走制造嫌疑；附近有人时远离那人但仍在尸体附近活动。残局（已知存活≤6）出现紧急维修任务时，会在没有带刀坏人需要躲避时优先抢着去做（先于对陌生人保持距离/贴尸/抱团），阻止蟹靠破坏倒计时取胜。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。',
+  create(args?: string[]) {
+    return new ParadiseFishStrategy(parseGreetingArgs(args, 'paradise-fish'));
+  },
+};