autosnippet 3.2.7 → 3.2.9

package/lib/service/agent/strategies.js

@@ -0,0 +1,717 @@
+/**
+ * Strategies — Agent 执行策略
+ *
+ * 核心思想: "如何组织工作" 与 "能做什么" 正交。
+ *
+ * 四种策略:
+ *   1. SingleStrategy   — 单次 ReAct 循环 (最简单，用于对话)
+ *   2. PipelineStrategy — 顺序多阶段 + 质量门控 (分析→提交)
+ *   3. FanOutStrategy   — 并行执行 + 合并 (多维度冷启动)
+ *   4. AdaptiveStrategy — 运行时自动选择策略 (智能模式)
+ *
+ * 这就是为什么 "冷启动" 和 "扫描" 产出一致:
+ *   - 冷启动 = FanOut(items=dimensions, itemStrategy=Pipeline(analyze→gate→produce))
+ *   - 扫描   = Pipeline(analyze→gate→produce)
+ *   - 唯一区别: 作用域 (全项目 vs 单目录) 和并行度
+ *
+ * 借鉴:
+ *   - Anthropic: Prompt Chaining, Parallelization, Orchestrator-Worker
+ *   - LangGraph: StateGraph, parallel branches
+ *   - AutoGen: Sequential/Parallel teams
+ *
+ * @module strategies
+ */
+
+import { randomUUID } from 'node:crypto';
+import { AgentEventBus, AgentEvents } from './AgentEventBus.js';
+import { AgentMessage } from './AgentMessage.js';
+import { ExplorationTracker } from './context/ExplorationTracker.js';
+
+// ─── Base Strategy ─────────────────────────────
+
+/**
+ * Strategy 基类 — 定义 Agent 如何组织工作
+ */
+export class Strategy {
+  /** @type {string} */
+  get name() { throw new Error('Subclass must implement name'); }
+
+  /**
+   * 执行策略
+   *
+   * @param {Object} runtime — AgentRuntime 实例
+   * @param {import('./AgentMessage.js').AgentMessage} message — 输入消息
+   * @param {Object} [opts] — 策略特定选项
+   * @returns {Promise<StrategyResult>}
+   *
+   * @typedef {Object} StrategyResult
+   * @property {string} reply — 最终文本回复
+   * @property {Array} toolCalls — 所有工具调用记录
+   * @property {Object} tokenUsage — Token 统计
+   * @property {number} iterations — 总循环次数
+   * @property {Object} [phases] — 阶段详情 (Pipeline/FanOut)
+   */
+  async execute(_runtime, _message, _opts) {
+    throw new Error('Subclass must implement execute()');
+  }
+}
+
+// ─── SingleStrategy — 直接 ReAct ─────────────
+
+/**
+ * 最简单的策略: 直接运行 ReAct 循环。
+ *
+ * 适合: 用户对话、简单分析、任何单步骤任务。
+ *
+ * 等价于 Anthropic 的 "Augmented LLM" 模式。
+ */
+export class SingleStrategy extends Strategy {
+  get name() { return 'single'; }
+
+  async execute(runtime, message, opts = {}) {
+    return runtime.reactLoop(message.content, {
+      history: message.history,
+      context: message.metadata.context || {},
+      ...opts,
+    });
+  }
+}
+
+// ─── PipelineStrategy — 顺序多阶段 ──────────
+
+/**
+ * 多阶段顺序执行，每个阶段可以有不同的 Capability 和 Budget，
+ * 阶段间可插入质量门控 (Quality Gate)。
+ *
+ * 适合: 分析→提交、扫描→审计→报告
+ *
+ * 等价于 Anthropic 的 "Prompt Chaining" + "Evaluator-Optimizer"。
+ *
+ * 增强特性 (v3):
+ *   - Gate 支持自定义 evaluator 函数 (三态: pass/retry/degrade)
+ *   - Gate retry: 失败时回退重新执行前一阶段
+ *   - Stage 支持 promptBuilder(context) 替代简单 promptTransform
+ *   - Stage 支持 systemPrompt 覆盖 (per-phase 系统提示词)
+ *   - Stage 支持 onToolCall 钩子 (per-phase 工具调用通知)
+ *   - strategyContext: 通过 opts 传入的领域级上下文 (Bootstrap 注入 dimConfig/sessionStore/...)
+ *
+ * @example
+ * // 基础用法 (向后兼容)
+ * new PipelineStrategy({
+ *   stages: [
+ *     { name: 'analyze', capabilities: ['code_analysis'], budget: { maxIterations: 16 } },
+ *     { name: 'gate', gate: { minEvidenceLength: 500, minFileRefs: 3 } },
+ *     { name: 'produce', capabilities: ['knowledge_production'], budget: { maxIterations: 16 },
+ *       promptTransform: (input, prev) => `基于以下分析:\n${prev.analyze.reply}\n\n${input}` },
+ *   ],
+ * })
+ *
+ * @example
+ * // 增强用法 (Bootstrap)
+ * new PipelineStrategy({
+ *   stages: [
+ *     { name: 'analyze', capabilities: ['code_analysis'],
+ *       systemPrompt: ANALYST_SYSTEM_PROMPT,
+ *       promptBuilder: (ctx) => buildAnalystPrompt(ctx.dimConfig, ctx.projectInfo, ctx),
+ *       retryPromptBuilder: (retryCtx, input, prev) => `${prev.analyze.reply}\n\n${buildRetryPrompt(retryCtx.reason)}`,
+ *       onToolCall: (name, args, result, iter) => ac.recordToolCall(name, args, result, true),
+ *     },
+ *     { name: 'quality_gate', gate: {
+ *       evaluator: (source, phaseResults, ctx) => ({ action: 'pass'|'retry'|'degrade', reason, artifact }),
+ *       maxRetries: 1,
+ *     }},
+ *     { name: 'produce', capabilities: ['knowledge_production'],
+ *       systemPrompt: PRODUCER_SYSTEM_PROMPT,
+ *       promptBuilder: (ctx) => buildProducerPrompt(ctx.gateArtifact, ctx.dimConfig),
+ *       skipOnDegrade: true,
+ *     },
+ *   ],
+ * })
+ */
+export class PipelineStrategy extends Strategy {
+  /** @type {Array<Object>} */
+  #stages;
+  /** @type {number} 最大重试次数 (Gate 失败时全局兜底) */
+  #maxRetries;
+
+  constructor({ stages = [], maxRetries = 1 } = {}) {
+    super();
+    this.#stages = stages;
+    this.#maxRetries = maxRetries;
+  }
+
+  get name() { return 'pipeline'; }
+
+  async execute(runtime, message, opts = {}) {
+    const bus = AgentEventBus.getInstance();
+    const phaseResults = {};
+    const strategyContext = opts.strategyContext || {};
+    let totalToolCalls = [];
+    let totalTokenUsage = { input: 0, output: 0 };
+    let totalIterations = 0;
+    let gateArtifact = null;
+    let degraded = false;
+    let execStageCount = 0;  // 已执行的阶段计数 (用于阶段隔离)
+
+    for (let i = 0; i < this.#stages.length; i++) {
+      const stage = this.#stages[i];
+
+      // ── Quality Gate 阶段 ──
+      if (stage.gate) {
+        // 跳过 degrade 之后的 gate
+        if (degraded) continue;
+
+        const sourceName = stage.source || this.#prevStageName(stage);
+        const source = phaseResults[sourceName];
+        let gateResult;
+
+        // v3: 自定义评估器 (Bootstrap 用)
+        if (typeof stage.gate.evaluator === 'function') {
+          gateResult = stage.gate.evaluator(source, phaseResults, strategyContext);
+          // 规范化: 确保 action 字段存在
+          if (!gateResult.action) {
+            gateResult.action = gateResult.pass ? 'pass' : 'retry';
+          }
+        } else {
+          // 向后兼容: 阈值评估
+          const legacyResult = this.#evaluateGate(stage.gate, phaseResults, sourceName);
+          gateResult = {
+            action: legacyResult.pass ? 'pass' : 'retry',
+            pass: legacyResult.pass,
+            reason: legacyResult.reason,
+          };
+        }
+
+        bus.publish(AgentEvents.PROGRESS, {
+          type: 'quality_gate',
+          pass: gateResult.action === 'pass',
+          action: gateResult.action,
+          reason: gateResult.reason,
+          stage: stage.name || 'gate',
+        });
+
+        // 存储 gate 结果和产物
+        phaseResults[stage.name || 'gate'] = {
+          pass: gateResult.action === 'pass',
+          action: gateResult.action,
+          reason: gateResult.reason || '',
+          artifact: gateResult.artifact || null,
+        };
+        if (gateResult.artifact) gateArtifact = gateResult.artifact;
+
+        // v3: 三态处理
+        if (gateResult.action === 'pass') {
+          continue;
+        }
+
+        if (gateResult.action === 'degrade') {
+          degraded = true;
+          break;
+        }
+
+        if (gateResult.action === 'retry') {
+          const maxRetries = stage.gate.maxRetries ?? this.#maxRetries;
+          const retryKey = `_retries_${stage.name || 'gate'}`;
+          phaseResults[retryKey] = (phaseResults[retryKey] || 0) + 1;
+
+          if (phaseResults[retryKey] <= maxRetries) {
+            const prevIdx = this.#findPrevExecStageIdx(i);
+            if (prevIdx >= 0) {
+              const retryTargetStage = this.#stages[prevIdx];
+              phaseResults._retryContext = {
+                reason: gateResult.reason,
+                artifact: gateResult.artifact,
+              };
+              // 标记目标阶段为 retry, 供 retryBudget 判定
+              phaseResults[`_was_retry_${retryTargetStage.name}`] = true;
+              i = prevIdx - 1; // 循环 i++ 后回到 prevIdx
+              continue;
+            }
+          }
+          // 重试次数耗尽: 向后兼容 skipOnFail 逻辑
+          if (stage.skipOnFail !== false) break;
+          continue;
+        }
+
+        // 兜底: 未知 action 视为失败
+        if (stage.skipOnFail !== false) break;
+        continue;
+      }
+
+      // ── 执行阶段 ──
+
+      // 跳过 degrade 后的阶段 (除非显式标记 skipOnDegrade: false)
+      if (degraded && stage.skipOnDegrade !== false) continue;
+
+      bus.publish(AgentEvents.PROGRESS, {
+        type: 'pipeline_stage_start',
+        stage: stage.name,
+        capabilities: stage.capabilities?.map(c => typeof c === 'string' ? c : c.name),
+      });
+
+      // 构建阶段 prompt (优先级: retryPromptBuilder > promptBuilder > promptTransform > 原始)
+      let stagePrompt;
+      if (phaseResults._retryContext && stage.retryPromptBuilder) {
+        stagePrompt = stage.retryPromptBuilder(
+          phaseResults._retryContext, message.content, phaseResults,
+        );
+        delete phaseResults._retryContext;
+      } else if (stage.promptBuilder) {
+        // v3: 完整上下文感知的 prompt 构建
+        stagePrompt = stage.promptBuilder({
+          message: message.content,
+          phaseResults,
+          gateArtifact,
+          ...strategyContext,
+        });
+      } else if (stage.promptTransform) {
+        stagePrompt = stage.promptTransform(message.content, phaseResults);
+      } else {
+        stagePrompt = message.content;
+      }
+
+      // 清除已消费的 retryContext
+      if (phaseResults._retryContext) delete phaseResults._retryContext;
+
+      // Fork runtime with stage-specific capabilities and budget
+      // v3.1: retry 时使用 retryBudget (缩减预算, 如 Producer 拒绝修正轮)
+      const isRetry = !!phaseResults[`_was_retry_${stage.name}`];
+      const effectiveBudget = (isRetry && stage.retryBudget) ? stage.retryBudget : stage.budget;
+      delete phaseResults[`_was_retry_${stage.name}`];
+
+      // ── 阶段隔离 (v3.2) ──
+      // 避免 ContextWindow / ExplorationTracker 状态在阶段间泄漏
+      const ctxWin = strategyContext.contextWindow || null;
+      if (ctxWin && execStageCount > 0) {
+        ctxWin.resetForNewStage();
+      }
+
+      // 为每个阶段创建适当范围的 ExplorationTracker:
+      //   - analyze → 复用 orchestrator 创建的 bootstrap tracker (首个阶段)
+      //   - produce → 创建 producer 策略的独立 tracker
+      //   - 其他   → 创建 analyst 策略的独立 tracker
+      let stageTracker = strategyContext.tracker || null;
+      if (stageTracker && execStageCount > 0) {
+        const trackerStrategy = (stage.name === 'produce' || stage.name === 'producer')
+          ? 'producer'
+          : 'analyst';
+        stageTracker = ExplorationTracker.resolve(
+          { source: strategyContext.source || 'system', strategy: trackerStrategy },
+          effectiveBudget || {},
+        );
+      }
+      execStageCount++;
+
+      // ── 执行 reactLoop (含 per-stage 硬超时保护) ──
+      const reactPromise = runtime.reactLoop(stagePrompt, {
+        history: message.history,
+        context: { ...message.metadata.context, pipelinePhase: stage.name, previousPhases: phaseResults },
+        capabilityOverride: stage.capabilities,
+        budgetOverride: effectiveBudget,
+        systemPromptOverride: stage.systemPrompt,     // v3: per-phase 系统提示词
+        onToolCall: stage.onToolCall,                  // v3: per-phase 工具调用钩子
+        // ── 引擎增强参数: 从 strategyContext 透传 (tracker 使用阶段级实例) ──
+        contextWindow: ctxWin,
+        tracker: stageTracker,
+        trace: strategyContext.trace || null,
+        memoryCoordinator: strategyContext.memoryCoordinator || null,
+        sharedState: strategyContext.sharedState || null,
+        source: strategyContext.source || null,
+      });
+
+      // ── Per-stage hard timeout (安全网) ──
+      // 协作超时由 AgentRuntime.#shouldExit() 中的 budget.timeoutMs 检查处理 (优雅退出)
+      // 此处的硬超时 = budget.timeoutMs + 30s 缓冲，防止单次 LLM/Tool 调用阻塞过久
+      const stageTimeoutMs = effectiveBudget?.timeoutMs;
+      let stageResult;
+      if (stageTimeoutMs) {
+        const hardLimitMs = stageTimeoutMs + 30_000;
+        let hardTimer;
+        stageResult = await Promise.race([
+          reactPromise,
+          new Promise((_, reject) => {
+            hardTimer = setTimeout(
+              () => reject(new Error('__STAGE_HARD_TIMEOUT__')),
+              hardLimitMs,
+            );
+          }),
+        ]).catch(err => {
+          if (err.message === '__STAGE_HARD_TIMEOUT__') {
+            runtime.logger?.info?.(
+              `[PipelineStrategy] ⏰ Stage "${stage.name}" hard timeout (${hardLimitMs}ms) — continuing pipeline`,
+            );
+            bus.publish(AgentEvents.PROGRESS, {
+              type: 'pipeline_stage_timeout',
+              stage: stage.name,
+              timeoutMs: hardLimitMs,
+            });
+            return {
+              reply: '',
+              toolCalls: [],
+              iterations: 0,
+              tokenUsage: { input: 0, output: 0 },
+              timedOut: true,
+            };
+          }
+          throw err;
+        }).finally(() => clearTimeout(hardTimer));
+      } else {
+        stageResult = await reactPromise;
+      }
+
+      phaseResults[stage.name] = stageResult;
+      totalToolCalls.push(...(stageResult.toolCalls || []));
+      totalIterations += stageResult.iterations || 0;
+      if (stageResult.tokenUsage) {
+        totalTokenUsage.input += stageResult.tokenUsage.input || 0;
+        totalTokenUsage.output += stageResult.tokenUsage.output || 0;
+      }
+
+      bus.publish(AgentEvents.PROGRESS, {
+        type: 'pipeline_stage_done',
+        stage: stage.name,
+        iterations: stageResult.iterations,
+      });
+    }
+
+    // 最终回复 = 最后一个执行阶段的输出
+    const lastStage = Object.values(phaseResults).filter(r => r.reply).pop();
+
+    return {
+      reply: lastStage?.reply || '',
+      toolCalls: totalToolCalls,
+      tokenUsage: totalTokenUsage,
+      iterations: totalIterations,
+      phases: phaseResults,
+      degraded,
+    };
+  }
+
+  /**
+   * 质量门控评估 (向后兼容: 阈值模式)
+   */
+  #evaluateGate(gateConfig, phaseResults, sourceName) {
+    const source = phaseResults[sourceName];
+    if (!source?.reply) {
+      return { pass: false, reason: `No output from stage "${sourceName}"` };
+    }
+
+    const reply = source.reply;
+    const reasons = [];
+
+    if (gateConfig.minEvidenceLength && reply.length < gateConfig.minEvidenceLength) {
+      reasons.push(`分析长度不足: ${reply.length} < ${gateConfig.minEvidenceLength}`);
+    }
+
+    if (gateConfig.minFileRefs) {
+      const fileRefCount = (reply.match(/[\w/]+\.\w+/g) || []).length;
+      if (fileRefCount < gateConfig.minFileRefs) {
+        reasons.push(`文件引用不足: ${fileRefCount} < ${gateConfig.minFileRefs}`);
+      }
+    }
+
+    if (gateConfig.minToolCalls) {
+      const toolCalls = source.toolCalls?.length || 0;
+      if (toolCalls < gateConfig.minToolCalls) {
+        reasons.push(`工具调用不足: ${toolCalls} < ${gateConfig.minToolCalls}`);
+      }
+    }
+
+    if (gateConfig.custom && typeof gateConfig.custom === 'function') {
+      const customResult = gateConfig.custom(source);
+      if (!customResult.pass) reasons.push(customResult.reason);
+    }
+
+    return reasons.length === 0
+      ? { pass: true }
+      : { pass: false, reason: reasons.join('; ') };
+  }
+
+  /**
+   * 找到当前 gate 之前最近的执行阶段索引 (用于 retry 回退)
+   */
+  #findPrevExecStageIdx(currentIdx) {
+    for (let j = currentIdx - 1; j >= 0; j--) {
+      if (!this.#stages[j].gate) return j;
+    }
+    return -1;
+  }
+
+  #prevStageName(currentStage) {
+    const idx = this.#stages.indexOf(currentStage);
+    for (let i = idx - 1; i >= 0; i--) {
+      if (!this.#stages[i].gate && this.#stages[i].name) {
+        return this.#stages[i].name;
+      }
+    }
+    return null;
+  }
+}
+
+// ─── FanOutStrategy — 并行执行 ──────────────
+
+/**
+ * 并行执行多个子任务，每个子任务使用 itemStrategy (通常是 Pipeline)。
+ * 支持分层并发控制 (Tier)。
+ *
+ * 适合: 冷启动多维度、批量分析
+ *
+ * 等价于 Anthropic 的 "Parallelization" + "Orchestrator-Worker" 组合。
+ *
+ * @example
+ * new FanOutStrategy({
+ *   itemStrategy: new PipelineStrategy({
+ *     stages: [
+ *       { name: 'analyze', capabilities: ['code_analysis'], budget: { maxIterations: 24 } },
+ *       { name: 'gate', gate: { minEvidenceLength: 500, minFileRefs: 3 } },
+ *       { name: 'produce', capabilities: ['knowledge_production'], budget: { maxIterations: 24 },
+ *         promptTransform: (_, prev) => `将以下分析转为知识候选:\n${prev.analyze.reply}` },
+ *     ],
+ *   }),
+ *   tiers: { 1: { concurrency: 3 }, 2: { concurrency: 2 }, 3: { concurrency: 1 } },
+ * })
+ */
+export class FanOutStrategy extends Strategy {
+  /** @type {Strategy} 每个子任务的执行策略 */
+  #itemStrategy;
+  /** @type {Object} 分层并发配置 */
+  #tiers;
+  /** @type {Function} 结果合并函数 */
+  #merge;
+
+  /**
+   * @param {Object} opts
+   * @param {Strategy} opts.itemStrategy — 每个子任务使用的策略
+   * @param {Object} [opts.tiers] — { 1: { concurrency: 3 }, 2: { concurrency: 2 }, ... }
+   * @param {Function} [opts.merge] — 自定义合并函数 (results[]) => finalResult
+   */
+  constructor({ itemStrategy, tiers, merge } = {}) {
+    super();
+    this.#itemStrategy = itemStrategy || new SingleStrategy();
+    this.#tiers = tiers || { 1: { concurrency: 3 } };
+    this.#merge = merge || FanOutStrategy.#defaultMerge;
+  }
+
+  get name() { return 'fan_out'; }
+
+  /**
+   * @param {Object} runtime
+   * @param {import('./AgentMessage.js').AgentMessage} message
+   * @param {Object} opts
+   * @param {Array<{id: string, label: string, tier?: number, prompt?: string, guide?: string}>} opts.items — 子任务列表
+   */
+  async execute(runtime, message, opts = {}) {
+    const { items = [] } = opts;
+    const bus = AgentEventBus.getInstance();
+
+    if (items.length === 0) {
+      return { reply: 'No items to process', toolCalls: [], tokenUsage: { input: 0, output: 0 }, iterations: 0 };
+    }
+
+    // 按 tier 分组
+    const tierGroups = this.#groupByTier(items);
+    const allResults = [];
+
+    for (const [tier, tierItems] of Object.entries(tierGroups).sort(([a], [b]) => a - b)) {
+      const tierConfig = this.#tiers[tier] || this.#tiers[1] || { concurrency: 2 };
+
+      bus.publish(AgentEvents.PROGRESS, {
+        type: 'fan_out_tier_start',
+        tier: Number(tier),
+        count: tierItems.length,
+        concurrency: tierConfig.concurrency,
+      });
+
+      // 按并发度分批执行
+      const chunks = this.#chunk(tierItems, tierConfig.concurrency);
+      for (const chunk of chunks) {
+        const chunkPromises = chunk.map(async (item) => {
+          const itemMessage = AgentMessage.internal(
+            item.prompt || `${message.content}\n\n## 当前维度: ${item.label}\n${item.guide || ''}`,
+            {
+              sessionId: message.session.id,
+              dimension: item.id,
+              parentAgentId: runtime.id,
+              history: message.history,
+              metadata: { ...message.metadata, dimension: item },
+            }
+          );
+
+          bus.publish(AgentEvents.PROGRESS, {
+            type: 'fan_out_item_start',
+            itemId: item.id,
+            label: item.label,
+          });
+
+          try {
+            const result = await this.#itemStrategy.execute(runtime, itemMessage, {
+              dimension: item,
+            });
+            return { id: item.id, label: item.label, status: 'completed', ...result };
+          } catch (err) {
+            return { id: item.id, label: item.label, status: 'failed', error: err.message, reply: '', toolCalls: [], tokenUsage: { input: 0, output: 0 } };
+          }
+        });
+
+        const chunkResults = await Promise.all(chunkPromises);
+        allResults.push(...chunkResults);
+      }
+
+      bus.publish(AgentEvents.PROGRESS, {
+        type: 'fan_out_tier_done',
+        tier: Number(tier),
+        completed: allResults.filter(r => r.status === 'completed').length,
+        failed: allResults.filter(r => r.status === 'failed').length,
+      });
+    }
+
+    return this.#merge(allResults);
+  }
+
+  #groupByTier(items) {
+    const groups = {};
+    for (const item of items) {
+      const tier = item.tier || 1;
+      if (!groups[tier]) groups[tier] = [];
+      groups[tier].push(item);
+    }
+    return groups;
+  }
+
+  #chunk(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+      chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+  }
+
+  static #defaultMerge(results) {
+    const successful = results.filter(r => r.status === 'completed');
+    const failed = results.filter(r => r.status === 'failed');
+    return {
+      reply: [
+        `## 执行总结\n完成: ${successful.length}, 失败: ${failed.length}\n`,
+        ...successful.map(r => `### ${r.label}\n${r.reply || '(无输出)'}`),
+        ...failed.map(r => `### ${r.label} ❌\n${r.error}`),
+      ].join('\n\n'),
+      toolCalls: results.flatMap(r => r.toolCalls || []),
+      tokenUsage: {
+        input: results.reduce((sum, r) => sum + (r.tokenUsage?.input || 0), 0),
+        output: results.reduce((sum, r) => sum + (r.tokenUsage?.output || 0), 0),
+      },
+      iterations: results.reduce((sum, r) => sum + (r.iterations || 0), 0),
+      itemResults: results,
+    };
+  }
+}
+
+// ─── AdaptiveStrategy — 智能自适应 ──────────
+
+/**
+ * 根据输入复杂度自动选择合适的策略。
+ *
+ * 判断逻辑:
+ *   - 简单问答 → SingleStrategy
+ *   - 单模块深度分析 → PipelineStrategy
+ *   - 多维度/全项目 → FanOutStrategy
+ *
+ * 等价于 LangGraph 的 Router 节点 + 条件边。
+ *
+ * @example
+ * new AdaptiveStrategy({
+ *   single: new SingleStrategy(),
+ *   pipeline: new PipelineStrategy({ stages: [...] }),
+ *   fanOut: new FanOutStrategy({ itemStrategy: ..., tiers: ... }),
+ * })
+ */
+export class AdaptiveStrategy extends Strategy {
+  #strategies;
+
+  /**
+   * @param {Object} [strategies]
+   * @param {Strategy} [strategies.single]
+   * @param {Strategy} [strategies.pipeline]
+   * @param {Strategy} [strategies.fanOut]
+   */
+  constructor(strategies = {}) {
+    super();
+    this.#strategies = {
+      single: strategies.single || new SingleStrategy(),
+      pipeline: strategies.pipeline || null,
+      fanOut: strategies.fanOut || null,
+    };
+  }
+
+  get name() { return 'adaptive'; }
+
+  async execute(runtime, message, opts = {}) {
+    const complexity = this.#assessComplexity(message, opts);
+    const bus = AgentEventBus.getInstance();
+
+    bus.publish(AgentEvents.PROGRESS, {
+      type: 'adaptive_classification',
+      complexity,
+      selectedStrategy: complexity,
+    });
+
+    switch (complexity) {
+      case 'fan_out':
+        if (this.#strategies.fanOut) {
+          return this.#strategies.fanOut.execute(runtime, message, opts);
+        }
+        // fallthrough
+      case 'pipeline':
+        if (this.#strategies.pipeline) {
+          return this.#strategies.pipeline.execute(runtime, message, opts);
+        }
+        // fallthrough
+      default:
+        return this.#strategies.single.execute(runtime, message, opts);
+    }
+  }
+
+  /**
+   * 复杂度评估
+   */
+  #assessComplexity(message, opts) {
+    const text = message.content.toLowerCase();
+
+    // 有显式 items → fan_out
+    if (opts.items?.length > 1) return 'fan_out';
+
+    // 关键词启发
+    if (/冷启动|cold[\s-]?start|bootstrap|全项目|所有.*维度|all.*dimensions/i.test(text)) {
+      return 'fan_out';
+    }
+
+    if (/深度.*分析|扫描|审计|scan|deep.*analy|audit|知识提取|extract/i.test(text)) {
+      return 'pipeline';
+    }
+
+    return 'single';
+  }
+}
+
+// ─── Strategy 注册表 ─────────────────────────
+
+export const StrategyRegistry = {
+  _registry: new Map([
+    ['single', SingleStrategy],
+    ['pipeline', PipelineStrategy],
+    ['fan_out', FanOutStrategy],
+    ['adaptive', AdaptiveStrategy],
+  ]),
+
+  create(name, opts = {}) {
+    const Cls = this._registry.get(name);
+    if (!Cls) throw new Error(`Unknown strategy: ${name}`);
+    return new Cls(opts);
+  },
+
+  register(name, cls) {
+    this._registry.set(name, cls);
+  },
+};
+
+export default { Strategy, SingleStrategy, PipelineStrategy, FanOutStrategy, AdaptiveStrategy, StrategyRegistry };