autosnippet 3.2.9 → 3.2.10

package/lib/cli/deploy/FileManifest.js

@@ -146,7 +146,7 @@ export const MANIFEST = [
     src: 'pre-commit-guard.sh',
     dest: null,  // 动态决定：.husky/pre-commit 或 .git/hooks/pre-commit
     strategy: 'create-only',
-    on: 'setup',
+    on: 'manual',           // 暂不在 setup 中强制安装 git 工作流
     category: 'pre-commit-hook',
     chmod: true,
     resolveDest: 'resolvePreCommitDest',

package/lib/external/ai/providers/GoogleGeminiProvider.js

@@ -115,10 +115,12 @@ export class GoogleGeminiProvider extends AiProvider {
         ];
       }
 
-      // toolChoice → Gemini mode
-      body.toolConfig = {
-        functionCallingConfig: { mode: this.#toGeminiMode(toolChoice) },
-      };
+      // toolChoice → Gemini mode (仅在有工具声明时设置，无工具时设 toolConfig 可能导致空响应)
+      if (body.tools) {
+        body.toolConfig = {
+          functionCallingConfig: { mode: this.#toGeminiMode(toolChoice) },
+        };
+      }
 
       // 系统指令
       if (systemPrompt) {

package/lib/external/mcp/handlers/bootstrap/pipeline/orchestrator.js

@@ -24,6 +24,7 @@ import { SessionStore } from '../../../../../service/agent/memory/SessionStore.j
 import { AgentMessage } from '../../../../../service/agent/AgentMessage.js';
 import { BudgetPolicy } from '../../../../../service/agent/policies.js';
 import { PRESETS } from '../../../../../service/agent/presets.js';
+import { ANALYST_BUDGET } from '../../../../../service/agent/domain/insight-analyst.js';
 import { ContextWindow } from '../../../../../service/agent/context/ContextWindow.js';
 import { ExplorationTracker } from '../../../../../service/agent/context/ExplorationTracker.js';
 import { clearCheckpoints, loadCheckpoints, saveDimensionCheckpoint } from './checkpoint.js';
@@ -607,9 +608,12 @@ export async function fillDimensionsV3(fillContext) {
         outputType: dimConfig.outputType || 'analysis',
         // ── 引擎增强参数 (PipelineStrategy → reactLoop 透传) ──
         contextWindow: agentFactory.createContextWindow({ isSystem: true }),
+        // B1 fix: 分析阶段使用 analyst 策略 (SCAN→EXPLORE→VERIFY→SUMMARIZE)
+        // 而非 bootstrap (EXPLORE→PRODUCE→SUMMARIZE)，避免 PRODUCE nudge 浪费轮次
+        // B3 fix: 透传完整 ANALYST_BUDGET (searchBudget/maxSubmits/softSubmitLimit/idleRoundsToExit)
         tracker: ExplorationTracker.resolve(
-          { source: 'system', dimensionMeta: dimConfig },
-          { maxIterations: PRESETS.insight.strategy.stages[0].budget?.maxIterations || 24 },
+          { source: 'system', strategy: 'analyst' },
+          { ...ANALYST_BUDGET },
         ),
         trace: memoryCoordinator.getActiveContext(analystScopeId),
         memoryCoordinator,

package/lib/http/routes/recipes.js

@@ -111,11 +111,7 @@ router.post(
     // 异步执行，不 await
     (async () => {
       try {
-        const result = await agentFactory.scanKnowledge({
-          label: 'knowledge-graph',
-          files: [],
-          task: 'relations',
-        });
+        const result = await agentFactory.discoverRelations();
         discoverTask.status = 'done';
         discoverTask.finishedAt = new Date().toISOString();
         discoverTask.discovered = result.discovered || 0;

package/lib/service/agent/AgentFactory.js

@@ -23,8 +23,8 @@ import { BudgetPolicy, PolicyEngine } from './policies.js';
 import { getPreset, resolveStrategy } from './presets.js';
 import { ContextWindow } from './context/ContextWindow.js';
 import { ExplorationTracker } from './context/ExplorationTracker.js';
-import { ANALYST_SYSTEM_PROMPT } from './domain/insight-analyst.js';
-import { SCAN_TASK_CONFIGS } from './domain/scan-prompts.js';
+import { MemoryCoordinator } from './memory/MemoryCoordinator.js';
+import { SCAN_TASK_CONFIGS, buildScanPipelineStages, buildRelationsPipelineStages } from './domain/scan-prompts.js';
 
 export class AgentFactory {
   #container;
@@ -138,26 +138,63 @@ export class AgentFactory {
    * 抽取 bootstrap orchestrator 中创建 ExplorationTracker / ContextWindow / source 的
    * 通用逻辑，供 scanKnowledge 等系统场景共用完整的多轮 Agent 框架。
    *
-   * bootstrap orchestrator 不使用此方法（它还需要领域特定的 MemoryCoordinator / dimContext 等），
+   * 与 bootstrap orchestrator 保持一致的 MemoryCoordinator 管理模式:
+   *   - 创建轻量级 MemoryCoordinator (无 PersistentMemory/SessionStore)
+   *   - 通过 MC.createDimensionScope 创建并注册 ActiveContext
+   *   - trace 从 MC.getActiveContext 获取 (统一生命周期管理)
+   *   - memoryCoordinator 传入 strategyContext，供 reactLoop 每轮 buildDynamicMemoryPrompt
+   *
+   * 与 bootstrap orchestrator 对齐的关键字段:
+   *   - activeContext: 与 trace 同一实例 — insightGateEvaluator 通过此字段
+   *     决定走 buildAnalysisArtifact (完整: findings/evidenceMap/negativeSignals)
+   *     还是 buildAnalysisReport (降级: 仅文本)
+   *   - outputType: 'candidate' — 设置 quality_gate 的评判标准
+   *   - dimId: 维度 ID — buildAnalysisArtifact 的 dimensionId 参数
+   *
+   * bootstrap orchestrator 不使用此方法（它还需要领域特定的 SessionStore / dimContext 等），
    * 但引擎层基础设施是一致的。
    *
    * @param {Object} [opts]
    * @param {Object} [opts.budget] — 预算覆盖 (透传给 ExplorationTracker)
    * @param {string} [opts.trackerStrategy='analyst'] — tracker 策略名: 'analyst' | 'producer' | 'bootstrap'
-   * @returns {{ contextWindow: ContextWindow, tracker: ExplorationTracker, sharedState: Object, source: string }}
+   * @param {string} [opts.label='default'] — 作用域标签 (用于 scopeId 命名 + dimId)
+   * @param {string} [opts.lang] — 项目语言 (透传给 sharedState._projectLanguage)
+   * @returns {{ contextWindow: ContextWindow, tracker: ExplorationTracker, trace: import('./memory/ActiveContext.js').ActiveContext, activeContext: import('./memory/ActiveContext.js').ActiveContext, memoryCoordinator: MemoryCoordinator, outputType: string, dimId: string, sharedState: Object, source: string, scopeId: string }}
    */
-  buildSystemContext({ budget, trackerStrategy = 'analyst' } = {}) {
+  buildSystemContext({ budget, trackerStrategy = 'analyst', label = 'default', lang } = {}) {
+    // 创建轻量级 MemoryCoordinator (scan 场景无 PersistentMemory/SessionStore)
+    const mc = new MemoryCoordinator({ mode: 'bootstrap' });
+    const scopeId = `scan:${label}`;
+    mc.createDimensionScope(scopeId);
+
+    const activeContext = mc.getActiveContext(scopeId);
+
     return {
       contextWindow: this.createContextWindow({ isSystem: true }),
       tracker: ExplorationTracker.resolve(
         { source: 'system', strategy: trackerStrategy },
         budget || {},
       ),
+      // trace & activeContext 是同一个 ActiveContext 实例
+      // trace: AgentRuntime reactLoop 使用 (startRound/setThought/endRound)
+      // activeContext: insightGateEvaluator 检查此字段决定 artifact 路径
+      trace: activeContext,
+      activeContext,
+      memoryCoordinator: mc,
+      // outputType: bootstrap orchestrator 设为 'candidate'（insightGateEvaluator 的评判标准）
+      outputType: 'candidate',
+      // dimId: buildAnalysisArtifact 的 dimensionId 参数
+      dimId: label,
       sharedState: {
         submittedTitles: new Set(),
         submittedPatterns: new Set(),
+        // G6: _projectLanguage — ToolExecutionPipeline 透传给工具 handler 上下文
+        _projectLanguage: lang || null,
+        // G7: _dimensionScopeId — ToolExecutionPipeline 透传给工具 handler (note_finding scope)
+        _dimensionScopeId: scopeId,
       },
       source: 'system',
+      scopeId,
     };
   }
 
@@ -209,15 +246,19 @@ export class AgentFactory {
   // ─── 领域语义方法 (意图驱动, Agent 直接完成 AI 推理) ─────
 
   /**
-   * 统一知识扫描 — 走 insight 管线 (Analyze → QualityGate → Produce)
+   * 统一知识扫描 — 走 insight 管线 (Analyze → QualityGate → Produce → RejectionGate)
+   *
+   * extract 和 summarize 共享工具驱动管线 (collect_scan_recipe)，
+   * 仅 Produce 阶段的 systemPrompt 和预算不同:
+   * - extract: 多文件 target 扫描，24 iter analyze，24 iter produce
+   * - summarize: 单文件/代码片段，12 iter analyze，12 iter produce
    *
-   * 三种任务模式共享同一管线，仅 Produce 阶段的 systemPrompt 不同。
-   * 替代: extractRecipes + summarizeCode + discoverRelations
+   * 关系发现请使用单独的 discoverRelations() 方法。
    *
    * @param {Object} opts
    * @param {string} opts.label              — 上下文标签（target 名 / 文件名）
    * @param {Array<{name, content, language?}>} opts.files — 源文件
-   * @param {'extract'|'summarize'|'relations'} [opts.task='extract'] — 任务类型
+   * @param {'extract'|'summarize'} [opts.task='extract'] — 任务类型
    * @param {string} [opts.lang]             — 语言提示
    * @param {boolean} [opts.comprehensive]   — 深度扫描标志
    * @returns {Promise<Object>}              — task-specific JSON
@@ -229,60 +270,29 @@ export class AgentFactory {
     }
     const { producePrompt, fallback } = taskConfig;
 
-    // relations task 需要知识查询工具
-    const caps = task === 'relations'
-      ? ['code_analysis', 'knowledge_production']
-      : ['code_analysis'];
-
-    // produce 阶段: extract 使用 scan_production（工具驱动，与冷启动一致），
-    // summarize/relations 保持纯文本输出
-    const produceCaps = task === 'extract'
-      ? ['scan_production']
-      : [];
-
-    // ── Pipeline 配置 (与冷启动对齐: 24 轮标准) ──
-    const analyzeMaxIter = 24;
-    const stages = [
-      {
-        name: 'analyze',
-        capabilities: caps,
-        budget: { maxIterations: analyzeMaxIter, maxTokens: 8192, temperature: 0.3 },
-        systemPrompt: ANALYST_SYSTEM_PROMPT,
-      },
-      {
-        name: 'produce',
-        capabilities: produceCaps,
-        budget: { maxIterations: 24, temperature: 0.2 },
-        systemPrompt: producePrompt,
-        promptTransform: (_input, prev) => {
-          const analysis = prev.analyze?.reply || '';
-          if (analysis.length >= 200) {
-            return `将以下代码分析转化为结构化输出。\n\n## 代码分析\n${analysis}`;
-          }
-          // Fallback: analyze reply 不足时直接提供源代码
-          const fileCtx = (files || []).slice(0, 15).map(f => {
-            const body = f.content.length > 1200
-              ? f.content.slice(0, 1200) + '\n// ... (truncated)'
-              : f.content;
-            return `### ${f.relativePath}\n\`\`\`\n${body}\n\`\`\``;
-          }).join('\n\n');
-          const preamble = analysis
-            ? `## 部分分析\n${analysis}\n\n`
-            : '';
-          return `${preamble}分析以下 ${files?.length || 0} 个源文件，提取知识 Recipe。\n\n${fileCtx}`;
-        },
-      },
-    ];
+    // extract 和 summarize 都使用 code_analysis 分析 + scan_production 工具驱动
+    const analyzeCaps = ['code_analysis'];
+    const produceCaps = ['scan_production'];
+
+    // ── 统一 4 阶段 Pipeline (与冷启动 orchestrator 对齐) ──
+    // summarize (单文件) 使用较低预算
+    const analyzeMaxIter = task === 'summarize' ? 12 : 24;
+    const stages = buildScanPipelineStages({
+      task,
+      producePrompt,
+      analyzeCaps,
+      produceCaps,
+      files,
+      analyzeMaxIter,
+    });
 
     // ── 创建 Runtime — 使用 insight preset + 对齐 policies ──
-    // policies override: 让 Runtime 级 BudgetPolicy 与 stage budget 对齐
-    // (避免 insight preset 的 maxIterations:24 与 stage 的 10 冲突)
     const runtime = this.createRuntime(PresetName.INSIGHT, {
-      strategy: { type: 'pipeline', stages },
-      capabilities: caps,
+      strategy: { type: 'pipeline', maxRetries: 1, stages },
+      capabilities: analyzeCaps,
       policies: [
         new BudgetPolicy({
-          maxIterations: 30, // 24 stage budget + 6 tracker grace (SUMMARIZE 2轮 + 硬上限 buffer)
+          maxIterations: 30, // 24 stage budget + 6 tracker grace
           maxTokens: 8192,
           temperature: 0.3,
           timeoutMs: 600_000,
@@ -295,20 +305,12 @@ export class AgentFactory {
       runtime.setFileCache(files);
     }
 
-    // ── 完整的系统级多轮基础设施 ──
-    // ExplorationTracker (analyst 策略) 提供:
-    //   - 四阶段管理: SCAN → EXPLORE → VERIFY → SUMMARIZE
-    //   - Nudge: budget_warning / convergence / reflection / force_exit
-    //   - 阶段 toolChoice: SUMMARIZE='none' 强制 LLM 输出文本
-    //   - Graceful exit: 终结阶段 2 轮 grace + 硬上限兜底
-    // ContextWindow 提供:
-    //   - 自动三级递进上下文压缩
-    // source:'system' 提供:
-    //   - 空响应自动重试 (2 次)
-    //   - finalize 强制摘要兜底
+    // ── 完整的系统级多轮基础设施 (含 MemoryCoordinator 管理 ActiveContext) ──
     const systemCtx = this.buildSystemContext({
       budget: { maxIterations: analyzeMaxIter },
       trackerStrategy: 'analyst',
+      label: `${task}:${label}`,
+      lang,
     });
 
     // ── 执行 ──
@@ -317,36 +319,79 @@ export class AgentFactory {
     );
     const result = await runtime.execute(message, { strategyContext: systemCtx });
 
-    // ── 提取结果 ──
-    if (task === 'extract') {
-      // 工具驱动模式: 从 tool calls 中提取 collected recipes (与冷启动相同的提取方式)
-      const allToolCalls = result.toolCalls || [];
-      const recipes = allToolCalls
-        .filter(tc => (tc.tool || tc.name) === 'collect_scan_recipe')
-        .map(tc => {
-          // 优先从 handler 返回的 recipe 对象取，回退到参数
-          const res = tc.result;
-          if (res && typeof res === 'object' && res.status === 'collected' && res.recipe) {
-            return res.recipe;
-          }
-          return null;
-        })
-        .filter(Boolean);
-
-      if (recipes.length > 0) {
-        return { targetName: label, extracted: recipes.length, recipes };
+    // ── 提取结果 — extract 和 summarize 统一从 toolCalls 提取 ──
+    const allToolCalls = result.toolCalls || [];
+    const recipes = allToolCalls
+      .filter(tc => (tc.tool || tc.name) === 'collect_scan_recipe')
+      .map(tc => {
+        const res = tc.result;
+        if (res && typeof res === 'object' && res.status === 'collected' && res.recipe) {
+          return res.recipe;
+        }
+        return null;
+      })
+      .filter(Boolean);
+
+    if (recipes.length > 0) {
+      // summarize 向后兼容: 扁平化首个 recipe 为 { title, summary, usageGuide, ... }
+      if (task === 'summarize') {
+        const first = recipes[0];
+        return {
+          title: first.title || '',
+          summary: first.description || first.summary || '',
+          usageGuide: first.usageGuide || '',
+          category: first.category || '',
+          headers: first.headers || [],
+          tags: first.tags || [],
+          trigger: first.trigger || '',
+          recipes,
+          extracted: recipes.length,
+        };
       }
-
-      // Fallback: 工具未被调用时，尝试从文本解析
-      const produceReply = result.phases?.produce?.reply || result.reply;
-      return this.#parseJsonResponse(produceReply, fallback(label));
+      return { targetName: label, extracted: recipes.length, recipes };
     }
 
-    // summarize / relations: 纯文本 JSON 输出
+    // Fallback: 工具未被调用时，尝试从文本解析
     const produceReply = result.phases?.produce?.reply || result.reply;
     return this.#parseJsonResponse(produceReply, fallback(label));
   }
 
+  /**
+   * 知识图谱关系发现 — 独立管线 (Explore → Synthesize)
+   *
+   * 与 scanKnowledge 不同，relations 不需要源文件输入，
+   * 而是通过查询知识库 + 读取源码发现知识条目间的语义关系。
+   *
+   * @param {Object} [opts]
+   * @param {number} [opts.batchSize=20] — 批次大小提示
+   * @returns {Promise<{ analyzed: number, relations: Array }>}
+   */
+  async discoverRelations({ batchSize = 20 } = {}) {
+    const stages = buildRelationsPipelineStages();
+
+    const runtime = this.createRuntime(PresetName.INSIGHT, {
+      strategy: { type: 'pipeline', stages },
+      capabilities: ['knowledge_production', 'code_analysis'],
+      policies: [
+        new BudgetPolicy({
+          maxIterations: 28,
+          maxTokens: 8192,
+          temperature: 0.3,
+          timeoutMs: 420_000,
+        }),
+      ],
+      memory: { enabled: false },
+    });
+
+    const message = AgentMessage.internal(
+      `探索知识库中所有知识条目之间的语义关系。每批分析约 ${batchSize} 条知识。`,
+    );
+    const result = await runtime.execute(message);
+
+    const synthesizeReply = result.phases?.synthesize?.reply || result.reply;
+    return this.#parseJsonResponse(synthesizeReply, { analyzed: 0, relations: [] });
+  }
+
   /**
    * AI 翻译 — chat 模式，单轮生成
    *

package/lib/service/agent/AgentRuntime.js

@@ -334,7 +334,7 @@ export class AgentRuntime {
       : this.capabilities;
 
     // 构建基础系统提示词
-    const baseSystemPrompt = systemPromptOverride || this.#buildSystemPrompt(caps, context);
+    let baseSystemPrompt = systemPromptOverride || this.#buildSystemPrompt(caps, context);
 
     // 收集工具 (caps 为空数组时 = 明确无工具)
     const allowedTools = this.#collectTools(caps);
@@ -361,6 +361,16 @@ export class AgentRuntime {
       maxIterations: 20, maxTokens: 4096, temperature: 0.7,
     };
 
+    // 系统源: 注入轮次预算 (先验锚定阶段节奏)
+    // 与旧版 ChatAgent 对齐: 60% 探索 → 80% 验证 → 最后 20% 输出总结
+    const isSystem = source === 'system';
+    if (isSystem && tracker && !baseSystemPrompt.includes('轮次预算')) {
+      const maxIter = budget.maxIterations || 24;
+      const exploreEnd = Math.floor(maxIter * 0.6);
+      const verifyEnd = Math.floor(maxIter * 0.8);
+      baseSystemPrompt += `\n\n## 轮次预算\n- 总轮次: **${maxIter} 轮**\n- 探索阶段: 第 1-${exploreEnd} 轮（搜索和结构化查询）\n- 验证阶段: 第 ${exploreEnd + 1}-${verifyEnd} 轮（读取关键文件确认细节）\n- 总结阶段: 第 ${verifyEnd + 1}-${maxIter} 轮（**停止工具调用，输出分析文本**）\n\n到达第 ${verifyEnd} 轮时你必须开始输出总结，不要继续搜索。`;
+    }
+
     // 状态转移
     this.#safeTransition('start', { prompt: prompt.slice(0, 100) });
     this.#safeTransition('plan_ready');
@@ -534,10 +544,15 @@ export class AgentRuntime {
 
     let llmResult;
     try {
+      // toolChoice='none' 时不发送 toolSchemas —— 部分 LLM (Gemini) 在看到
+      // 工具定义但被禁止调用时会返回空内容，导致 SUMMARIZE 阶段失败
+      const effectiveToolSchemas = toolChoice === 'none'
+        ? undefined
+        : (ctx.toolSchemas.length > 0 ? ctx.toolSchemas : undefined);
       llmResult = await this.aiProvider.chatWithTools(effectivePrompt, {
         messages: ctx.messages.toMessages(),
-        toolSchemas: ctx.toolSchemas.length > 0 ? ctx.toolSchemas : undefined,
-        toolChoice,
+        toolSchemas: effectiveToolSchemas,
+        toolChoice: effectiveToolSchemas ? toolChoice : undefined,
         systemPrompt: effectiveSystemPrompt,
         temperature: ctx.budget.temperature ?? (ctx.isSystem ? 0.3 : 0.7),
         maxTokens: ctx.budget.maxTokens ?? (ctx.isSystem ? 8192 : 4096),
@@ -563,6 +578,24 @@ export class AgentRuntime {
 
     // 空响应重试
     if (!llmResult.text && !llmResult.functionCalls?.length) {
+      // B4 fix: SUMMARIZE 阶段也允许重试 — force_exit nudge 刚注入时 LLM 可能
+      // 需要额外一轮才能生成有效输出。与 ExplorationTracker 的 2 轮 grace 对齐，
+      // 避免 grace 机制被架空。重试次数由 tracker.phaseRounds 控制而非独立计数。
+      const isTerminal = ctx.tracker && (ctx.tracker.phase === 'SUMMARIZE');
+      if (isTerminal) {
+        const phaseRounds = ctx.tracker.metrics?.phaseRounds ?? 0;
+        if (phaseRounds < 2) {
+          ctx.consecutiveEmptyResponses++;
+          this.logger.warn(
+            `[AgentRuntime] ⚠ empty response in SUMMARIZE — retrying (grace ${phaseRounds + 1}/2)`
+          );
+          // 不 rollbackTick: 让 tracker 计入 phaseRounds 以便到达 grace 上限退出
+          await new Promise(r => setTimeout(r, 1500));
+          return { __continue: true };
+        }
+        this.logger.warn('[AgentRuntime] ⚠ empty response in SUMMARIZE (grace exhausted) — proceeding to forced summary');
+        return null;
+      }
       if (ctx.isSystem && ctx.consecutiveEmptyResponses < 2) {
         ctx.consecutiveEmptyResponses++;
         this.logger.warn(
@@ -843,6 +876,13 @@ export class AgentRuntime {
    * @returns {Promise<Object>}
    */
   async #finalize(ctx) {
+    // Scan pipeline: 所有结果在 toolCalls 中 (collect_scan_recipe)，不需要文本回复
+    // 直接跳过 forced summary，避免浪费一次 LLM 调用
+    if (!ctx.lastReply && ctx.tracker?.submitToolName === 'collect_scan_recipe') {
+      const recipeCount = ctx.toolCalls.filter(tc => (tc.tool || tc.name) === 'collect_scan_recipe').length;
+      ctx.lastReply = `[scan complete: ${recipeCount} recipes collected]`;
+    }
+
     // 强制摘要 (系统场景或 tracker 场景)
     if (!ctx.lastReply && (ctx.tracker || ctx.isSystem)) {
       const forcedResult = await produceForcedSummary({

package/lib/service/agent/capabilities.js

@@ -239,11 +239,12 @@ export class KnowledgeProduction extends Capability {
   }
 
   get tools() {
+    // 与旧版 PRODUCER_TOOLS 保持一致: 仅 3 个核心工具
+    // guard_check_code / validate_candidate 不需要：提交时 UnifiedValidator 已自动校验
+    // 额外工具会分散 LLM 注意力，浪费 produce 轮次在验证而非提交上
     return [
       'submit_knowledge', 'submit_with_check',
       'read_project_file', // 获取代码片段用于知识正文
-      'guard_check_code',  // 提交前质量检查
-      'validate_candidate', // 校验候选质量
     ];
   }
 }