autosnippet 3.3.6 → 3.3.8

package/dist/lib/external/mcp/handlers/bootstrap/pipeline/mock-pipeline.js

@@ -0,0 +1,432 @@
+/**
+ * mock-pipeline.ts — Mock AI Bootstrap 轻量管线
+ *
+ * 当 AI Provider 为 mock 时，利用 Phase 1-4 已收集的真实数据
+ * (AST、依赖图、文件列表、Panorama) 为每个维度生成模板化候选知识。
+ *
+ * 不调用 AI，但走完完整的 submit → dimension_complete 流程，
+ * 使 Dashboard 能正常展示知识库、健康雷达等 UI。
+ *
+ * @module pipeline/mock-pipeline
+ */
+import path from 'node:path';
+import Logger from '#infra/logging/Logger.js';
+import { BootstrapEventEmitter } from '#service/bootstrap/BootstrapEventEmitter.js';
+const logger = Logger.getInstance();
+// ── 模板生成器 ────────────────────────────────────────────
+/** 从 AST 指标提取代码统计 */
+function extractAstStats(ast) {
+    if (!ast) {
+        return { classes: 0, protocols: 0, functions: 0 };
+    }
+    const pm = (ast.projectMetrics ?? ast);
+    return {
+        classes: pm.totalClasses ?? 0,
+        protocols: pm.totalProtocols ?? 0,
+        functions: pm.totalFunctions ?? 0,
+    };
+}
+/** 从文件列表中按 target 分组并提取代表性文件 */
+function getRepresentativeFiles(files, targetFileMap) {
+    const result = new Map();
+    if (targetFileMap) {
+        for (const [target, paths] of Object.entries(targetFileMap)) {
+            result.set(target, paths.slice(0, 5));
+        }
+    }
+    else if (files) {
+        const grouped = new Map();
+        for (const f of files) {
+            const target = f.targetName || 'default';
+            const list = grouped.get(target) || [];
+            list.push(f.relativePath || f.name);
+            grouped.set(target, list);
+        }
+        for (const [target, paths] of grouped) {
+            result.set(target, paths.slice(0, 5));
+        }
+    }
+    return result;
+}
+/** 从文件内容中提取 import 语句（作为 headers）*/
+function extractImports(content, lang) {
+    const imports = [];
+    const lines = content.split('\n').slice(0, 30);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (lang === 'swift' && trimmed.startsWith('import ')) {
+            imports.push(trimmed);
+        }
+        else if ((lang === 'typescript' || lang === 'javascript') && trimmed.startsWith('import ')) {
+            imports.push(trimmed);
+        }
+    }
+    return [...new Set(imports)].slice(0, 5);
+}
+/** 从文件内容中提取类/结构体/协议名 */
+function extractTypes(content) {
+    const types = [];
+    for (const m of content.matchAll(/(?:class|struct|protocol|enum|interface|type)\s+(\w+)/g)) {
+        types.push(m[1]);
+    }
+    return [...new Set(types)].slice(0, 10);
+}
+/** 生成 kebab-case trigger */
+function toKebab(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '')
+        .slice(0, 40);
+}
+// ── 维度级候选生成 ────────────────────────────────────────
+/** 为单个维度生成 Mock 候选 */
+function generateDimensionCandidates(dimId, dimLabel, files, lang, projectName, astStats, targetFiles) {
+    const candidates = [];
+    // 从文件中收集有代表性的类型和源文件
+    const allTypes = [];
+    const allSources = [];
+    const allImports = [];
+    const dimFiles = files?.filter((f) => {
+        const p = f.relativePath?.toLowerCase() || f.name.toLowerCase();
+        // 根据维度 ID 做简单相关性匹配
+        switch (dimId) {
+            case 'architecture':
+                return (p.includes('coordinator') ||
+                    p.includes('delegate') ||
+                    p.includes('service') ||
+                    p.includes('manager'));
+            case 'code-pattern':
+                return p.includes('extension') || p.includes('helper') || p.includes('util');
+            case 'naming-style':
+                return true; // 全局适用
+            case 'error-handling':
+                return p.includes('error') || p.includes('result') || p.includes('handler');
+            case 'networking':
+                return (p.includes('network') ||
+                    p.includes('api') ||
+                    p.includes('request') ||
+                    p.includes('http'));
+            case 'data-model':
+                return p.includes('model') || p.includes('entity') || p.includes('dto');
+            case 'testing-quality':
+                return p.includes('test') || p.includes('spec') || p.includes('mock');
+            case 'ui-patterns':
+                return (p.includes('view') ||
+                    p.includes('controller') ||
+                    p.includes('cell') ||
+                    p.includes('component'));
+            case 'concurrency':
+                return (p.includes('actor') ||
+                    p.includes('async') ||
+                    p.includes('queue') ||
+                    p.includes('dispatch'));
+            case 'storage':
+                return (p.includes('store') ||
+                    p.includes('cache') ||
+                    p.includes('database') ||
+                    p.includes('persist'));
+            default:
+                return true;
+        }
+    }) || [];
+    // 提取文件中的类型和导入
+    for (const f of dimFiles.slice(0, 10)) {
+        allTypes.push(...extractTypes(f.content || ''));
+        allSources.push(f.relativePath || f.name);
+        allImports.push(...extractImports(f.content || '', lang));
+    }
+    // 如果没找到相关文件，用全部文件兜底
+    if (allTypes.length === 0 && files) {
+        for (const f of files.slice(0, 5)) {
+            allTypes.push(...extractTypes(f.content || ''));
+            allSources.push(f.relativePath || f.name);
+        }
+    }
+    const uniqueTypes = [...new Set(allTypes)].slice(0, 8);
+    const uniqueSources = [...new Set(allSources)].slice(0, 5);
+    const uniqueImports = [...new Set(allImports)].slice(0, 5);
+    // 为每个维度生成 3 个候选
+    const templates = getDimensionTemplates(dimId, dimLabel, uniqueTypes, uniqueSources, lang, projectName, astStats);
+    for (const tpl of templates.slice(0, 3)) {
+        candidates.push({
+            ...tpl,
+            headers: uniqueImports,
+            sourceRefs: uniqueSources.slice(0, 3),
+            reasoning: {
+                whyStandard: `基于 ${projectName} 项目 ${dimFiles.length} 个相关文件的代码分析（Mock 模式自动生成）`,
+                sources: uniqueSources.slice(0, 3),
+                confidence: 0.7,
+            },
+            tags: ['mock-generated', dimId, lang],
+        });
+    }
+    return candidates;
+}
+/** 根据维度 ID 返回候选模板 */
+function getDimensionTemplates(dimId, dimLabel, types, sources, lang, projectName, ast) {
+    const typeList = types.length > 0 ? types.slice(0, 3).join('、') : '核心模块';
+    const typeFirst = types[0] || 'AppModule';
+    const srcFirst = sources[0] || 'Sources/Main.swift';
+    const base = {
+        language: lang,
+        knowledgeType: dimId,
+    };
+    switch (dimId) {
+        case 'architecture':
+            return [
+                {
+                    ...base,
+                    title: `${projectName} 分层架构模式`,
+                    description: `项目采用分层架构，包含 ${ast.classes} 个类、${ast.protocols} 个协议`,
+                    trigger: `@${toKebab(projectName)}-layered-arch`,
+                    kind: 'pattern',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### ${projectName} 分层架构\n\n项目基于分层架构设计，核心类型包括 ${typeList}。\n\n**层次结构**:\n- 表现层: View/Controller\n- 业务层: Service/Manager\n- 数据层: Repository/Store\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ 此条目由 Mock AI 基于代码结构自动生成`,
+                        rationale: `分层架构是 ${projectName} 的核心设计决策，确保模块间关注点分离`,
+                    },
+                    coreCode: `// ${lang === 'swift' ? 'protocol' : 'interface'} ${typeFirst}Service { ... }`,
+                    doClause: `Follow the layered architecture with ${typeFirst} as the core service boundary`,
+                    dontClause: 'Do not bypass service layer to access data layer directly',
+                    whenClause: 'When adding new features or modules to the project',
+                    usageGuide: `### 使用指南\n\n遵循 ${projectName} 的分层架构进行模块设计。`,
+                },
+                {
+                    ...base,
+                    title: `${typeFirst} 依赖注入约定`,
+                    description: `${typeFirst} 等核心类型通过依赖注入管理生命周期`,
+                    trigger: `@${toKebab(typeFirst)}-di-pattern`,
+                    kind: 'pattern',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### 依赖注入约定\n\n${projectName} 使用依赖注入管理 ${typeList} 等组件的生命周期。\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '依赖注入提高可测试性和模块解耦',
+                    },
+                    coreCode: `${lang === 'swift' ? `class ${typeFirst} {\n  init(service: Service) { }\n}` : `class ${typeFirst} {\n  constructor(private service: Service) {}\n}`}`,
+                    doClause: `Use constructor injection for ${typeFirst} dependencies`,
+                    dontClause: 'Do not use service locator or global singletons',
+                    whenClause: `When creating or modifying ${typeFirst} and its dependencies`,
+                    usageGuide: `### 使用指南\n\n通过构造器注入依赖项。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 模块通信约定`,
+                    description: `模块间通过协议/接口进行通信，避免直接耦合`,
+                    trigger: `@${toKebab(projectName)}-module-comm`,
+                    kind: 'rule',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### 模块通信\n\n${projectName} 的模块通信遵循接口隔离原则，${ast.protocols} 个协议定义了清晰的边界。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '接口隔离确保模块可独立演进和测试',
+                    },
+                    coreCode: `${lang === 'swift' ? `protocol ${typeFirst}Protocol {\n  func execute() async\n}` : `interface I${typeFirst} {\n  execute(): Promise<void>\n}`}`,
+                    doClause: 'Define protocols/interfaces for all cross-module communication',
+                    dontClause: 'Do not import concrete implementations across module boundaries',
+                    whenClause: 'When modules need to communicate or share data',
+                    usageGuide: `### 使用指南\n\n定义协议作为模块间通信契约。`,
+                },
+            ];
+        case 'code-pattern':
+            return [
+                {
+                    ...base,
+                    title: `${typeFirst} 扩展方法约定`,
+                    description: `使用扩展方法为 ${typeFirst} 添加功能，保持核心类型精简`,
+                    trigger: `@${toKebab(typeFirst)}-extension-pattern`,
+                    kind: 'pattern',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 扩展方法约定\n\n${projectName} 广泛使用扩展方法组织代码，${typeList} 等类型均采用此模式。\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '扩展方法使核心类型保持精简，增强可读性',
+                    },
+                    coreCode: `${lang === 'swift' ? `extension ${typeFirst} {\n  func helper() { }\n}` : `// ${typeFirst}.extensions.ts`}`,
+                    doClause: `Group related functionality in ${lang === 'swift' ? 'extensions' : 'utility modules'}`,
+                    dontClause: 'Do not bloat core types with unrelated methods',
+                    whenClause: `When adding utility or convenience methods to ${typeFirst}`,
+                    usageGuide: `### 使用指南\n\n按功能分组创建扩展文件。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 类型安全惯例`,
+                    description: `项目统一使用强类型和类型守卫确保安全`,
+                    trigger: `@${toKebab(projectName)}-type-safety`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 类型安全\n\n${projectName} 强制类型安全，包含 ${ast.classes} 个类和 ${ast.protocols} 个协议定义。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '类型安全减少运行时错误',
+                    },
+                    coreCode: `${lang === 'swift' ? 'guard let value = optional else { return }' : 'if (value === undefined) { return; }'}`,
+                    doClause: 'Use type guards and optional binding for safe access',
+                    dontClause: 'Do not use force unwrapping or type casting without checks',
+                    whenClause: 'When handling optional values or type conversions',
+                    usageGuide: `### 使用指南\n\n始终使用安全的类型转换。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 命名约定`,
+                    description: `文件和类型命名遵循一致的约定`,
+                    trigger: `@${toKebab(projectName)}-naming-conventions`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 命名约定\n\n${projectName} 使用一致的命名风格。类型: PascalCase, 方法/属性: camelCase。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '统一命名提高代码可读性',
+                    },
+                    coreCode: `// ${typeFirst}.swift / ${typeFirst}.ts`,
+                    doClause: 'Follow PascalCase for types and camelCase for members',
+                    dontClause: 'Do not use abbreviations or inconsistent casing',
+                    whenClause: 'When naming new types, methods, or properties',
+                    usageGuide: `### 使用指南\n\n遵循项目既有命名风格。`,
+                },
+            ];
+        default:
+            return [
+                {
+                    ...base,
+                    title: `${projectName} ${dimLabel}实践`,
+                    description: `${dimLabel}维度的最佳实践，基于 ${typeList} 等代码分析`,
+                    trigger: `@${toKebab(projectName)}-${toKebab(dimLabel)}-practice`,
+                    kind: 'pattern',
+                    category: 'Tool',
+                    topicHint: dimId.includes('network')
+                        ? 'networking'
+                        : dimId.includes('ui')
+                            ? 'ui'
+                            : 'conventions',
+                    content: {
+                        markdown: `### ${dimLabel}\n\n${projectName} 在 ${dimLabel} 方面的实践，涉及 ${typeList} 等核心类型。\n\n**文件统计**: ${ast.classes} 类, ${ast.protocols} 协议, ${ast.functions} 函数\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `${dimLabel}是项目质量的重要维度`,
+                    },
+                    coreCode: `// See ${srcFirst}`,
+                    doClause: `Follow established ${dimLabel} patterns in the project`,
+                    dontClause: `Do not deviate from the project's ${dimLabel} conventions`,
+                    whenClause: `When working on ${dimLabel}-related code`,
+                    usageGuide: `### 使用指南\n\n遵循项目的 ${dimLabel} 约定。`,
+                },
+                {
+                    ...base,
+                    title: `${typeFirst} ${dimLabel}约定`,
+                    description: `${typeFirst} 相关的 ${dimLabel} 约定`,
+                    trigger: `@${toKebab(typeFirst)}-${toKebab(dimLabel)}`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: dimId.includes('network') ? 'networking' : 'conventions',
+                    content: {
+                        markdown: `### ${typeFirst} ${dimLabel}\n\n${typeFirst} 遵循的 ${dimLabel} 约定。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `基于 ${typeFirst} 的实际代码模式`,
+                    },
+                    coreCode: `// ${typeFirst} — ${dimLabel}`,
+                    doClause: `Apply ${dimLabel} patterns consistent with ${typeFirst}`,
+                    dontClause: `Do not introduce inconsistent ${dimLabel} approaches`,
+                    whenClause: `When modifying ${typeFirst} or related components`,
+                    usageGuide: `### 使用指南\n\n参考 ${typeFirst} 的既有实现。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} ${dimLabel}检查清单`,
+                    description: `${dimLabel}方面的代码审查清单`,
+                    trigger: `@${toKebab(projectName)}-${toKebab(dimLabel)}-checklist`,
+                    kind: 'fact',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### ${dimLabel} 检查清单\n\n1. 遵循项目既有模式\n2. 确保类型安全\n3. 添加适当的错误处理\n4. 保持代码一致性\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `${dimLabel}检查清单帮助保持代码质量`,
+                    },
+                    coreCode: `// ${dimLabel} checklist applied`,
+                    doClause: `Review code against the ${dimLabel} checklist before committing`,
+                    dontClause: `Do not skip ${dimLabel} review for shortcuts`,
+                    whenClause: `During code review for ${dimLabel}-related changes`,
+                    usageGuide: `### 使用指南\n\n在代码审查时参考此清单。`,
+                },
+            ];
+    }
+}
+// ── Mock Pipeline 入口 ────────────────────────────────────────
+/**
+ * fillDimensionsMock — Mock AI 轻量管线
+ *
+ * 利用 Phase 1-4 的真实数据（AST、文件列表、Panorama）自动生成候选知识，
+ * 不调用任何 AI API，但走完 submit → dimension_complete 的完整流程。
+ */
+export async function fillDimensionsMock(view, dimensions) {
+    const { snapshot, projectRoot } = view;
+    const ctx = view.ctx;
+    const emitter = new BootstrapEventEmitter(ctx.container);
+    const projectName = path.basename(projectRoot);
+    const primaryLang = snapshot.language.primaryLang ?? 'unknown';
+    const astStats = extractAstStats(snapshot.ast);
+    const allFiles = snapshot.allFiles;
+    const targetFileMap = view.targetFileMap;
+    const repFiles = getRepresentativeFiles(allFiles, targetFileMap);
+    logger.info(`[MockPipeline] ═══ Starting Mock bootstrap — ${dimensions.length} dimensions, ` +
+        `${allFiles?.length || 0} files, lang=${primaryLang}`);
+    emitter.emitProgress('bootstrap:mock-mode', {
+        message: '🧪 Mock AI 模式 — 基于代码结构自动生成知识候选（非 AI 深度分析）',
+        mockMode: true,
+    });
+    const knowledgeService = ctx.container.get('knowledgeService');
+    let totalCreated = 0;
+    for (const dim of dimensions) {
+        const dimStartTime = Date.now();
+        const dimLabel = dim.label ?? dim.id;
+        emitter.emitProgress('bootstrap:dimension-start', {
+            dimensionId: dim.id,
+            dimensionLabel: dimLabel,
+            mockMode: true,
+        });
+        logger.info(`[MockPipeline] ── Dimension "${dim.id}" (${dimLabel}) ──`);
+        // 生成候选
+        const candidates = generateDimensionCandidates(dim.id, dimLabel, allFiles, primaryLang, projectName, astStats, repFiles);
+        const createdIds = [];
+        for (const candidate of candidates) {
+            try {
+                const entry = await knowledgeService.create({
+                    ...candidate,
+                    source: 'mock-bootstrap',
+                }, { userId: 'mock-ai' });
+                createdIds.push(entry.id);
+                totalCreated++;
+                // 尝试自动评分（非关键路径）
+                try {
+                    await knowledgeService.updateQuality?.(entry.id, { userId: 'mock-ai' });
+                }
+                catch {
+                    /* best effort */
+                }
+                logger.info(`[MockPipeline] ✅ Created: "${candidate.title}" → ${entry.id}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.warn(`[MockPipeline] ⚠️ Failed to create "${candidate.title}": ${msg}`);
+            }
+        }
+        const durationMs = Date.now() - dimStartTime;
+        emitter.emitDimensionComplete(dim.id, {
+            type: 'candidate',
+            extracted: candidates.length,
+            created: createdIds.length,
+            status: 'mock-pipeline-complete',
+            degraded: false,
+            durationMs,
+            toolCallCount: 0,
+            source: 'mock-pipeline',
+        });
+        logger.info(`[MockPipeline] ✅ "${dim.id}": ${createdIds.length}/${candidates.length} candidates, ${durationMs}ms`);
+    }
+    emitter.emitProgress('bootstrap:mock-complete', {
+        message: `🧪 Mock Bootstrap 完成: ${totalCreated} 个候选知识已生成`,
+        totalCreated,
+        mockMode: true,
+    });
+    logger.info(`[MockPipeline] ═══ Mock bootstrap complete — ${totalCreated} candidates from ${dimensions.length} dimensions`);
+}

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

@@ -20,6 +20,7 @@ import { ExplorationTracker } from '#agent/context/ExplorationTracker.js';
 import { EpisodicConsolidator } from '#agent/domain/EpisodicConsolidator.js';
 import { ANALYST_BUDGET } from '#agent/domain/insight-analyst.js';
 import { MemoryCoordinator } from '#agent/memory/MemoryCoordinator.js';
+import { MemoryEmbeddingStore } from '#agent/memory/MemoryEmbeddingStore.js';
 import { PersistentMemory } from '#agent/memory/PersistentMemory.js';
 import { SessionStore } from '#agent/memory/SessionStore.js';
 import { PRESETS } from '#agent/presets.js';
@@ -32,6 +33,7 @@ import { clearCheckpoints, loadCheckpoints, saveDimensionCheckpoint } from './ch
 import { buildTierReflection, DIMENSION_CONFIGS_V3, getFullDimensionConfig, } from './dimension-configs.js';
 import { DimensionContext, parseDimensionDigest } from './dimension-context.js';
 import { IncrementalBootstrap } from './IncrementalBootstrap.js';
+import { fillDimensionsMock } from './mock-pipeline.js';
 import { TierScheduler } from './tier-scheduler.js';
 const logger = Logger.getInstance();
 // ──────────────────────────────────────────────────────────────────
@@ -116,21 +118,22 @@ export async function fillDimensionsV3(view, dimensions) {
     logger.info(`[Insight-v3] ═══ fillDimensionsV3 entered — ${isIncremental ? 'INCREMENTAL' : 'FULL'} pipeline`);
     let allFiles = snapshot.allFiles;
     // ═══════════════════════════════════════════════════════════
-    // Step 0: AI 可用性检查 (v7.2: 使用 AgentFactory)
+    // Step 0: AI 可用性检查 (v7.2: 使用 AgentFactory + AiProviderManager)
     // ═══════════════════════════════════════════════════════════
     let agentFactory = null;
+    let isMockMode = false;
     try {
-        agentFactory = ctx.container.get('agentFactory');
-        // 检查 AI Provider 是否可用
-        const aiProvider = ctx.container.singletons?.aiProvider;
-        if (!aiProvider || aiProvider.name === 'mock') {
-            agentFactory = null;
+        // 通过 AiProviderManager 统一检查 mock 模式
+        const manager = ctx.container.singletons?._aiProviderManager;
+        isMockMode = manager?.isMock ?? false;
+        if (!isMockMode) {
+            agentFactory = ctx.container.get('agentFactory');
         }
     }
     catch {
         /* not available */
     }
-    if (!agentFactory) {
+    if (!agentFactory && !isMockMode) {
         logger.error('[Insight-v3] AI Provider not available — bootstrap requires AI');
         emitter.emitProgress('bootstrap:ai-unavailable', {
             message: 'AI Provider 不可用，Bootstrap 需要 AI 才能运行。请先配置 AI Provider（如 OpenAI、Anthropic 等）后重试。',
@@ -140,6 +143,12 @@ export async function fillDimensionsV3(view, dimensions) {
         }
         return;
     }
+    // Mock AI: 走 mock-pipeline 轻量管线
+    if (isMockMode) {
+        logger.info('[Insight-v3] Mock AI detected — routing to mock-pipeline');
+        await fillDimensionsMock(view, dimensions);
+        return;
+    }
     // ═══════════════════════════════════════════════════════════
     // Step 0.5: 构建 ProjectGraph
     // ═══════════════════════════════════════════════════════════
@@ -151,7 +160,7 @@ export async function fillDimensionsV3(view, dimensions) {
                 timeoutMs: 15_000,
             })) ?? null;
         if (projectGraph) {
-            const overview = projectGraph.getOverview();
+            const overview = await projectGraph.getOverview();
             logger.info(`[Insight-v3] ProjectGraph: ${overview.totalClasses} classes, ${overview.totalProtocols} protocols (${overview.buildTimeMs}ms)`);
         }
     }
@@ -225,7 +234,11 @@ export async function fillDimensionsV3(view, dimensions) {
             catch {
                 // EmbedProvider 不可用时 fallback 到无向量模式
             }
-            semanticMemory = new PersistentMemory(db, { logger, embeddingFn });
+            semanticMemory = new PersistentMemory(db, {
+                logger,
+                embeddingFn,
+                embeddingStore: new MemoryEmbeddingStore(projectRoot),
+            });
             const smStats = semanticMemory.getStats();
             if (smStats.total > 0) {
                 logger.info(`[Insight-v3] Loaded ${smStats.total} semantic memories from previous bootstrap ` +
@@ -240,10 +253,11 @@ export async function fillDimensionsV3(view, dimensions) {
     let codeEntityGraphInst = null;
     try {
         const { CodeEntityGraph } = await import('#service/knowledge/CodeEntityGraph.js');
-        const db = ctx.container.get('database');
-        if (db) {
-            codeEntityGraphInst = new CodeEntityGraph(db, { projectRoot, logger });
-            const topo = codeEntityGraphInst.getTopology();
+        const entityRepo = ctx.container.get('codeEntityRepository');
+        const edgeRepo = ctx.container.get('knowledgeEdgeRepository');
+        if (entityRepo && edgeRepo) {
+            codeEntityGraphInst = new CodeEntityGraph(entityRepo, edgeRepo, { projectRoot, logger });
+            const topo = await codeEntityGraphInst.getTopology();
             if (topo.totalEntities > 0) {
                 logger.info(`[Insight-v3] CodeEntityGraph: ${topo.totalEntities} entities, ${topo.totalEdges} edges`);
             }
@@ -311,6 +325,7 @@ export async function fillDimensionsV3(view, dimensions) {
     // ── 跨维度去重集合 (实例级持久化，等效旧 ChatAgent.#globalSubmittedTitles/Patterns) ──
     const globalSubmittedTitles = new Set();
     const globalSubmittedPatterns = new Set();
+    const globalSubmittedTriggers = new Set();
     // ── Rescan 模式: 预种已有 recipe 标题到去重集合，防止重复创建 ──
     const existingRecipesList = existingRecipes;
     if (existingRecipesList && existingRecipesList.length > 0) {
@@ -319,8 +334,12 @@ export async function fillDimensionsV3(view, dimensions) {
             if (r.title && r.status !== 'decaying') {
                 globalSubmittedTitles.add(r.title.toLowerCase().trim());
             }
+            // ★ trigger 全部预种（含 decaying），防止 trigger 冲突
+            if (r.trigger) {
+                globalSubmittedTriggers.add(r.trigger.toLowerCase().trim());
+            }
         }
-        logger.info(`[Insight-v3] Rescan mode: seeded ${globalSubmittedTitles.size} existing recipe titles into dedup set`);
+        logger.info(`[Insight-v3] Rescan mode: seeded ${globalSubmittedTitles.size} titles + ${globalSubmittedTriggers.size} triggers into dedup set`);
     }
     // 构建 rescanContext 供 Analyst/Producer prompt 使用（区分 healthy/decaying）
     const rescanContext = existingRecipesList
@@ -579,7 +598,7 @@ export async function fillDimensionsV3(view, dimensions) {
                     modules: Object.keys(targetFileMap || {}),
                 },
                 // ── 引擎增强参数 (PipelineStrategy → reactLoop 透传) ──
-                contextWindow: agentFactory.createContextWindow({ isSystem: true }),
+                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)
@@ -589,6 +608,7 @@ export async function fillDimensionsV3(view, dimensions) {
                 sharedState: {
                     submittedTitles: globalSubmittedTitles,
                     submittedPatterns: globalSubmittedPatterns,
+                    submittedTriggers: globalSubmittedTriggers,
                     _dimensionMeta: {
                         id: dimId,
                         outputType: dimConfig.outputType || 'candidate',
@@ -986,9 +1006,10 @@ export async function fillDimensionsV3(view, dimensions) {
     // ═══════════════════════════════════════════════════════════
     try {
         const { CodeEntityGraph } = await import('#service/knowledge/CodeEntityGraph.js');
-        const db = ctx.container.get('database');
-        if (db) {
-            const ceg = new CodeEntityGraph(db, { projectRoot, logger });
+        const entityRepo = ctx.container.get('codeEntityRepository');
+        const edgeRepo = ctx.container.get('knowledgeEdgeRepository');
+        if (entityRepo && edgeRepo) {
+            const ceg = new CodeEntityGraph(entityRepo, edgeRepo, { projectRoot, logger });
             // 收集所有维度产出的候选 (从 Producer toolCalls 中提取)
             const allCandidates = [];
             for (const dimData of Object.values(dimensionCandidates)) {
@@ -1007,7 +1028,7 @@ export async function fillDimensionsV3(view, dimensions) {
                 }
             }
             if (allCandidates.length > 0) {
-                const relResult = ceg.populateFromCandidateRelations(allCandidates);
+                const relResult = await ceg.populateFromCandidateRelations(allCandidates);
                 logger.info(`[Insight-v3] Code Entity Graph relations: ${relResult.edgesCreated} edges from ${allCandidates.length} candidates (${relResult.durationMs}ms)`);
             }
         }
@@ -1025,7 +1046,10 @@ export async function fillDimensionsV3(view, dimensions) {
     try {
         const db = ctx.container.get('database');
         if (db) {
-            const semanticMemory = new PersistentMemory(db, { logger });
+            const semanticMemory = new PersistentMemory(db, {
+                logger,
+                embeddingStore: new MemoryEmbeddingStore(projectRoot),
+            });
             const consolidator = new EpisodicConsolidator(semanticMemory, { logger });
             consolidationResult = consolidator.consolidate(sessionStore, {
                 bootstrapSession: sessionId,
@@ -1144,10 +1168,11 @@ export async function fillDimensionsV3(view, dimensions) {
         // Phase E: 附加 Code Entity Graph 拓扑到报告
         try {
             const { CodeEntityGraph } = await import('#service/knowledge/CodeEntityGraph.js');
-            const db = ctx.container.get('database');
-            if (db) {
-                const ceg = new CodeEntityGraph(db, { projectRoot, logger });
-                const topo = ceg.getTopology();
+            const entityRepo = ctx.container.get('codeEntityRepository');
+            const edgeRepo = ctx.container.get('knowledgeEdgeRepository');
+            if (entityRepo && edgeRepo) {
+                const ceg = new CodeEntityGraph(entityRepo, edgeRepo, { projectRoot, logger });
+                const topo = await ceg.getTopology();
                 report.codeEntityGraph = {
                     entities: topo.entities,
                     edges: topo.edges,

package/dist/lib/external/mcp/handlers/bootstrap/refine.js

@@ -21,6 +21,14 @@ export async function bootstrapRefine(ctx, args) {
             errorCode: 'MISSING_AI_PROVIDER',
         });
     }
+    // Mock 模式下跳过 AI 润色
+    if (aiProvider.name === 'mock') {
+        return envelope({
+            success: false,
+            message: 'AI Provider 未配置，当前为 Mock 模式。请先配置 API Key。',
+            errorCode: 'MOCK_MODE',
+        });
+    }
     // 接入 BootstrapTaskManager 双通道推送 refine:* 事件
     let onProgress = null;
     try {

package/dist/lib/external/mcp/handlers/bootstrap/shared/bootstrap-phases.d.ts

@@ -9,7 +9,7 @@
  *   Phase 1   → 文件收集（DiscovererRegistry → 多语言项目类型检测）
  *   Phase 1.5 → AST 代码结构分析（tree-sitter + SFC 预处理）
  *   Phase 1.6 → Code Entity Graph（代码实体关系图谱）
- *   Phase 1.8 → Panorama 全景汇总（RoleRefiner + CouplingAnalyzer + LayerInferrer）
+ *   Phase 2.2 → Panorama 全景汇总（RoleRefiner + CouplingAnalyzer + LayerInferrer）
  *   Phase 2   → 依赖关系 → knowledge_edges
  *   Phase 2.1 → Module 实体写入 Entity Graph
  *   Phase 3   → Guard 规则审计