@myclaw163/clawclaw-cli 0.6.54

package/src/strategies/goals/wander-task-goal.ts

@@ -0,0 +1,33 @@
+import type { GameState, TaskInfo } from '../../sdk/types.js';
+import { approachOrDoTaskStep, patrolStep, PatrolState } from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+
+export type TaskPicker = (state: GameState, ctx: StrategyContext) => TaskInfo | null;
+
+/**
+ * 任务伪装 + 巡逻子目标（叶子，由上层以 WANDER 优先级挂载）：先按 pickTask 取一个任务靠近 / 提交，
+ * 没有可做任务、或到点暂不可提交，就按房间巡逻，绝不停在原地。供 lone-kill-task / crab-sabotage 复用，
+ * pickTask 决定做哪类任务，stopOnPlayer 通常接 LoneKillCore.patrolStopOnPlayer()，patrol 由上层注入以共享巡逻进度。
+ */
+export class WanderTaskGoal extends Goal {
+  constructor(
+    private readonly pickTask: TaskPicker,
+    private readonly stopOnPlayer: () => boolean,
+    private readonly patrol: PatrolState,
+  ) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    if (state.you.doing_task) return [];
+
+    const task = this.pickTask(state, ctx);
+    if (task) {
+      const decision = approachOrDoTaskStep(state, ctx, task, this.stopOnPlayer());
+      if (decision) return decision;
+      // 到点却暂时无法提交 → 转巡逻，避免卡在任务点
+    }
+    return patrolStep(state, ctx, this.patrol, this.stopOnPlayer());
+  }
+}

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

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { buildKnowledgeView, type KnowledgeFile } from '../../lib/knowledge-store.js';
+import type { GameState } from '../../sdk/types.js';
+import type { StrategyContext } from '../types.js';
+import { KeepAwayGoal } from './keep-away-goal.js';
+import { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { WarriorShrimpTop } from './warrior-shrimp-top.js';
+
+function state(): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'warrior',
+      x: 0,
+      y: 0,
+      room: 'control',
+      role: 'shrimp_warrior',
+      faction: 'lobster',
+      is_alive: true,
+      kill_cooldown_secs: 0,
+      kills_remaining: 1,
+    },
+    your_tasks: [],
+    players: [{ name: 'target', seat: 2, x: 100, y: 0, room: 'control', distance: 100 }],
+    all_players: [{ name: 'target', seat: 2, role: 'unknown', is_alive: true }],
+    corpses: [],
+    stale: false,
+  };
+}
+
+function knowledge(mark: 'suspect' | 'hostile' | 'trusted') {
+  const ts = Date.now();
+  const file: KnowledgeFile = {
+    version: 1,
+    gameId: 'game-1',
+    subjects: {
+      'player:target': {
+        type: 'player',
+        selector: 'target',
+        tags: { [mark]: { ts } },
+      },
+    },
+  };
+  return buildKnowledgeView(file);
+}
+
+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: { '2': 'target' },
+    forcePatrolAdvance: false,
+    blockedMoveTarget: null,
+    mySeat: 1,
+    speechNotifications: [],
+    agentAlerts: [],
+    ...overrides,
+  };
+}
+
+describe('WarriorShrimpTop knowledge tiers', () => {
+  it('avoids a suspect even when the weapon is ready', () => {
+    const top = new WarriorShrimpTop();
+
+    top.tick(state(), context({ knowledge: knowledge('suspect') }));
+
+    expect(top.subGoal).toBeInstanceOf(KeepAwayGoal);
+  });
+
+  it('hunts hostile targets', () => {
+    const top = new WarriorShrimpTop();
+
+    top.tick(state(), context({ knowledge: knowledge('hostile') }));
+
+    expect(top.subGoal).toBeInstanceOf(KillVisibleTargetGoal);
+  });
+});

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

