autosnippet 3.2.8 → 3.2.9

package/lib/external/mcp/handlers/bootstrap/shared/bootstrap-phases.js

@@ -615,7 +615,7 @@ export async function runAllPhases(projectRoot, ctx, options = {}) {
   // ── 清除旧数据 (if requested) ──
   if (options.clearOldData) {
     try {
-      const { clearCheckpoints, clearSnapshots } = await import('../../pipeline/orchestrator.js');
+      const { clearCheckpoints, clearSnapshots } = await import('../pipeline/orchestrator.js');
       await clearCheckpoints(projectRoot);
       await clearSnapshots(projectRoot, ctx);
       ctx.logger.info('[Bootstrap] Cleared old checkpoints and snapshots');
@@ -636,10 +636,12 @@ export async function runAllPhases(projectRoot, ctx, options = {}) {
       allFiles, langStats,
       primaryLang: null, discoverer, allTargets,
       astProjectSummary: null, astContext: '',
-      codeEntityResult: null, depGraphData: null,
+      codeEntityResult: null, callGraphResult: null,
+      depGraphData: null, depEdgesWritten: 0,
       guardAudit: null, guardEngine: null,
       activeDimensions: [], enhancementPackInfo: [],
-      enhancementPatterns: [], langProfile: {},
+      enhancementPatterns: [], enhancementGuardRules: [],
+      langProfile: {},
       targetsSummary: [], warnings,
       report: report || {},
       incrementalPlan: null,
@@ -652,12 +654,11 @@ export async function runAllPhases(projectRoot, ctx, options = {}) {
   let incrementalPlan = null;
   if (options.incremental) {
     try {
-      const { IncrementalBootstrap } = await import('../../pipeline/IncrementalBootstrap.js');
+      const { IncrementalBootstrap } = await import('../pipeline/IncrementalBootstrap.js');
       const db = ctx.container?.resolve?.('db') ?? ctx.db;
       if (db) {
         const ib = new IncrementalBootstrap(db, projectRoot, { logger: ctx.logger });
-        const dimIds = (await import('./dimension-configs.js')).getDimensionConfigs?.()
-          ?.map(d => d.id) || [];
+        const dimIds = baseDimensions.map(d => d.id);
         incrementalPlan = await ib.evaluate(allFiles, dimIds);
         if (report) report.phases.incremental = { plan: incrementalPlan };
         ctx.logger.info(`[Bootstrap] Incremental mode: ${incrementalPlan.mode}, affected: ${incrementalPlan.affectedDimensions?.length || 0}`);

package/lib/external/mcp/handlers/bootstrap/shared/dimension-sop.js

@@ -6,7 +6,7 @@
  *
  * 参考:
  *   - MetaGPT SOP 驱动模式 (docs/design/external-agent-quality-gap.md §4.2)
- *   - 内部 Agent 的 AnalystAgent + ProducerAgent 双阶段流程
+ *   - 内部 Agent 的 PipelineStrategy (Analyze → QualityGate → Produce → RejectionGate)
  *
  * 设计原则:
  *   - 每个维度 4 个阶段: 扫描 → 验证 → 异常检测 → 提交

package/lib/external/mcp/handlers/bootstrap-internal.js

@@ -6,7 +6,7 @@
  *
  * 调用方:
  *   - CLI: `asd bootstrap --knowledge`
- *   - ChatAgent: `bootstrapKnowledgeTool` (infrastructure.js)
+ *   - AgentRuntime: `bootstrapKnowledgeTool` (infrastructure.js)
  *   - Dashboard HTTP: POST /api/bootstrap/knowledge
  *
  * 外部 Agent 路径（Cursor/Copilot 等 IDE Agent）请参见:
@@ -280,7 +280,7 @@ export async function bootstrapKnowledge(ctx, args) {
       expectedOutput: `候选知识（微观代码维度：code-pattern/best-practice/event-and-data-flow + 语言条件扫描）+ Project Skills（宏观叙事维度：code-standard/architecture/project-profile/agent-guidelines + 语言条件扫描）— 共 ${dimensions.length} 个维度`,
     },
 
-    // AST 代码结构分析上下文（供 ChatAgent 使用）
+    // AST 代码结构分析上下文（供 Agent 使用）
     astContext: astContext || null,
     astSummary: astProjectSummary
       ? {

package/lib/external/mcp/handlers/dimension-complete-external.js

@@ -291,7 +291,7 @@ export async function dimensionComplete(ctx, args) {
   if (isComplete) {
     // R4: 自动触发 Cursor Delivery
     try {
-      const { getServiceContainer } = await import('../../../../injection/ServiceContainer.js');
+      const { getServiceContainer } = await import('../../../injection/ServiceContainer.js');
       const container = getServiceContainer();
       if (container.services.cursorDeliveryPipeline) {
         const pipeline = container.get('cursorDeliveryPipeline');
@@ -311,9 +311,9 @@ export async function dimensionComplete(ctx, args) {
     // R5: 自动触发 Wiki 生成 (fire-and-forget)
     setImmediate(async () => {
       try {
-        const { getServiceContainer: getWikiContainer } = await import('../../../../injection/ServiceContainer.js');
+        const { getServiceContainer: getWikiContainer } = await import('../../../injection/ServiceContainer.js');
         const wikiContainer = getWikiContainer();
-        const { WikiGenerator } = await import('../../../../service/wiki/WikiGenerator.js');
+        const { WikiGenerator } = await import('../../../service/wiki/WikiGenerator.js');
         const moduleService = wikiContainer.get?.('moduleService');
         const knowledgeService = wikiContainer.get?.('knowledgeService');
         if (moduleService && knowledgeService) {
@@ -334,11 +334,11 @@ export async function dimensionComplete(ctx, args) {
     // R6: 全量 Semantic Memory 固化 (fire-and-forget)
     setImmediate(async () => {
       try {
-        const { EpisodicConsolidator } = await import('../../../service/chat/EpisodicConsolidator.js');
+        const { EpisodicConsolidator } = await import('../../../service/agent/domain/EpisodicConsolidator.js');
         const db = ctx.container.get?.('database') ?? ctx.container.get?.('db');
         if (db && session.sessionStore) {
-          const { ProjectSemanticMemory } = await import('../../../service/chat/ProjectSemanticMemory.js');
-          const semanticMemory = new ProjectSemanticMemory(db, { logger });
+          const { PersistentMemory } = await import('../../../service/agent/memory/PersistentMemory.js');
+          const semanticMemory = new PersistentMemory(db, { logger });
           const consolidator = new EpisodicConsolidator(semanticMemory, { logger });
           const result = await consolidator.consolidate(session.sessionStore, {
             bootstrapSession: session.id,

package/lib/http/HttpServer.js

@@ -36,7 +36,7 @@ import recipesRouter from './routes/recipes.js';
 import searchRouter from './routes/search.js';
 import skillsRouter from './routes/skills.js';
 import snippetRouter from './routes/snippets.js';
-import spmRouter from './routes/spm.js';
+import spmRouter from '../platform/ios/routes/spm.js';
 import taskRouter from './routes/task.js';
 import remoteRouter from './routes/remote.js';
 import violationsRouter from './routes/violations.js';

package/lib/http/middleware/requestLogger.js

@@ -20,6 +20,7 @@ const SILENT_PATHS = [
   '/api/health',
   '/api/realtime/events',
   '/api/sse',
+  '/api/v1/remote/wait',
   '/socket.io',
 ];
 

package/lib/http/routes/ai.js

@@ -9,6 +9,18 @@ import express from 'express';
 import { createProvider } from '../../external/ai/AiFactory.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
+import { AgentMessage, Channel } from '../../service/agent/AgentMessage.js';
+import { PRESETS } from '../../service/agent/presets.js';
+import { ContextWindow } from '../../service/agent/context/ContextWindow.js';
+import { ConversationStore } from '../../service/agent/ConversationStore.js';
+import { buildProjectBriefing, cleanFinalAnswer } from '../../service/agent/core/ChatAgentPrompts.js';
+import {
+  taskCheckAndSubmit,
+  taskDiscoverAllRelations,
+  taskFullEnrich,
+  taskQualityAudit,
+  taskGuardFullScan,
+} from '../../service/agent/domain/ChatAgentTasks.js';
 import { ValidationError } from '../../shared/errors/index.js';
 import { asyncHandler } from '../middleware/errorHandler.js';
 import { createStreamSession, getStreamSession } from '../utils/sse-sessions.js';
@@ -16,10 +28,9 @@ import { createStreamSession, getStreamSession } from '../utils/sse-sessions.js'
 const router = express.Router();
 const logger = Logger.getInstance();
 
-/** 获取 ChatAgent 实例（统一 AI 入口） */
-function getChatAgent() {
-  const container = getServiceContainer();
-  return container.get('chatAgent');
+/** 获取 DI 容器 */
+function getContainer() {
+  return getServiceContainer();
 }
 
 // ═══════════════════════════════════════════════════════
@@ -33,8 +44,8 @@ function getChatAgent() {
 router.get(
   '/lang',
   asyncHandler(async (req, res) => {
-    const chatAgent = getChatAgent();
-    res.json({ success: true, data: { lang: chatAgent.getLang() || 'zh' } });
+    const container = getContainer();
+    res.json({ success: true, data: { lang: container.getLang() || 'zh' } });
   })
 );
 
@@ -49,8 +60,8 @@ router.post(
     if (lang !== 'zh' && lang !== 'en') {
       throw new ValidationError('lang must be "zh" or "en"');
     }
-    const chatAgent = getChatAgent();
-    chatAgent.setLang(lang);
+    const container = getContainer();
+    container.setLang(lang);
     logger.info(`UI language preference updated to "${lang}"`);
     res.json({ success: true, data: { lang } });
   })
@@ -168,8 +179,13 @@ router.post(
       throw new ValidationError('code is required');
     }
 
-    const chatAgent = getChatAgent();
-    const result = await chatAgent.executeTool('summarize_code', { code, language });
+    const container = getContainer();
+    const factory = container.get('agentFactory');
+    const result = await factory.scanKnowledge({
+      label: 'code',
+      files: [{ name: 'code', content: code, language }],
+      task: 'summarize',
+    });
 
     if (result?.error) {
       throw new ValidationError(result.error);
@@ -196,8 +212,9 @@ router.post(
     }
 
     try {
-      const chatAgent = getChatAgent();
-      const result = await chatAgent.executeTool('ai_translate', { summary, usageGuide });
+      const container = getContainer();
+      const factory = container.get('agentFactory');
+      const result = await factory.translateToEnglish(summary, usageGuide);
 
       if (result?.error) {
         // AI 不可用，降级返回原文
@@ -224,26 +241,123 @@ router.post(
 /**
  * POST /api/v1/ai/chat
  * AI 对话（RAG 模式，结合项目知识库）
+ *
+ * 增强特性 (Engine Migration):
+ *   - 对话持久化 (ConversationStore)
+ *   - ContextWindow 上下文窗口管理
+ *   - Token 用量持久化
+ *   - 项目概况注入 (buildProjectBriefing)
+ *   - SSE 流式最终回答 (text:start/delta/end)
+ *   - MemoryCoordinator 记忆提取
  */
 router.post(
   '/chat',
   asyncHandler(async (req, res) => {
-    const { prompt, history = [], lang } = req.body;
+    const { prompt, history = [], lang, conversationId } = req.body;
 
     if (!prompt) {
       throw new ValidationError('prompt is required');
     }
 
-    const chatAgent = getChatAgent();
-    const result = await chatAgent.execute(prompt, { history, lang });
+    const container = getContainer();
+    const factory = container.get('agentFactory');
+
+    // ── 对话持久化: 从 ConversationStore 加载历史 ──
+    let convStore = null;
+    let effectiveHistory = history;
+    let effectiveConvId = conversationId || null;
+    try {
+      const projectRoot = container.get('projectRoot') || process.cwd();
+      convStore = new ConversationStore(projectRoot);
+      if (effectiveConvId) {
+        effectiveHistory = convStore.load(effectiveConvId);
+        convStore.append(effectiveConvId, { role: 'user', content: prompt });
+      } else {
+        effectiveConvId = convStore.create({ category: 'user', title: prompt.slice(0, 50) });
+        convStore.append(effectiveConvId, { role: 'user', content: prompt });
+      }
+    } catch {
+      /* ConversationStore 不可用时静默降级 */
+    }
+
+    // ── 项目概况刷新 ──
+    let projectBriefing = '';
+    try {
+      projectBriefing = await buildProjectBriefing({ container });
+    } catch { /* 静默降级 */ }
+
+    // ── 创建 ContextWindow ──
+    const contextWindow = factory.createContextWindow({ isSystem: false });
+
+    // ── 创建 Runtime 并注入 onProgress ──
+    const message = AgentMessage.fromHttp(req);
+    // 加载持久化历史到 message
+    if (effectiveHistory.length > 0) {
+      message.history = effectiveHistory;
+    }
+
+    const runtime = factory.createChat({
+      lang,
+      onProgress: (event) => {
+        // SSE 流式进度 (如果前端通过 SSE 建立了连接)
+        try {
+          const sessionId = req.body.sseSessionId;
+          if (sessionId) {
+            const session = getStreamSession(sessionId);
+            if (session) session.send(event);
+          }
+        } catch { /* SSE 不可用时静默 */ }
+      },
+    });
+    const result = await runtime.execute(message);
+
+    // ── 持久化 assistant 回复 ──
+    if (convStore && effectiveConvId && result.reply) {
+      try {
+        convStore.append(effectiveConvId, { role: 'assistant', content: result.reply });
+      } catch { /* 静默降级 */ }
+    }
+
+    // ── MemoryCoordinator: 提取记忆 ──
+    try {
+      const memoryCoordinator = container.get('memoryCoordinator');
+      if (memoryCoordinator) {
+        memoryCoordinator.extractFromConversation?.(prompt, result.reply, 'user');
+      }
+    } catch { /* 静默降级 */ }
+
+    // ── Token 用量持久化 ──
+    try {
+      const tokenStore = container.get('tokenUsageStore');
+      if (tokenStore && result.tokenUsage) {
+        const aiProvider = container.singletons?.aiProvider;
+        tokenStore.record({
+          source: 'user',
+          dimension: null,
+          provider: aiProvider?.name || null,
+          model: aiProvider?.model || null,
+          inputTokens: result.tokenUsage.input || 0,
+          outputTokens: result.tokenUsage.output || 0,
+          durationMs: result.durationMs || 0,
+          toolCalls: result.toolCalls?.length || 0,
+          sessionId: effectiveConvId,
+        });
+        // 通知前端 token 用量变化
+        try {
+          const realtime = container.get('realtimeService');
+          realtime?.broadcastTokenUsageUpdated?.();
+        } catch { /* optional */ }
+      }
+    } catch { /* token logging should never break execution */ }
 
     res.json({
       success: true,
       data: {
         reply: result.reply,
-        hasContext: result.hasContext,
         toolCalls: result.toolCalls,
-        reasoningQuality: result.reasoningQuality || null,
+        iterations: result.iterations || null,
+        conversationId: effectiveConvId,
+        tokenUsage: result.tokenUsage || null,
       },
     });
   })
@@ -263,8 +377,9 @@ router.post(
       throw new ValidationError('tool name is required');
     }
 
-    const chatAgent = getChatAgent();
-    const result = await chatAgent.executeTool(tool, params);
+    const container = getContainer();
+    const factory = container.get('agentFactory');
+    const result = await factory.invokeAgent(tool, params);
 
     res.json({ success: true, data: result });
   })
@@ -274,7 +389,19 @@ router.post(
  * POST /api/v1/ai/agent/task
  * 执行预定义任务流（查重提交 / 批量关系发现 / 批量补全）
  * Body: { task: string, params: object }
+ *
+ * 支持两种任务类型:
+ *   1. ToolRegistry 注册的工具 (直接通过 toolName 调用)
+ *   2. ChatAgentTasks 的 5 个预定义 DAG 任务
  */
+const DAG_TASK_HANDLERS = {
+  check_and_submit: taskCheckAndSubmit,
+  discover_all_relations: taskDiscoverAllRelations,
+  full_enrich: taskFullEnrich,
+  quality_audit: taskQualityAudit,
+  guard_full_scan: taskGuardFullScan,
+};
+
 router.post(
   '/agent/task',
   asyncHandler(async (req, res) => {
@@ -284,8 +411,25 @@ router.post(
       throw new ValidationError('task name is required');
     }
 
-    const chatAgent = getChatAgent();
-    const result = await chatAgent.runTask(task, params);
+    const container = getContainer();
+    const factory = container.get('agentFactory');
+
+    // 优先尝试 DAG 任务
+    const dagHandler = DAG_TASK_HANDLERS[task];
+    if (dagHandler) {
+      const aiProvider = container.singletons?.aiProvider;
+      const taskContext = {
+        invokeAgent: (name, p) => factory.invokeAgent(name, p),
+        aiProvider,
+        container,
+        logger,
+      };
+      const result = await dagHandler(taskContext, params);
+      return res.json({ success: true, data: result });
+    }
+
+    // 回退到 Agent 工具执行
+    const result = await factory.invokeAgent(task, params);
 
     res.json({ success: true, data: result });
   })
@@ -298,8 +442,29 @@ router.post(
 router.get(
   '/agent/capabilities',
   asyncHandler(async (req, res) => {
-    const chatAgent = getChatAgent();
-    res.json({ success: true, data: chatAgent.getCapabilities() });
+    const container = getContainer();
+    const toolRegistry = container.get('toolRegistry');
+    const tools = toolRegistry.getToolSchemas();
+    const presets = Object.entries(PRESETS).map(([name, p]) => ({
+      name,
+      description: p.description,
+      capabilities: p.capabilities,
+      strategy: p.strategy?.type || 'single',
+    }));
+    res.json({
+      success: true,
+      data: {
+        tools,
+        presets,
+        tasks: [
+          { name: 'check_and_submit', description: '提交候选前自动查重 + 质量预评' },
+          { name: 'discover_all_relations', description: '批量发现 Recipe 之间的知识图谱关系' },
+          { name: 'full_enrich', description: '批量 AI 语义补全候选字段' },
+          { name: 'quality_audit', description: '批量质量审计全部 Recipe，标记低分项' },
+          { name: 'guard_full_scan', description: '用全部 Guard 规则扫描指定代码，生成完整报告' },
+        ],
+      },
+    });
   })
 );
 
@@ -511,7 +676,7 @@ router.post(
 
 /**
  * POST /api/v1/ai/chat/stream
- * 启动 AI 对话流 — 创建 session，后台执行 ChatAgent，立即返回 sessionId
+ * 启动 AI 对话流 — 创建 session，后台执行 AgentRuntime，立即返回 sessionId
  *
  * 客户端拿到 sessionId 后通过 GET /chat/events/:sessionId (EventSource) 消费事件
  *
@@ -537,27 +702,67 @@ router.post(
       throw new ValidationError('prompt is required');
     }
 
-    const chatAgent = getChatAgent();
+    const container = getContainer();
+    const factory = container.get('agentFactory');
     const session = createStreamSession('chat');
 
     logger.debug('SSE session created', { sessionId: session.sessionId });
 
-    // 立即返回 sessionId（不等待 ChatAgent 执行）
+    // 立即返回 sessionId（不等待 Agent 执行）
     res.json({ success: true, sessionId: session.sessionId });
 
-    // 后台执行 ChatAgent — 事件通过 session.send() 缓冲
-    chatAgent
-      .execute(prompt, {
-        history,
-        lang,
-        onProgress: (event) => session.send(event),
-      })
+    // AgentMessage 构建
+    const message = new AgentMessage({
+      content: prompt,
+      channel: Channel.HTTP,
+      session: { id: session.sessionId, history },
+      sender: { id: req.ip || 'http-user', type: 'user' },
+      metadata: { lang, stream: true },
+    });
+
+    // 创建 Runtime — 挂载 onProgress 回调映射到 SSE 事件
+    const runtime = factory.createChat({
+      lang,
+      onProgress: (event) => {
+        // 将 AgentRuntime 内部事件映射到前端 SSE 协议
+        switch (event.type) {
+          case 'thinking':
+            session.send({ type: 'step:start', step: event.iteration, maxSteps: event.maxIterations, phase: 'thinking' });
+            break;
+          case 'tool_call':
+            session.send({ type: 'tool:start', tool: event.tool, args: event.args });
+            break;
+          case 'tool_end':
+            session.send({
+              type: 'tool:end',
+              tool: event.tool,
+              status: event.status,
+              resultSize: event.resultSize,
+              duration: event.duration,
+              error: event.error,
+            });
+            break;
+          default:
+            session.send(event);
+        }
+      },
+    });
+
+    // 后台执行 AgentRuntime
+    runtime
+      .execute(message)
       .then((result) => {
-        // text:start/delta/end 已由 ChatAgent.execute() 内部通过 onProgress 发送
+        // 发送最终文本
+        if (result.reply) {
+          const textId = `text_${Date.now()}`;
+          session.send({ type: 'text:start', id: textId, role: 'assistant' });
+          session.send({ type: 'text:delta', id: textId, delta: result.reply });
+          session.send({ type: 'text:end', id: textId });
+        }
         session.end({
           text: result.reply,
           toolCalls: result.toolCalls || [],
-          hasContext: result.hasContext || false,
+          iterations: result.iterations || 0,
         });
         logger.debug('SSE session completed', {
           sessionId: session.sessionId,

package/lib/http/routes/candidates.js

@@ -75,10 +75,9 @@ router.post(
         // 获取用户语言偏好
         let lang = 'en';
         try {
-          const chatAgent = container.get('chatAgent');
-          lang = chatAgent?.getLang?.() || 'en';
+          lang = container.getLang?.() || 'en';
         } catch {
-          /* chatAgent not available */
+          /* lang not available */
         }
         enriched = await aiProvider.enrichCandidates(candidates, { lang });
       } catch (err) {

package/lib/http/routes/extract.js

@@ -17,7 +17,7 @@ const logger = Logger.getInstance();
 /**
  * POST /api/v1/extract/path
  * 从文件路径提取代码片段
- * 管线: RecipeParser(MD解析) → AI 提取(ChatAgent) → 原始兜底
+ * 管线: RecipeParser(MD解析) → AI 提取(AgentRuntime) → 原始兜底
  */
 router.post(
   '/path',
@@ -55,14 +55,15 @@ router.post(
       !items[0].frontmatter?.title;
 
     if (isRawFallback) {
-      // 3. 尝试 ChatAgent AI 提取
+      // 3. 尝试 AI 提取
       try {
-        const chatAgent = container.get('chatAgent');
+        const agentFactory = container.get('agentFactory');
         const file = items[0];
         const fileName = basename(relativePath); // 保留扩展名: BDMineViewController.m
-        const aiResult = await chatAgent.executeTool('extract_recipes', {
-          targetName: fileName,
+        const aiResult = await agentFactory.scanKnowledge({
+          label: fileName,
           files: [{ name: fileName, content: file.code || '' }],
+          task: 'extract',
           comprehensive: true,
         });
 
@@ -102,7 +103,7 @@ router.post(
 /**
  * POST /api/v1/extract/text
  * 从文本内容提取代码片段（剪贴板等）
- * 管线: RecipeParser(MD解析) → AI 提取(ChatAgent) → 基础兜底
+ * 管线: RecipeParser(MD解析) → AI 提取(AgentRuntime) → 基础兜底
  */
 router.post(
   '/text',
@@ -138,18 +139,19 @@ router.post(
       });
     }
 
-    // 2. Recipe MD 解析失败 → 尝试 ChatAgent AI 提取
+    // 2. Recipe MD 解析失败 → 尝试 AI 提取
     try {
-      const chatAgent = container.get('chatAgent');
-      if (chatAgent) {
+      const agentFactory = container.get('agentFactory');
+      if (agentFactory) {
         const lang =
           language ||
           (relativePath ? LanguageService.inferLang(relativePath) || 'unknown' : 'unknown');
         const ext = LanguageService.extForLang(lang) || '.txt';
         const fileName = relativePath ? basename(relativePath) : `clipboard${ext}`;
-        const aiResult = await chatAgent.executeTool('extract_recipes', {
-          targetName: fileName,
+        const aiResult = await agentFactory.scanKnowledge({
+          label: fileName,
           files: [{ name: fileName, content: text }],
+          task: 'extract',
           comprehensive: true,
         });
 

package/lib/http/routes/modules.js

@@ -531,11 +531,11 @@ router.post(
     const { maxFiles, skipGuard, contentMaxLines } = req.body || {};
 
     const container = getServiceContainer();
-    const chatAgent = container.get('chatAgent');
+    const agentFactory = container.get('agentFactory');
 
     logger.info('Bootstrap cold start initiated (ModuleService path)');
 
-    const bootstrapResult = await chatAgent.executeTool('bootstrap_knowledge', {
+    const bootstrapResult = await agentFactory.bootstrapKnowledge({
       maxFiles: maxFiles || 500,
       skipGuard: skipGuard || false,
       contentMaxLines: contentMaxLines || 120,

package/lib/http/routes/recipes.js

@@ -70,15 +70,15 @@ router.post(
       });
     }
 
-    // 检查 ChatAgent 是否可用
+    // 检查 ToolRegistry 是否可用
     const container = getServiceContainer();
-    let chatAgent;
+    let agentFactory;
     try {
-      chatAgent = container.get('chatAgent');
+      agentFactory = container.get('agentFactory');
     } catch {
       return res.json({
         success: true,
-        data: { status: 'error', error: 'ChatAgent 不可用，请检查 AI Provider 配置' },
+        data: { status: 'error', error: 'AgentFactory 不可用，请检查 AI Provider 配置' },
       });
     }
 
@@ -111,7 +111,11 @@ router.post(
     // 异步执行，不 await
     (async () => {
       try {
-        const result = await chatAgent.runTask('discover_all_relations', { batchSize });
+        const result = await agentFactory.scanKnowledge({
+          label: 'knowledge-graph',
+          files: [],
+          task: 'relations',
+        });
         discoverTask.status = 'done';
         discoverTask.finishedAt = new Date().toISOString();
         discoverTask.discovered = result.discovered || 0;