@@ -0,0 +1,248 @@
+import type { GameState, PlayerInfo } from '../../sdk/types.js';
+import { Action } from '../../sdk/action.js';
+import {
+  canUseKill,
+  corpseAtScene,
+  dist,
+  firstAvailableTask,
+  hasKnownCorpse,
+  isKnowledgeHostile,
+  isKnowledgeThreat,
+  isKnowledgeTrusted,
+  killCooldownSecs,
+  KILL_RANGE,
+  matchesAnyTarget,
+  nonTeammatesVisible,
+  PROGRESS_INTERVAL_MS,
+  reportCorpseDecision,
+  SHRIMP_VISION_RANGE,
+  SHRIMP_VISION_RELEASE_RANGE,
+  taskMoveDecision,
+} from '../game-utils.js';
+import type { BehaviorDecision, StrategyContext } from '../types.js';
+import { Goal } from './goal.js';
+import { KeepAwayGoal, type KeepAwayGoalOptions } from './keep-away-goal.js';
+import { KillVisibleTargetGoal } from './kill-target-goal.js';
+import { SafeTaskOrPatrolGoal } from './safe-task-goal.js';
+
+const SUB_PRIORITY = 0.5;
+const STRANGER_TRIGGER_RADIUS = SHRIMP_VISION_RANGE;
+const STRANGER_RELEASE_RADIUS = SHRIMP_VISION_RELEASE_RANGE;
+const WITNESS_MEMORY_MS = 0;
+const WITNESS_EXEMPT_COUNT = 2;
+const TASK_RETURN_INERTIA_MS = 2_000;
+const FLEE_KEY = 'warrior-flee';
+const STRANGER_KEY = 'warrior-stranger-distance';
+
+type ProgressTier = 'flee-bad' | 'keep-distance' | 'task';
+
+/**
+ * 带刀虾·记忆进阶版（武士虾/枪虾，带刀好人）。好人阵营但能出刀，按行为表的优先级逐条判断：
+ *
+ * - P0 发现尸体：旁边有非保护对象且刀可用 → 先出刀；否则报警（靠近至可报距离）。
+ * - P1 处理危险：明确猎杀目标（启动参数 / hostile）刀好就追杀；
+ *   suspect 只表示可疑，始终回避，不会仅凭怀疑主动出刀；
+ *   无可信同伴且单个无标记陌生人贴近 → 按普通虾 B 档先拉开距离。
+ * - P2 紧急任务：无危险时优先处理。
+ * - P3 兜底：做任务 / 巡逻
+ *   （SafeTaskOrPatrolGoal：测地最近、威胁旁/途经威胁的任务硬排除、带粘性）。
+ *
+ * 谁算「认定坏人」「可信同伴」来自 ctx.knowledge（见 warrior-memory.knowledge.md），
+ * 队友由游戏事实判定（nonTeammatesVisible），知识库只提供推断。
+ */
+export class WarriorShrimpTop extends Goal {
+  private readonly taskGoal = new SafeTaskOrPatrolGoal(
+    // 威胁点 = 当前会触发追杀/后撤的对象，或未被目击者豁免的无标记陌生人；保护对象不算。
+    (s, c) => nonTeammatesVisible(s, c)
+      .filter(p => !this.isTrusted(p, c))
+      .filter(p => this.isThreat(p, c) || !this.witnessExempt)
+      .map(p => ({ x: p.x, y: p.y })),
+  );
+  private readonly strangerSeenAt = new Map<string, number>();
+  private witnessExempt = false;
+
+  constructor(private readonly huntTargets: string[] = []) {
+    super();
+  }
+
+  tick(state: GameState, ctx: StrategyContext): BehaviorDecision[] {
+    const visible = nonTeammatesVisible(state, ctx);
+    this.updateWitnessMemory(visible, ctx);
+    const killReady = canUseKill(state);
+
+    // ── P0 发现尸体 ──
+    // 灭口贴脸目击者只在「此刻就在命案现场」（当帧视野有尸体）时考虑——记忆里某处有尸体不算现场，
+    // 否则会变成随便撞见一个人就灭口。
+    if (corpseAtScene(state) && killReady) {
+      const victim = this.nearestKillable(state, ctx, visible);
+      if (victim) {
+        this.clearSub();
+        return [{ action: Action.kill(victim.name) }];
+      }
+    }
+    // 报尸 / 前往报尸：可以追着记忆里看见过、已离开视野的尸体走回去报告。
+    if (hasKnownCorpse(ctx)) {
+      const report = reportCorpseDecision(state, ctx, { respectBlock: true });
+      if (report) {
+        this.clearSub();
+        return [report];
+      }
+    }
+
+    // ── P1-A hostile 刀好就追；suspect 只回避 ──
+    const threats = visible.filter(p => this.isThreat(p, ctx));
+    if (threats.length > 0) {
+      const huntTargets = threats.filter(p => this.isHuntTarget(p, ctx));
+      if (killReady && huntTargets.length > 0) {
+        this.setHunt(this.nearestByDistance(state, huntTargets).name);
+        return [];
+      }
+      this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+      this.setFlee();
+      this.emitProgress(state, ctx, visible, 'flee-bad');
+      return [];
+    }
+
+    // ── P1-B 无可信同伴且无标记陌生人贴近 → 按普通虾 B 档拉开距离 ──
+    const trustedVisible = visible.some(p => this.isTrusted(p, ctx));
+    if (!trustedVisible) {
+      const worker = this.subGoal;
+      const strangerClose = visible.some(p =>
+        this.isUnmarkedStranger(p, ctx)
+        && (p.distance ?? dist(p.x, p.y, state.you.x, state.you.y)) <= STRANGER_TRIGGER_RADIUS);
+      const stillBackingOff = worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY && !worker.isFinish(state, ctx);
+      if (!this.witnessExempt && (strangerClose || stillBackingOff)) {
+        this.taskGoal.planTask(state, ctx, { holdUnsafeCurrentForMs: TASK_RETURN_INERTIA_MS });
+        this.setStrangerKeepAway();
+        this.emitProgress(state, ctx, visible, 'keep-distance');
+        return [];
+      }
+    }
+
+    // ── P2 紧急任务 ──
+    const emergency = firstAvailableTask([], t => t.faction !== 'crab', ctx.emergency, ctx.blockedMoveTarget);
+    if (emergency) {
+      this.clearSub();
+      return [taskMoveDecision(state, ctx, emergency)];
+    }
+
+    // ── P3 普通任务 / 巡逻 ──
+    this.clearSub();
+    this.emitProgress(state, ctx, visible, 'task');
+    return this.taskGoal.tick(state, ctx);
+  }
+
+  /** 目击者豁免：当前只按本轮可见玩家判断，见到 2 个以上陌生人时不对无标记者后撤。 */
+  private updateWitnessMemory(visible: PlayerInfo[], ctx: StrategyContext): void {
+    const now = Date.now();
+    for (const p of visible) {
+      if (!this.isUnmarkedStranger(p, ctx)) continue;
+      const key = p.name || String(p.seat ?? '');
+      if (key) this.strangerSeenAt.set(key, now);
+    }
+    for (const [key, at] of this.strangerSeenAt) {
+      if (now - at > WITNESS_MEMORY_MS) this.strangerSeenAt.delete(key);
+    }
+    this.witnessExempt = this.strangerSeenAt.size >= WITNESS_EXEMPT_COUNT;
+  }
+
+  private isUnmarkedStranger(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx) && !this.isThreat(p, ctx);
+  }
+
+  /** 知识里 trusted 的玩家：可信同伴，永不击杀。 */
+  private isTrusted(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return isKnowledgeTrusted(p, ctx);
+  }
+
+  /** 明确猎杀目标：启动参数或 hostile；suspect 不在这里。 */
+  private isHuntTarget(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx)
+      && (matchesAnyTarget(p, this.huntTargets, ctx) || isKnowledgeHostile(p, ctx));
+  }
+
+  /** 威胁：明确猎杀目标，或知识库 suspect 标记；trusted 永远排除。 */
+  private isThreat(p: PlayerInfo, ctx: StrategyContext): boolean {
+    return !this.isTrusted(p, ctx)
+      && (this.isHuntTarget(p, ctx) || isKnowledgeThreat(p, ctx));
+  }
+
+  /** 尸体场景下「认定坏人/身份不明」= 视野内最近的非保护非队友，且在出刀范围内。 */
+  private nearestKillable(state: GameState, ctx: StrategyContext, visible: PlayerInfo[]): PlayerInfo | null {
+    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)
+      .sort((a, b) => a.d - b.d)[0]?.p ?? null;
+  }
+
+  private nearestByDistance(state: GameState, players: PlayerInfo[]): PlayerInfo {
+    return players
+      .map(p => ({ p, d: p.distance ?? dist(state.you.x, state.you.y, p.x, p.y) }))
+      .sort((a, b) => a.d - b.d)[0].p;
+  }
+
+  private setHunt(targetName: string): void {
+    const worker = this.subGoal;
+    if (worker instanceof KillVisibleTargetGoal && worker.targetName === targetName) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KillVisibleTargetGoal(targetName, [], true), SUB_PRIORITY);
+  }
+
+  private setFlee(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === FLEE_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(
+      FLEE_KEY,
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isThreat(p, c)),
+      { threatRadius: Infinity, noun: '认定坏人' } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private setStrangerKeepAway(): void {
+    const worker = this.subGoal;
+    if (worker instanceof KeepAwayGoal && worker.key === STRANGER_KEY) return;
+    if (this.subGoal) this.removeSubGoal();
+    this.setSubGoal(new KeepAwayGoal(
+      STRANGER_KEY,
+      (s, c) => nonTeammatesVisible(s, c).filter(p => this.isUnmarkedStranger(p, c)),
+      {
+        threatRadius: STRANGER_RELEASE_RADIUS,
+        noun: '陌生人',
+        planOpts: { steps: 4 },
+      } satisfies KeepAwayGoalOptions,
+    ), SUB_PRIORITY);
+  }
+
+  private clearSub(): void {
+    if (this.subGoal) this.removeSubGoal();
+  }
+
+  private emitProgress(state: GameState, ctx: StrategyContext, visible: PlayerInfo[], tier: ProgressTier): void {
+    const now = Date.now();
+    if (now - ctx.lastProgressNotifyAt < PROGRESS_INTERVAL_MS) return;
+    ctx.lastProgressNotifyAt = now;
+
+    const room = state.you.room ?? '未知';
+    const cd = killCooldownSecs(state);
+    const killsRemaining = state.you.kills_remaining;
+
+    let msg = `[进度] 当前在${room}`;
+    if (visible.length === 0) {
+      msg += '，附近无人，做任务/巡逻。';
+    } else if (tier === 'keep-distance') {
+      msg += '，无标记陌生人靠得太近，先拉开距离再做任务。';
+    } else {
+      const bad = visible.filter(p => this.isThreat(p, ctx)).map(p => p.name);
+      if (bad.length > 0) msg += `，发现认定坏人${bad.join('、')}`;
+      else if (this.witnessExempt) msg += `，附近有${visible.length}个无标记陌生人互为目击者，正常做任务`;
+      else msg += `，附近有${visible.length}人，正常做任务`;
+      if (tier === 'flee-bad') msg += killCooldownSecs(state) > 0 ? '，刀在冷却，正在回避' : '，正在处理';
+      if (cd > 0) msg += `（攻击冷却${cd}s）`;
+      if (killsRemaining === 0) msg += '（出刀次数已用完）';
+      msg += '。';
+    }
+    ctx.notifications.push(msg);
+  }
+}

package/src/strategies/greeting.ts

@@ -0,0 +1,53 @@
+import { Action } from '../sdk/action.js';
+import type { GameState } from '../sdk/types.js';
+import type { BehaviorDecision } from './types.js';
+import { TTS_TEXT_MAX_LENGTH } from '../lib/tts-keys.js';
+import { stripRoleIds } from './player-targets.js';
+
+export const MAX_GREETING_PHRASES = 3;
+export const GREETING_COOLDOWN_MS = 120_000;
+
+/**
+ * 解析「打招呼话术」启动参数：剥掉 role-id 噪声与空串，校验条数（≤3）与单条长度（≤TTS 上限）。
+ * 供 task-report / corpse-patrol / shrimp-memory / paradise-fish 共用——它们的启动参数语义都是「打招呼话术」。
+ *
+ * @param strategyId 仅用于错误文案。
+ */
+export function parseGreetingArgs(args: string[] | undefined, strategyId: string): string[] {
+  if (!args || args.length === 0) return [];
+
+  const phrases = args.map(a => stripRoleIds(a)).filter(a => a.length > 0);
+  if (phrases.length === 0) return [];
+
+  if (phrases.length > MAX_GREETING_PHRASES) {
+    throw new Error(`${strategyId} strategy accepts 0-${MAX_GREETING_PHRASES} greeting phrases (got ${phrases.length}).`);
+  }
+  for (const phrase of phrases) {
+    if (phrase.length > TTS_TEXT_MAX_LENGTH) {
+      throw new Error(`Greeting phrase too long (${phrase.length} chars, max ${TTS_TEXT_MAX_LENGTH}).`);
+    }
+  }
+  return phrases;
+}
+
+/**
+ * 打招呼节流器：视野内有人时随机发一条话术，之后 GREETING_COOLDOWN_MS 内不再发。
+ * 被多个编排型 Top Goal（TaskReportTop / NormalShrimpTop 等）持有复用。
+ */
+export class GreetingTracker {
+  private lastGreetingAt: number | null = null;
+
+  constructor(private readonly phrases: string[]) {}
+
+  tryGreeting(state: GameState): BehaviorDecision | null {
+    if (this.phrases.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.phrases[Math.floor(Math.random() * this.phrases.length)];
+    this.lastGreetingAt = now;
+    return { action: Action.speech(text) };
+  }
+}

package/src/strategies/kill-frenzy.ts

@@ -0,0 +1,12 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { KillFrenzyTop } from './goals/kill-frenzy-top.js';
+
+export const strategy: StrategyEntry = {
+  id: 'kill-frenzy',
+  description:
+    '疯狂砍人：见谁杀谁（除队友外所有可见玩家），多人在场也照杀。按房间顺序巡逻，视野里只要有非队友就冲向最近的那个，50内且冷却好就出刀，冷却中保持10距离贴身跟随等冷却。与 kill-lone 不同，不会因为周围人多而暂停攻击。永不停手。',
+  create() {
+    return new GoalRootStrategy('kill-frenzy', () => new KillFrenzyTop(), { resetOnMeetingResume: false });
+  },
+};

package/src/strategies/kill-lone.knowledge.md

@@ -0,0 +1,20 @@
+# kill-lone 知识契约
+
+`kill-lone` 读取统一的玩家三档标记：
+
+| 标记 | 行为 |
+|------|------|
+| `suspect` | 不升级为主动猎杀目标，仍按默认落单规则判断 |
+| `hostile` | 视为明确猎杀目标，见到就追杀，可突破多人保护规则 |
+| `trusted` | 永不击杀，优先级高于其他猎杀判断 |
+
+未标记玩家维持默认行为：仅猎杀落单的非队友。
+
+```bash
+ccl knowledge mark 5 suspect --confidence 0.7 --note "行为可疑"
+ccl knowledge mark 5 hostile --confidence 0.9 --note "确认敌对"
+ccl knowledge mark 3 trusted --note "已澄清"
+ccl knowledge del player 5
+```
+
+`role` 是纯身份事实，不直接控制策略。

package/src/strategies/kill-lone.ts

@@ -0,0 +1,13 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { KillLoneTop } from './goals/kill-lone-top.js';
+import { parseTargetArgs } from './player-targets.js';
+
+export const strategy: StrategyEntry = {
+  id: 'kill-lone',
+  description: '按照房间顺序进行巡逻，巡逻时遇到人会判断。可传入避免击杀的座位号或名字列表。视野里只有一个非队友且不在避免名单内就靠近，进入50距离就出刀；冷却中贴在10距离附近等。视野里出现两人以上时，暂停攻击10秒并继续巡逻。',
+  create(args?: string[]) {
+    const protectedTargets = args ? parseTargetArgs(args) : [];
+    return new GoalRootStrategy('kill-lone', () => new KillLoneTop(protectedTargets), { resetOnMeetingResume: false });
+  },
+};

package/src/strategies/kill-target.ts

@@ -0,0 +1,18 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { KillTargetTop } from './goals/kill-target-top.js';
+import { parseTargetArgs } from './player-targets.js';
+
+export const strategy: StrategyEntry = {
+  id: 'kill-target',
+  description: '专门追杀指定目标（传入座位号或名字，可多人）。按照房间顺序进行巡逻，目标进入视野就冲上去，50内且冷却好就出刀；冷却中保持10距离贴身跟随等待。找目标时路过其他玩家不会停步。所有目标死亡后停止。',
+  create(args?: string[]) {
+    const targets = args ? parseTargetArgs(args) : [];
+    if (targets.length === 0) {
+      throw new Error(
+        'kill-target strategy requires target seat numbers or player names (comma- or space-separated).',
+      );
+    }
+    return new GoalRootStrategy('kill-target', () => new KillTargetTop(targets), { resetOnMeetingResume: false });
+  },
+};