autosnippet 3.0.1 → 3.0.2

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

@@ -37,15 +37,28 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { envelope } from '../envelope.js';
-import { inferLang, detectPrimaryLanguage, buildLanguageExtension } from './LanguageExtensions.js';
-import { inferTargetRole, inferFilePriority } from './TargetClassifier.js';
-import { analyzeProject, generateContextForAgent, isAvailable as astIsAvailable } from '../../../core/AstAnalyzer.js';
+import {
+  analyzeProject,
+  isAvailable as astIsAvailable,
+  generateContextForAgent,
+} from '../../../core/AstAnalyzer.js';
+import { DimensionCopy } from '../../../shared/DimensionCopyRegistry.js';
+import { LanguageService } from '../../../shared/LanguageService.js';
 import pathGuard from '../../../shared/PathGuard.js';
-
+import { envelope } from '../envelope.js';
+import {
+  clearCheckpoints,
+  clearSnapshots,
+  fillDimensionsV3,
+} from './bootstrap/pipeline/orchestrator.js';
 // ── Sub-modules ──
-import { loadBootstrapSkills, extractSkillDimensionGuides, enhanceDimensions } from './bootstrap/skills.js';
-import { fillDimensionsV3, clearCheckpoints, clearSnapshots } from './bootstrap/pipeline/orchestrator.js';
+import {
+  enhanceDimensions,
+  extractSkillDimensionGuides,
+  loadBootstrapSkills,
+} from './bootstrap/skills.js';
+import { buildLanguageExtension, detectPrimaryLanguage, inferLang } from './LanguageExtensions.js';
+import { inferFilePriority, inferTargetRole } from './TargetClassifier.js';
 
 // Re-export for external consumers
 export { loadBootstrapSkills };
@@ -95,21 +108,26 @@ export async function bootstrapKnowledge(ctx, args) {
   };
 
   // ═══════════════════════════════════════════════════════════
-  // Phase 1: 文件收集
+  // Phase 1: 文件收集（通过 DiscovererRegistry 自动选择项目类型）
   // ═══════════════════════════════════════════════════════════
-  const { SpmService } = await import('../../../service/spm/SpmService.js');
-  const spm = new SpmService(projectRoot);
-  await spm.load();
-  const allTargets = await spm.listTargets();
+  const { getDiscovererRegistry } = await import('../../../core/discovery/index.js');
+  const registry = getDiscovererRegistry();
+  const discoverer = await registry.detect(projectRoot);
+  ctx.logger.info(`[Bootstrap] Project type: ${discoverer.displayName} (${discoverer.id})`);
+
+  await discoverer.load(projectRoot);
+  const allTargets = await discoverer.listTargets();
 
   const seenPaths = new Set();
   const allFiles = []; // { name, path, relativePath, content, targetName }
   for (const t of allTargets) {
     try {
-      const fileList = await spm.getTargetFiles(t);
+      const fileList = await discoverer.getTargetFiles(t);
       for (const f of fileList) {
         const fp = typeof f === 'string' ? f : f.path;
-        if (seenPaths.has(fp)) continue;
+        if (seenPaths.has(fp)) {
+          continue;
+        }
         seenPaths.add(fp);
         try {
           const content = fs.readFileSync(fp, 'utf8');
@@ -120,14 +138,24 @@ export async function bootstrapKnowledge(ctx, args) {
             content,
             targetName: typeof t === 'string' ? t : t.name,
           });
-        } catch { /* skip unreadable */ }
-        if (allFiles.length >= maxFiles) break;
+        } catch {
+          /* skip unreadable */
+        }
+        if (allFiles.length >= maxFiles) {
+          break;
+        }
       }
-    } catch { /* skip target */ }
-    if (allFiles.length >= maxFiles) break;
+    } catch {
+      /* skip target */
+    }
+    if (allFiles.length >= maxFiles) {
+      break;
+    }
   }
 
   report.phases.fileCollection = {
+    discoverer: discoverer.id,
+    discovererName: discoverer.displayName,
     targets: allTargets.length,
     files: allFiles.length,
     truncated: allFiles.length >= maxFiles,
@@ -142,13 +170,27 @@ export async function bootstrapKnowledge(ctx, args) {
     try {
       const db = ctx.container.get('database');
       if (db) {
-        const { IncrementalBootstrap } = await import('./bootstrap/pipeline/IncrementalBootstrap.js');
+        const { IncrementalBootstrap } = await import(
+          './bootstrap/pipeline/IncrementalBootstrap.js'
+        );
         const ib = new IncrementalBootstrap(db, projectRoot, { logger: ctx.logger });
-        // 所有 9 个维度 ID
+        // 所有可能的维度 ID（动态维度在后面按语言过滤 + Enhancement Pack 追加）
         const allDimIds = [
-          'project-profile', 'objc-deep-scan', 'category-scan',
-          'code-standard', 'architecture', 'code-pattern',
-          'event-and-data-flow', 'best-practice', 'agent-guidelines',
+          'project-profile',
+          'code-standard',
+          'code-pattern',
+          'architecture',
+          'best-practice',
+          'event-and-data-flow',
+          'agent-guidelines',
+          // 语言条件维度
+          'objc-deep-scan',
+          'category-scan',
+          'module-export-scan',
+          'framework-convention-scan',
+          'python-package-scan',
+          'jvm-annotation-scan',
+          'go-module-scan',
         ];
         incrementalPlan = ib.evaluate(allFiles, allDimIds);
         report.phases.incrementalEvaluation = {
@@ -157,25 +199,29 @@ export async function bootstrapKnowledge(ctx, args) {
           affectedDimensions: incrementalPlan.affectedDimensions,
           skippedDimensions: incrementalPlan.skippedDimensions,
           reason: incrementalPlan.reason,
-          diff: incrementalPlan.diff ? {
-            added: incrementalPlan.diff.added.length,
-            modified: incrementalPlan.diff.modified.length,
-            deleted: incrementalPlan.diff.deleted.length,
-            unchanged: incrementalPlan.diff.unchanged.length,
-            changeRatio: incrementalPlan.diff.changeRatio,
-          } : null,
+          diff: incrementalPlan.diff
+            ? {
+                added: incrementalPlan.diff.added.length,
+                modified: incrementalPlan.diff.modified.length,
+                deleted: incrementalPlan.diff.deleted.length,
+                unchanged: incrementalPlan.diff.unchanged.length,
+                changeRatio: incrementalPlan.diff.changeRatio,
+              }
+            : null,
         };
         if (incrementalPlan.canIncremental) {
           ctx.logger.info(
             `[Bootstrap] 🔄 Incremental mode: ${incrementalPlan.affectedDimensions.length} affected, ` +
-            `${incrementalPlan.skippedDimensions.length} skipped — ${incrementalPlan.reason}`
+              `${incrementalPlan.skippedDimensions.length} skipped — ${incrementalPlan.reason}`
           );
         } else {
           ctx.logger.info(`[Bootstrap] Full mode: ${incrementalPlan.reason}`);
         }
       }
     } catch (incErr) {
-      ctx.logger.warn(`[Bootstrap] Incremental evaluation failed (fallback to full): ${incErr.message}`);
+      ctx.logger.warn(
+        `[Bootstrap] Incremental evaluation failed (fallback to full): ${incErr.message}`
+      );
     }
   }
 
@@ -197,24 +243,73 @@ export async function bootstrapKnowledge(ctx, args) {
   // ═══════════════════════════════════════════════════════════
   // Phase 1.5: AST 代码结构分析（Tree-sitter）
   // ═══════════════════════════════════════════════════════════
+
+  // ── Phase 1.5a: 按需安装缺失的 tree-sitter 语法包 ──────────
+  let grammarInstallResult = null;
+  try {
+    const { ensureGrammars, inferLanguagesFromStats, reloadPlugins } = await import(
+      '../../../core/ast/ensure-grammars.js'
+    );
+    const neededLangs = inferLanguagesFromStats(langStats);
+    if (neededLangs.length > 0) {
+      grammarInstallResult = await ensureGrammars(neededLangs, { logger: ctx.logger });
+      if (grammarInstallResult.installed.length > 0) {
+        ctx.logger.info(
+          `[Bootstrap] Installed grammar packages: ${grammarInstallResult.installed.join(', ')} — reloading AST plugins`
+        );
+        await reloadPlugins();
+      }
+    }
+    // 确保 AST 插件已加载（即使没有新安装语法包 — 首次启动时需要触发 loadPlugins）
+    await import('../../../core/ast/index.js');
+  } catch (e) {
+    ctx.logger.warn(`[Bootstrap] Grammar auto-install skipped: ${e.message}`);
+  }
+  report.phases.grammarEnsure = grammarInstallResult || { installed: [], skipped: [], failed: [] };
+
+  // ── Phase 1.5b: AST 分析 ──────────────────────────────────
   let astProjectSummary = null;
   let astContext = '';
   const primaryLangEarly = detectPrimaryLanguage(langStats);
   if (astIsAvailable() && primaryLangEarly) {
     try {
-      const astFiles = allFiles.map(f => ({
+      const astFiles = allFiles.map((f) => ({
         name: f.name,
         relativePath: f.relativePath,
         content: f.content,
       }));
-      astProjectSummary = analyzeProject(astFiles, primaryLangEarly);
+
+      // SFC 预处理: 支持 .vue / .svelte 等框架特有文件的 <script> 提取
+      let sfcPreprocessor = null;
+      try {
+        const { initEnhancementRegistry } = await import('../../../core/enhancement/index.js');
+        const enhReg = await initEnhancementRegistry();
+        const allPacks = enhReg.all();
+        // 找到第一个提供 preprocessFile 的增强包
+        const preprocessPack = allPacks.find(
+          (p) => typeof p.preprocessFile === 'function'
+        );
+        if (preprocessPack) {
+          sfcPreprocessor = preprocessPack.preprocessFile.bind(preprocessPack);
+        }
+      } catch {
+        /* Enhancement 未加载时跳过预处理 */
+      }
+
+      astProjectSummary = analyzeProject(astFiles, primaryLangEarly, {
+        preprocessFile: sfcPreprocessor,
+      });
       astContext = generateContextForAgent(astProjectSummary);
-      ctx.logger.info(`[Bootstrap] AST analysis: ${astProjectSummary.classes.length} classes, ${astProjectSummary.protocols.length} protocols, ${astProjectSummary.categories.length} categories, ${Object.keys(astProjectSummary.patternStats).length} patterns`);
+      ctx.logger.info(
+        `[Bootstrap] AST analysis: ${astProjectSummary.classes.length} classes, ${astProjectSummary.protocols.length} protocols, ${astProjectSummary.categories.length} categories, ${Object.keys(astProjectSummary.patternStats).length} patterns`
+      );
     } catch (e) {
       ctx.logger.warn(`[Bootstrap] AST analysis failed (graceful degradation): ${e.message}`);
     }
   } else {
-    ctx.logger.info(`[Bootstrap] AST analysis skipped: tree-sitter ${astIsAvailable() ? 'available' : 'not available'}, lang=${primaryLangEarly}`);
+    ctx.logger.info(
+      `[Bootstrap] AST analysis skipped: tree-sitter ${astIsAvailable() ? 'available' : 'not available'}, lang=${primaryLangEarly}`
+    );
   }
   report.phases.astAnalysis = {
     available: astIsAvailable(),
@@ -238,7 +333,7 @@ export async function bootstrapKnowledge(ctx, args) {
         codeEntityResult = ceg.populateFromAst(astProjectSummary);
         ctx.logger.info(
           `[Bootstrap] Code Entity Graph: ${codeEntityResult.entitiesUpserted} entities, ` +
-          `${codeEntityResult.edgesCreated} edges (${codeEntityResult.durationMs}ms)`
+            `${codeEntityResult.edgesCreated} edges (${codeEntityResult.durationMs}ms)`
         );
       }
     } catch (e) {
@@ -252,39 +347,48 @@ export async function bootstrapKnowledge(ctx, args) {
   };
 
   // ═══════════════════════════════════════════════════════════
-  // Phase 2: SPM 依赖关系 → knowledge_edges
+  // Phase 2: 依赖关系 → knowledge_edges
   // ═══════════════════════════════════════════════════════════
   let depEdgesWritten = 0;
   let depGraphData = null;
   try {
     const knowledgeGraphService = ctx.container.get('knowledgeGraphService');
-    depGraphData = await spm.getDependencyGraph();
+    depGraphData = await discoverer.getDependencyGraph();
     if (knowledgeGraphService) {
-      for (const edge of (depGraphData.edges || [])) {
+      for (const edge of depGraphData.edges || []) {
         const result = knowledgeGraphService.addEdge(
-          edge.from, 'module', edge.to, 'module', 'depends_on',
-          { weight: 1.0, source: 'spm-bootstrap' },
+          edge.from,
+          'module',
+          edge.to,
+          'module',
+          'depends_on',
+          { weight: 1.0, source: `${discoverer.id}-bootstrap` }
         );
-        if (result.success) depEdgesWritten++;
+        if (result.success) {
+          depEdgesWritten++;
+        }
       }
     }
   } catch (e) {
-    ctx.logger.warn(`[Bootstrap] SPM→Graph failed: ${e.message}`);
+    ctx.logger.warn(`[Bootstrap] DepGraph failed: ${e.message}`);
   }
-  report.phases.spmDependencyGraph = { edgesWritten: depEdgesWritten };
+  report.phases.dependencyGraph = { edgesWritten: depEdgesWritten };
 
-  // Phase 2.1: SPM module 实体节点写入 Code Entity Graph
+  // Phase 2.1: Module 实体节点写入 Code Entity Graph
   if (depGraphData?.nodes?.length > 0) {
     try {
       const { CodeEntityGraph } = await import('../../../service/knowledge/CodeEntityGraph.js');
       const db = ctx.container.get('database');
       if (db) {
         const ceg = new CodeEntityGraph(db, { projectRoot });
-        const spmResult = ceg.populateFromSpm(depGraphData);
-        ctx.logger.info(`[Bootstrap] Code Entity Graph SPM: ${spmResult.entitiesUpserted} module entities`);
+        // populateFromSpm 接受通用的 { nodes, edges } 结构，不仅限于 SPM
+        const depResult = ceg.populateFromSpm(depGraphData);
+        ctx.logger.info(
+          `[Bootstrap] Code Entity Graph modules: ${depResult.entitiesUpserted} entities`
+        );
       }
     } catch (e) {
-      ctx.logger.warn(`[Bootstrap] Code Entity Graph SPM failed: ${e.message}`);
+      ctx.logger.warn(`[Bootstrap] Code Entity Graph modules failed: ${e.message}`);
     }
   }
 
@@ -297,13 +401,13 @@ export async function bootstrapKnowledge(ctx, args) {
       const { GuardCheckEngine } = await import('../../../service/guard/GuardCheckEngine.js');
       const db = ctx.container.get('database');
       const engine = new GuardCheckEngine(db);
-      const guardFiles = allFiles.map(f => ({ path: f.path, content: f.content }));
+      const guardFiles = allFiles.map((f) => ({ path: f.path, content: f.content }));
       guardAudit = engine.auditFiles(guardFiles, { scope: 'project' });
 
       // 写入 ViolationsStore
       try {
         const violationsStore = ctx.container.get('violationsStore');
-        for (const fileResult of (guardAudit.files || [])) {
+        for (const fileResult of guardAudit.files || []) {
           if (fileResult.violations.length > 0) {
             violationsStore.appendRun({
               filePath: fileResult.filePath,
@@ -312,27 +416,31 @@ export async function bootstrapKnowledge(ctx, args) {
             });
           }
         }
-      } catch { /* ViolationsStore not available */ }
+      } catch {
+        /* ViolationsStore not available */
+      }
     } catch (e) {
       ctx.logger.warn(`[Bootstrap] Guard audit failed: ${e.message}`);
     }
   }
   report.phases.guardAudit = {
     totalViolations: guardAudit?.summary?.totalViolations || 0,
-    filesWithViolations: (guardAudit?.files || []).filter(f => f.violations.length > 0).length,
+    filesWithViolations: (guardAudit?.files || []).filter((f) => f.violations.length > 0).length,
     skipped: skipGuard,
   };
   report.totals.guardViolations = guardAudit?.summary?.totalViolations || 0;
   report.totals.graphEdges = depEdgesWritten;
 
-  const elapsed = Date.now() - t0;
+  const _elapsed = Date.now() - t0;
 
   // ═══════════════════════════════════════════════════════════
   // Phase 4: 构建响应 — filesByTarget + analysisFramework
   // ═══════════════════════════════════════════════════════════
   const targetFileMap = {};
   for (const f of allFiles) {
-    if (!targetFileMap[f.targetName]) targetFileMap[f.targetName] = [];
+    if (!targetFileMap[f.targetName]) {
+      targetFileMap[f.targetName] = [];
+    }
     const lines = f.content.split('\n');
     targetFileMap[f.targetName].push({
       name: f.name,
@@ -370,17 +478,23 @@ export async function bootstrapKnowledge(ctx, args) {
   const skillsEnhanced = Object.keys(skillGuides).length > 0;
 
   if (skillsEnhanced) {
-    ctx.logger.info(`[Bootstrap] Skill dimension guides extracted for: ${Object.keys(skillGuides).join(', ')}`);
+    ctx.logger.info(
+      `[Bootstrap] Skill dimension guides extracted for: ${Object.keys(skillGuides).join(', ')}`
+    );
     // 输出每个 guide 的前 80 字符用于诊断
     for (const [dimId, guide] of Object.entries(skillGuides)) {
       ctx.logger.debug(`[Bootstrap] Skill guide [${dimId}]: ${guide.substring(0, 80)}...`);
     }
     // 输出 sectionMap 诊断
     for (const [dimId, sections] of Object.entries(skillSections)) {
-      ctx.logger.debug(`[Bootstrap] Skill sections [${dimId}]: ${sections.length} section(s) — ${sections.map(s => s.title).join(', ')}`);
+      ctx.logger.debug(
+        `[Bootstrap] Skill sections [${dimId}]: ${sections.length} section(s) — ${sections.map((s) => s.title).join(', ')}`
+      );
     }
   } else {
-    ctx.logger.warn('[Bootstrap] No skill dimension guides extracted — Skills may not match expected format');
+    ctx.logger.warn(
+      '[Bootstrap] No skill dimension guides extracted — Skills may not match expected format'
+    );
   }
 
   report.phases.skillLoading = {
@@ -398,41 +512,278 @@ export async function bootstrapKnowledge(ctx, args) {
   //   ⑧ ⑨ 提前到 ⑥ 前面执行 → deep-scan / category-scan 的中间结果
   //   通过 PipelineContext 缓存，供 project-profile 复用，避免重复扫描
   const baseDimensions = [
-    // ① 代码规范（Dual: Skill + Candidate）— 新增 api-naming、comment-style 子主题
-    { id: 'code-standard', label: '代码规范', guide: '命名约定（类名前缀/方法签名风格/API 命名）、注释风格（语言/格式/MARK 分段）、文件组织规范', knowledgeTypes: ['code-standard', 'code-style'],
-      skillWorthy: true, dualOutput: true, skillMeta: { name: 'project-code-standard', description: 'Project coding standards and naming conventions (auto-generated by bootstrap)' } },
-    // ② 代码模式（Candidate）— 新增 builder、observer、coordinator
-    { id: 'code-pattern', label: '设计模式与代码惯例', guide: '单例/委托/Category·Extension/工厂/Builder/观察者/Coordinator 模式、继承关系', knowledgeTypes: ['code-pattern', 'code-relation', 'inheritance'] },
-    // ③ 架构模式（Dual: Skill + Candidate）— 新增 boundary-rules 子主题
-    { id: 'architecture', label: '架构模式', guide: '分层架构、模块职责与边界、依赖图、导入约束规则', knowledgeTypes: ['architecture', 'module-dependency', 'boundary-constraint'],
-      skillWorthy: true, dualOutput: true, skillMeta: { name: 'project-architecture', description: 'Project architecture layers, module boundaries and dependency graph (auto-generated by bootstrap)' } },
-    // ④ 最佳实践（Candidate）— 新增 logging、testing 子主题
-    { id: 'best-practice', label: '最佳实践', guide: '错误处理、并发安全、内存管理、日志规范、测试模式', knowledgeTypes: ['best-practice'] },
-    // ⑤ 事件与数据流（Candidate）— 合并原 call-chain + data-flow，消除重叠
-    { id: 'event-and-data-flow', label: '事件与数据流', guide: '事件传播（Delegate/Notification/Block·Closure/Target-Action）、数据状态管理（KVO/属性观察/响应式/持久化）', knowledgeTypes: ['call-chain', 'data-flow'] },
-    // ⑧ ObjC/Swift 深度扫描（dualOutput: Skill + Candidate → Recipe → Snippet）— 常量 + Hook
-    // ★ 提前到 ⑥ 前面执行，中间结果缓存到 PipelineContext 供 project-profile 复用
-    { id: 'objc-deep-scan', label: '深度扫描（常量/Hook）', guide: '全量扫描 #define 值宏/函数宏、extern/static 常量、Method Swizzling hook 对（Agent 必须使用项目常量，修改被 hook 方法前必须查阅 hook 清单）', knowledgeTypes: ['code-standard', 'code-pattern'],
-      skillWorthy: true, dualOutput: true, skillMeta: { name: 'project-objc-deep-scan', description: 'Project #define macros, static constants, and Method Swizzling hooks (auto-generated by bootstrap)' } },
-    // ⑨ Foundation/UIKit Category/Extension 专项扫描（dualOutput: Skill + Candidate → Recipe → Snippet）
-    // ★ 提前到 ⑥ 前面执行，分类方法清单缓存到 PipelineContext 供 project-profile/base-extensions 复用
-    { id: 'category-scan', label: '基础类分类方法扫描', guide: 'Foundation/UIKit Category/Extension 逐方法清单（含完整实现代码与项目使用频次），仅扫描基础类分类、不含业务代码（Agent 遇到同等功能必须使用项目已有分类方法，禁止重复实现）', knowledgeTypes: ['code-standard', 'code-pattern'],
-      skillWorthy: true, dualOutput: true, skillMeta: { name: 'project-category-scan', description: 'Foundation/UIKit Category and Extension methods with implementations and usage patterns — base classes only, no business code (auto-generated by bootstrap)' } },
-    // ⑥ 项目特征（Dual: Skill + Candidate）— v4.2: 8 个子主题
-    // ★ 排在 ⑧⑨ 之后，可从 PipelineContext 读取 deep-scan/category-scan 的缓存结果
-    { id: 'project-profile', label: '项目特征', guide: '技术栈、目录结构、三方依赖枚举与用途、Extension/Category 分类聚合、自定义基类层级与全局定义（宏/typealias/PCH）、系统事件 hook 与生命周期入口、基础设施服务注册表、Runtime 与语言互操作', knowledgeTypes: ['architecture'],
-      skillWorthy: true, dualOutput: true, skillMeta: { name: 'project-profile', description: 'Project tech stack, module structure, third-party dependencies, base extensions/classes, event hooks, infrastructure services, and runtime/interop features (auto-generated by bootstrap)' } },
-    // ⑦ Agent 开发注意事项（Skill）— 新增 deprecated-api、arch-constraints、coding-principles 子主题
-    { id: 'agent-guidelines', label: 'Agent开发注意事项', guide: '三大核心原则（严谨性/深度特征挖掘/完整性）、命名强制、线程安全、内存约束、已废弃 API 标记、架构约束注释、TODO/FIXME', knowledgeTypes: ['boundary-constraint', 'code-standard'],
-      skillWorthy: true, skillMeta: { name: 'project-agent-guidelines', description: 'Mandatory coding rules, deprecated APIs and agent constraints for this project (auto-generated by bootstrap)' } },
+    // ── 通用维度（所有语言共享）──────────────────────────────────
+
+    // ① 代码规范（Dual: Skill + Candidate）
+    {
+      id: 'code-standard',
+      label: '代码规范',
+      guide:
+        '命名约定（类名前缀/方法签名风格/API 命名）、注释风格（语言/格式/MARK 分段）、文件组织规范',
+      knowledgeTypes: ['code-standard', 'code-style'],
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-code-standard',
+        description:
+          'Project coding standards and naming conventions (auto-generated by bootstrap)',
+      },
+    },
+    // ② 代码模式（Candidate）
+    {
+      id: 'code-pattern',
+      label: '设计模式与代码惯例',
+      guide: '单例/委托/Category·Extension/工厂/Builder/观察者/Coordinator 模式、继承关系',
+      knowledgeTypes: ['code-pattern', 'code-relation', 'inheritance'],
+    },
+    // ③ 架构模式（Dual: Skill + Candidate）
+    {
+      id: 'architecture',
+      label: '架构模式',
+      guide: '分层架构、模块职责与边界、依赖图、导入约束规则',
+      knowledgeTypes: ['architecture', 'module-dependency', 'boundary-constraint'],
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-architecture',
+        description:
+          'Project architecture layers, module boundaries and dependency graph (auto-generated by bootstrap)',
+      },
+    },
+    // ④ 最佳实践（Candidate）
+    {
+      id: 'best-practice',
+      label: '最佳实践',
+      guide: '错误处理、并发安全、内存管理、日志规范、测试模式',
+      knowledgeTypes: ['best-practice'],
+    },
+    // ⑤ 事件与数据流（Candidate）
+    {
+      id: 'event-and-data-flow',
+      label: '事件与数据流',
+      guide:
+        '事件传播（Delegate/Notification/Block·Closure/Target-Action）、数据状态管理（KVO/属性观察/响应式/持久化）',
+      knowledgeTypes: ['call-chain', 'data-flow'],
+    },
+    // ⑥ 项目特征（Dual: Skill + Candidate）
+    {
+      id: 'project-profile',
+      label: '项目特征',
+      guide:
+        '技术栈、目录结构、三方依赖枚举与用途、Extension/Category 分类聚合、自定义基类层级与全局定义（宏/typealias/PCH）、系统事件 hook 与生命周期入口、基础设施服务注册表、Runtime 与语言互操作',
+      knowledgeTypes: ['architecture'],
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-profile',
+        description:
+          'Project tech stack, module structure, third-party dependencies, base extensions/classes, event hooks, infrastructure services, and runtime/interop features (auto-generated by bootstrap)',
+      },
+    },
+    // ⑦ Agent 开发注意事项（Skill）
+    {
+      id: 'agent-guidelines',
+      label: 'Agent开发注意事项',
+      guide:
+        '三大核心原则（严谨性/深度特征挖掘/完整性）、命名强制、线程安全、内存约束、已废弃 API 标记、架构约束注释、TODO/FIXME',
+      knowledgeTypes: ['boundary-constraint', 'code-standard'],
+      skillWorthy: true,
+      skillMeta: {
+        name: 'project-agent-guidelines',
+        description:
+          'Mandatory coding rules, deprecated APIs and agent constraints for this project (auto-generated by bootstrap)',
+      },
+    },
+
+    // ── 语言条件维度（按 conditions 过滤）──────────────────────
+
+    // ⑧ ObjC/Swift 深度扫描
+    {
+      id: 'objc-deep-scan',
+      label: '深度扫描（常量/Hook）',
+      guide:
+        '全量扫描 #define 值宏/函数宏、extern/static 常量、Method Swizzling hook 对（Agent 必须使用项目常量，修改被 hook 方法前必须查阅 hook 清单）',
+      knowledgeTypes: ['code-standard', 'code-pattern'],
+      conditions: { languages: ['objectivec', 'swift'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-objc-deep-scan',
+        description:
+          'Project #define macros, static constants, and Method Swizzling hooks (auto-generated by bootstrap)',
+      },
+    },
+    // ⑨ Foundation/UIKit Category/Extension 专项扫描
+    {
+      id: 'category-scan',
+      label: '基础类分类方法扫描',
+      guide:
+        'Foundation/UIKit Category/Extension 逐方法清单（含完整实现代码与项目使用频次），仅扫描基础类分类、不含业务代码（Agent 遇到同等功能必须使用项目已有分类方法，禁止重复实现）',
+      knowledgeTypes: ['code-standard', 'code-pattern'],
+      conditions: { languages: ['objectivec', 'swift'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-category-scan',
+        description:
+          'Foundation/UIKit Category and Extension methods with implementations and usage patterns — base classes only, no business code (auto-generated by bootstrap)',
+      },
+    },
+
+    // ⑩ TS/JS 模块导出分析
+    {
+      id: 'module-export-scan',
+      label: '模块导出分析',
+      guide: 'barrel export 结构、re-export 链路、public API surface、tree-shaking 合规性',
+      knowledgeTypes: ['code-standard', 'architecture'],
+      conditions: { languages: ['typescript', 'javascript'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-module-exports',
+        description: 'Module export structure and public API surface (auto-generated by bootstrap)',
+      },
+    },
+    // ⑪ TS/JS 框架约定扫描
+    {
+      id: 'framework-convention-scan',
+      label: '框架约定扫描',
+      guide: '组件目录结构、状态管理约定、路由约定、样式约定、数据获取模式',
+      knowledgeTypes: ['code-standard', 'architecture'],
+      conditions: {
+        languages: ['typescript', 'javascript'],
+        frameworks: ['react', 'vue', 'angular', 'nextjs', 'nuxt'],
+      },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-framework-conventions',
+        description: 'Framework-specific conventions and patterns (auto-generated by bootstrap)',
+      },
+    },
+
+    // ⑫ Python 包结构分析
+    {
+      id: 'python-package-scan',
+      label: 'Python 包结构分析',
+      guide:
+        '__init__.py 导出策略、相对/绝对导入风格、type hints 覆盖率、decorator 使用模式、__all__ 定义',
+      knowledgeTypes: ['code-standard', 'architecture'],
+      conditions: { languages: ['python'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-python-structure',
+        description:
+          'Python package structure, import patterns and type hint coverage (auto-generated by bootstrap)',
+      },
+    },
+
+    // ⑬ Java/Kotlin 注解扫描
+    {
+      id: 'jvm-annotation-scan',
+      label: '注解/Annotation 扫描',
+      guide:
+        'DI 注解（@Inject/@Autowired/@Component）、ORM 注解（@Entity/@Table）、API 注解（@RestController/@RequestMapping）、自定义注解、元编程模式',
+      knowledgeTypes: ['code-pattern', 'architecture'],
+      conditions: { languages: ['java', 'kotlin'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-jvm-annotations',
+        description:
+          'Annotation/DI usage patterns and meta-programming (auto-generated by bootstrap)',
+      },
+    },
+
+    // ⑭ Go 模块结构分析
+    {
+      id: 'go-module-scan',
+      label: 'Go 模块结构分析',
+      guide:
+        'go.mod 依赖图、internal 包隔离边界、cmd/ 入口点枚举、build tags/constraints、interface 分布与实现关系、init() 函数清单',
+      knowledgeTypes: ['architecture', 'code-pattern'],
+      conditions: { languages: ['go'] },
+      skillWorthy: true,
+      dualOutput: true,
+      skillMeta: {
+        name: 'project-go-module-structure',
+        description:
+          'Go module structure, internal packages, build tags and interface distribution (auto-generated by bootstrap)',
+      },
+    },
   ];
 
+  // ── 根据项目主语言和框架过滤条件维度 ──────────────────────
+  const detectedFrameworks = allTargets
+    .map((t) => (typeof t === 'object' ? t.framework : null))
+    .filter(Boolean);
+  const activeDimensions = _resolveActiveDimensions(
+    baseDimensions,
+    primaryLang,
+    detectedFrameworks
+  );
+
+  // ── Enhancement Pack 动态追加维度 + Guard 规则 ─────────────
+  const enhancementPackInfo = [];
+  const enhancementGuardRules = [];
+  const enhancementPatterns = [];
+  try {
+    const { initEnhancementRegistry } = await import('../../../core/enhancement/index.js');
+    const enhReg = await initEnhancementRegistry();
+    const matchedPacks = enhReg.resolve(primaryLang, detectedFrameworks);
+    for (const pack of matchedPacks) {
+      enhancementPackInfo.push({ id: pack.id, displayName: pack.displayName });
+      // 追加额外维度
+      const extraDims = pack.getExtraDimensions();
+      for (const dim of extraDims) {
+        // 避免与 baseDimensions 中已有的 id 重复
+        if (!activeDimensions.some((d) => d.id === dim.id)) {
+          activeDimensions.push(dim);
+        }
+      }
+      // 收集 Guard 规则
+      const guardRules = pack.getGuardRules();
+      if (guardRules.length > 0) {
+        enhancementGuardRules.push(...guardRules);
+      }
+      // 收集 AST 模式检测
+      if (astProjectSummary) {
+        try {
+          const patterns = pack.detectPatterns(astProjectSummary);
+          if (patterns.length > 0) {
+            enhancementPatterns.push(...patterns.map((p) => ({ ...p, source: pack.id })));
+          }
+        } catch {
+          /* graceful degradation */
+        }
+      }
+    }
+    if (matchedPacks.length > 0) {
+      ctx.logger.info(
+        `[Bootstrap] Enhancement packs matched: ${matchedPacks.map((p) => p.id).join(', ')} → +${activeDimensions.length - baseDimensions.length} extra dims, ${enhancementGuardRules.length} guard rules, ${enhancementPatterns.length} patterns`
+      );
+    }
+  } catch (enhErr) {
+    ctx.logger.warn(`[Bootstrap] Enhancement pack loading skipped: ${enhErr.message}`);
+  }
+  report.phases.enhancementPacks = {
+    matched: enhancementPackInfo,
+    extraDimensions: enhancementPackInfo.length,
+    guardRules: enhancementGuardRules.length,
+    patterns: enhancementPatterns.length,
+  };
+
+  // 按项目语言画像注入差异化文案（支持多语言项目）
+  const langProfile = LanguageService.detectProfile(langStats);
+  DimensionCopy.applyMulti(activeDimensions, langProfile.primary, langProfile.secondary);
+
   // 用 Skill 内容增强维度 guide（共享层增强点）
-  const dimensions = enhanceDimensions(baseDimensions, skillGuides, skillSections);
+  const dimensions = enhanceDimensions(activeDimensions, skillGuides, skillSections);
 
   const responseData = {
     report,
-    targets: allTargets.map(t => {
+    targets: allTargets.map((t) => {
       const name = typeof t === 'string' ? t : t.name;
       return {
         name,
@@ -448,65 +799,102 @@ export async function bootstrapKnowledge(ctx, args) {
       Object.entries(targetFileMap).map(([target, files]) => {
         const sorted = [...files].sort((a, b) => (b.priority || 0) - (a.priority || 0));
         const top = sorted.slice(0, 10);
-        return [target, {
-          totalFiles: files.length,
-          topFiles: top.map(({ content, ...meta }) => meta),
-          ...(files.length > 10 ? { truncated: true } : {}),
-        }];
+        return [
+          target,
+          {
+            totalFiles: files.length,
+            topFiles: top.map(({ content, ...meta }) => meta),
+            ...(files.length > 10 ? { truncated: true } : {}),
+          },
+        ];
       })
     ),
-    dependencyGraph: depGraphData ? {
-      nodes: (depGraphData.nodes || []).map(n => ({
-        id: typeof n === 'string' ? n : n.id,
-        label: typeof n === 'string' ? n : n.label,
-      })),
-      edges: depGraphData.edges || [],
-    } : null,
+    dependencyGraph: depGraphData
+      ? {
+          nodes: (depGraphData.nodes || []).map((n) => ({
+            id: typeof n === 'string' ? n : n.id,
+            label: typeof n === 'string' ? n : n.label,
+          })),
+          edges: depGraphData.edges || [],
+        }
+      : null,
     languageStats: langStats,
     primaryLanguage: primaryLang,
+    secondaryLanguages: langProfile.secondary,
+    isMultiLang: langProfile.isMultiLang,
     languageExtension: buildLanguageExtension(primaryLang),
-    guardSummary: guardAudit ? {
-      totalViolations: guardAudit.summary?.totalViolations || 0,
-      errors: guardAudit.summary?.errors || 0,
-      warnings: guardAudit.summary?.warnings || 0,
-    } : null,
+    guardSummary: guardAudit
+      ? {
+          totalViolations: guardAudit.summary?.totalViolations || 0,
+          errors: guardAudit.summary?.errors || 0,
+          warnings: guardAudit.summary?.warnings || 0,
+        }
+      : null,
     guardViolationFiles: guardAudit
-      ? (guardAudit.files || []).filter(f => f.violations.length > 0).map(f => ({
-          filePath: f.filePath,
-          violations: f.violations.map(v => ({ ruleId: v.ruleId, severity: v.severity, message: v.message, line: v.line })),
-        }))
+      ? (guardAudit.files || [])
+          .filter((f) => f.violations.length > 0)
+          .map((f) => ({
+            filePath: f.filePath,
+            violations: f.violations.map((v) => ({
+              ruleId: v.ruleId,
+              severity: v.severity,
+              message: v.message,
+              line: v.line,
+            })),
+          }))
       : [],
 
     // 9 维度分析框架（4 Skill-only + 2 dualOutput + 3 Candidate-only）
     // 注意：anti-pattern 已移除，代码问题由 Guard 独立处理
     analysisFramework: {
       dimensions,
-      skillWorthyDimensions: dimensions.filter(d => d.skillWorthy).map(d => d.id),
-      candidateOnlyDimensions: dimensions.filter(d => !d.skillWorthy).map(d => d.id),
-      candidateRequiredFields: ['title', 'code', 'language', 'category', 'knowledgeType', 'reasoning'],
+      skillWorthyDimensions: dimensions.filter((d) => d.skillWorthy).map((d) => d.id),
+      candidateOnlyDimensions: dimensions.filter((d) => !d.skillWorthy).map((d) => d.id),
+      candidateRequiredFields: [
+        'title',
+        'code',
+        'language',
+        'category',
+        'knowledgeType',
+        'reasoning',
+      ],
       submissionTool: 'autosnippet_submit_knowledge_batch',
-      expectedOutput: '候选知识（微观代码维度：code-pattern/best-practice/event-and-data-flow + 深度扫描：objc-deep-scan/category-scan）+ 6 个 Project Skills（宏观叙事维度：code-standard/architecture/project-profile/agent-guidelines + 深度扫描：objc-deep-scan/category-scan）',
+      expectedOutput: `候选知识（微观代码维度：code-pattern/best-practice/event-and-data-flow + 语言条件扫描）+ Project Skills（宏观叙事维度：code-standard/architecture/project-profile/agent-guidelines + 语言条件扫描）— 共 ${dimensions.length} 个维度`,
     },
 
     // AST 代码结构分析上下文（供 ChatAgent 使用）
     astContext: astContext || null,
-    astSummary: astProjectSummary ? {
-      classes: astProjectSummary.classes.length,
-      protocols: astProjectSummary.protocols.length,
-      categories: astProjectSummary.categories.length,
-      patterns: Object.keys(astProjectSummary.patternStats || {}),
-      metrics: astProjectSummary.projectMetrics ? {
-        totalMethods: astProjectSummary.projectMetrics.totalMethods,
-        avgMethodsPerClass: astProjectSummary.projectMetrics.avgMethodsPerClass,
-        maxNestingDepth: astProjectSummary.projectMetrics.maxNestingDepth,
-        complexMethods: astProjectSummary.projectMetrics.complexMethods?.length || 0,
-        longMethods: astProjectSummary.projectMetrics.longMethods?.length || 0,
-      } : null,
-    } : null,
+    astSummary: astProjectSummary
+      ? {
+          classes: astProjectSummary.classes.length,
+          protocols: astProjectSummary.protocols.length,
+          categories: astProjectSummary.categories.length,
+          patterns: Object.keys(astProjectSummary.patternStats || {}),
+          metrics: astProjectSummary.projectMetrics
+            ? {
+                totalMethods: astProjectSummary.projectMetrics.totalMethods,
+                avgMethodsPerClass: astProjectSummary.projectMetrics.avgMethodsPerClass,
+                maxNestingDepth: astProjectSummary.projectMetrics.maxNestingDepth,
+                complexMethods: astProjectSummary.projectMetrics.complexMethods?.length || 0,
+                longMethods: astProjectSummary.projectMetrics.longMethods?.length || 0,
+              }
+            : null,
+        }
+      : null,
+
+    // Enhancement Pack 检测到的额外模式
+    enhancementPacks:
+      enhancementPackInfo.length > 0
+        ? {
+            matched: enhancementPackInfo,
+            patterns: enhancementPatterns,
+            guardRules: enhancementGuardRules.length,
+          }
+        : null,
 
     // 引导 Agent 下一步操作
     nextSteps: [
-      '✅ Bootstrap 骨架已创建，9 个维度的 AI 分析任务已在后台启动。',
+      `✅ Bootstrap 骨架已创建，${dimensions.length} 个维度的 AI 分析任务已在后台启动。`,
       '',
       '== 后台自动执行中 ==',
       '后台 AI pipeline 正在逐维度分析代码并创建候选（Analyst → Producer 双 Agent 模式）。',
@@ -519,7 +907,10 @@ export async function bootstrapKnowledge(ctx, args) {
       '4. 使用 autosnippet_skill({ operation: "load", name }) 加载自动生成的 Project Skills',
       '',
       '== 宏观维度 → Project Skills ==',
-      '宏观维度（architecture/code-standard/project-profile/agent-guidelines/objc-deep-scan/category-scan）',
+      `宏观维度（${dimensions
+        .filter((d) => d.skillWorthy)
+        .map((d) => d.id)
+        .join('/')}）`,
       '自动生成 Project Skill 到 AutoSnippet/skills/，可通过 autosnippet_skill({ operation: "load" }) 加载。',
     ],
   };
@@ -534,7 +925,7 @@ export async function bootstrapKnowledge(ctx, args) {
   // ═══════════════════════════════════════════════════════════
 
   // 构建任务定义列表
-  const taskDefs = dimensions.map(dim => ({
+  const taskDefs = dimensions.map((dim) => ({
     id: dim.id,
     meta: {
       type: dim.skillWorthy ? 'skill' : 'candidate',
@@ -551,7 +942,9 @@ export async function bootstrapKnowledge(ctx, args) {
     const taskManager = ctx.container.get('bootstrapTaskManager');
     bootstrapSession = taskManager.startSession(taskDefs);
   } catch (e) {
-    ctx.logger.warn(`[Bootstrap] BootstrapTaskManager init failed (graceful degradation): ${e.message}`);
+    ctx.logger.warn(
+      `[Bootstrap] BootstrapTaskManager init failed (graceful degradation): ${e.message}`
+    );
   }
 
   // 立即构建骨架响应
@@ -575,7 +968,13 @@ export async function bootstrapKnowledge(ctx, args) {
     astProjectSummary,
     skillContext,
     skillsEnhanced,
-    taskManager: (() => { try { return ctx.container.get('bootstrapTaskManager'); } catch { return null; } })(),
+    taskManager: (() => {
+      try {
+        return ctx.container.get('bootstrapTaskManager');
+      } catch {
+        return null;
+      }
+    })(),
     sessionId: bootstrapSession?.id || null,
     projectRoot,
     // v5.0: 增量 Bootstrap 计划
@@ -585,7 +984,7 @@ export async function bootstrapKnowledge(ctx, args) {
   // 使用 setImmediate 避免阻塞 HTTP 响应
   setImmediate(() => {
     ctx.logger.info(`[Bootstrap] Dispatching v3 AI-First pipeline`);
-    fillDimensionsV3(fillContext).catch(e => {
+    fillDimensionsV3(fillContext).catch((e) => {
       ctx.logger.error(`[Bootstrap] Async fill (v3) failed: ${e.message}`);
     });
   });
@@ -593,16 +992,23 @@ export async function bootstrapKnowledge(ctx, args) {
   // ── SkillHooks: onBootstrapStarted (fire-and-forget) ──
   try {
     const skillHooks = ctx.container.get('skillHooks');
-    skillHooks.run('onBootstrapComplete', {
-      filesScanned: allFiles.length,
-      targetsFound: allTargets.length,
-      candidatesCreated: 0,       // 异步填充中，初始为 0
-      candidatesFailed: 0,
-      autoSkillsCreated: 0,
-      autoSkills: [],
-    }, { projectRoot: ctx.container.get('database')?.filename || '' })
+    skillHooks
+      .run(
+        'onBootstrapComplete',
+        {
+          filesScanned: allFiles.length,
+          targetsFound: allTargets.length,
+          candidatesCreated: 0, // 异步填充中，初始为 0
+          candidatesFailed: 0,
+          autoSkillsCreated: 0,
+          autoSkills: [],
+        },
+        { projectRoot: ctx.container.get('database')?.filename || '' }
+      )
       .catch(() => {}); // fire-and-forget
-  } catch { /* skillHooks not available */ }
+  } catch {
+    /* skillHooks not available */
+  }
 
   return envelope({
     success: true,
@@ -629,7 +1035,11 @@ export async function bootstrapRefine(ctx, args) {
   const aiProvider = ctx.container.get('aiProvider');
 
   if (!aiProvider) {
-    return envelope({ success: false, message: 'AI provider not configured', errorCode: 'MISSING_AI_PROVIDER' });
+    return envelope({
+      success: false,
+      message: 'AI provider not configured',
+      errorCode: 'MISSING_AI_PROVIDER',
+    });
   }
 
   // 接入 BootstrapTaskManager 双通道推送 refine:* 事件
@@ -637,7 +1047,9 @@ export async function bootstrapRefine(ctx, args) {
   try {
     const taskManager = ctx.container.get('bootstrapTaskManager');
     onProgress = (eventName, data) => taskManager.emitProgress(eventName, data);
-  } catch { /* optional */ }
+  } catch {
+    /* optional */
+  }
 
   // 1. 收集待润色条目
   let entries;
@@ -645,21 +1057,39 @@ export async function bootstrapRefine(ctx, args) {
     entries = [];
     for (const id of args.candidateIds) {
       const e = await knowledgeService.get(id);
-      if (e) entries.push(typeof e.toJSON === 'function' ? e.toJSON() : e);
+      if (e) {
+        entries.push(typeof e.toJSON === 'function' ? e.toJSON() : e);
+      }
     }
   } else {
-    const result = await knowledgeService.list({ lifecycle: 'pending', source: 'bootstrap' }, { page: 1, pageSize: 200 });
-    entries = (result.items || []).map(e => typeof e.toJSON === 'function' ? e.toJSON() : e);
+    const result = await knowledgeService.list(
+      { lifecycle: 'pending', source: 'bootstrap' },
+      { page: 1, pageSize: 200 }
+    );
+    entries = (result.items || []).map((e) => (typeof e.toJSON === 'function' ? e.toJSON() : e));
   }
 
   if (entries.length === 0) {
-    return envelope({ success: true, data: { refined: 0, total: 0, errors: [], results: [] }, meta: { tool: 'autosnippet_bootstrap', responseTimeMs: Date.now() - t0 } });
+    return envelope({
+      success: true,
+      data: { refined: 0, total: 0, errors: [], results: [] },
+      meta: { tool: 'autosnippet_bootstrap', responseTimeMs: Date.now() - t0 },
+    });
   }
 
-  onProgress?.('refine:started', { total: entries.length, candidateIds: entries.map(e => e.id) });
+  onProgress?.('refine:started', { total: entries.length, candidateIds: entries.map((e) => e.id) });
 
-  // 2. 逐条 AI 润色
-  const allTitles = entries.map(e => e.title).filter(Boolean);
+  // 2. 收集已发布 Recipe 标题（关联关系只能指向已发布 Recipe，不能在候选之间互关联）
+  let publishedTitles = [];
+  try {
+    const published = await knowledgeService.list(
+      { lifecycle: 'active' },
+      { page: 1, pageSize: 200 }
+    );
+    publishedTitles = (published.items || []).map((e) => e.title).filter(Boolean);
+  } catch { /* ignore */ }
+
+  // 3. 逐条 AI 润色
   const results = [];
   const errors = [];
   let refined = 0;
@@ -667,7 +1097,13 @@ export async function bootstrapRefine(ctx, args) {
 
   for (const entry of entries) {
     processed++;
-    onProgress?.('refine:item-started', { candidateId: entry.id, title: entry.title, current: processed, total: entries.length, progress: Math.round(((processed - 1) / entries.length) * 100) });
+    onProgress?.('refine:item-started', {
+      candidateId: entry.id,
+      title: entry.title,
+      current: processed,
+      total: entries.length,
+      progress: Math.round(((processed - 1) / entries.length) * 100),
+    });
 
     try {
       const before = {
@@ -685,7 +1121,7 @@ export async function bootstrapRefine(ctx, args) {
 
       const refineInstruction = args.userPrompt
         ? args.userPrompt
-        : '请改善描述使其更专业简洁，补充高阶架构洞察，如缺少关联关系请推断补充';
+        : '请改善描述使其更专业简洁，补充高阶架构洞察';
 
       const prompt = `你是一位高级代码知识管理专家。请改进以下知识条目。
 
@@ -736,7 +1172,7 @@ ${before.aiInsight || '（空）'}
 【agentNotes】Agent 笔记
 ${JSON.stringify(before.agentNotes || [])}
 
-同批次知识: ${allTitles.slice(0, 20).join(', ')}
+${publishedTitles.length > 0 ? `已发布的 Recipe: ${publishedTitles.slice(0, 20).join(', ')}` : '（尚无已发布的 Recipe）'}
 
 ## 润色指令
 
@@ -747,7 +1183,8 @@ ${refineInstruction}
 1. 只修改需要改进的字段，未涉及的必须原样返回。
 2. tags 采用合并策略（保留原有 + 补充新建议），不要删除已有标签。
 3. relations 为 object 格式，key 为关系类型（如 inherits/implements/calls/depends_on/extends/related），value 为 string[]。
-4. 每个 key 都必须存在，key 名称必须与上述完全一致。
+4. relations 只能指向已发布的 Recipe，不能在候选之间建立关联。如果没有已发布的 Recipe，relations 应保持为空 {}。
+5. 每个 key 都必须存在，key 名称必须与上述完全一致。
 
 仅返回 JSON，不要添加任何其他文字或代码块标记。`;
 
@@ -755,39 +1192,77 @@ ${refineInstruction}
 
       if (!parsed) {
         errors.push({ id: entry.id, title: entry.title, error: 'AI returned no valid JSON' });
-        onProgress?.('refine:item-failed', { candidateId: entry.id, title: entry.title, error: 'No valid JSON', current: processed, total: entries.length, progress: Math.round((processed / entries.length) * 100) });
+        onProgress?.('refine:item-failed', {
+          candidateId: entry.id,
+          title: entry.title,
+          error: 'No valid JSON',
+          current: processed,
+          total: entries.length,
+          progress: Math.round((processed / entries.length) * 100),
+        });
         continue;
       }
 
       if (args.dryRun) {
         results.push({ id: entry.id, title: entry.title, preview: parsed });
-        onProgress?.('refine:item-completed', { candidateId: entry.id, title: entry.title, refined: false, current: processed, total: entries.length, progress: Math.round((processed / entries.length) * 100) });
+        onProgress?.('refine:item-completed', {
+          candidateId: entry.id,
+          title: entry.title,
+          refined: false,
+          current: processed,
+          total: entries.length,
+          progress: Math.round((processed / entries.length) * 100),
+        });
         continue;
       }
 
       // ─── key 别名归一化（与 candidates.js 保持一致） ───
       const KEY_ALIASES = {
-        summary: 'description', desc: 'description',
-        content: 'pattern', design: 'rationale', designRationale: 'rationale',
-        markdownDoc: 'markdown', doc: 'markdown',
-        tag: 'tags', label: 'tags', labels: 'tags',
+        summary: 'description',
+        desc: 'description',
+        content: 'pattern',
+        design: 'rationale',
+        designRationale: 'rationale',
+        markdownDoc: 'markdown',
+        doc: 'markdown',
+        tag: 'tags',
+        label: 'tags',
+        labels: 'tags',
         score: 'confidence',
-        ai_insight: 'aiInsight', insight: 'aiInsight', aiinsight: 'aiInsight',
-        agent_notes: 'agentNotes', notes: 'agentNotes', agentnotes: 'agentNotes',
+        ai_insight: 'aiInsight',
+        insight: 'aiInsight',
+        aiinsight: 'aiInsight',
+        agent_notes: 'agentNotes',
+        notes: 'agentNotes',
+        agentnotes: 'agentNotes',
         relation: 'relations',
       };
-      const VALID_KEYS = new Set(['description', 'pattern', 'markdown', 'rationale', 'tags', 'confidence', 'aiInsight', 'agentNotes', 'relations']);
+      const VALID_KEYS = new Set([
+        'description',
+        'pattern',
+        'markdown',
+        'rationale',
+        'tags',
+        'confidence',
+        'aiInsight',
+        'agentNotes',
+        'relations',
+      ]);
       const normalized = {};
       for (const [key, value] of Object.entries(parsed)) {
         if (VALID_KEYS.has(key)) {
           normalized[key] = value;
         } else {
           const mapped = KEY_ALIASES[key] || KEY_ALIASES[key.toLowerCase?.()];
-          if (mapped && !(mapped in normalized)) normalized[mapped] = value;
+          if (mapped && !(mapped in normalized)) {
+            normalized[mapped] = value;
+          }
         }
       }
       for (const k of VALID_KEYS) {
-        if (!(k in normalized)) normalized[k] = before[k];
+        if (!(k in normalized)) {
+          normalized[k] = before[k];
+        }
       }
 
       // 构建更新数据
@@ -806,7 +1281,10 @@ ${refineInstruction}
           changed = true;
         }
       }
-      if (typeof normalized.confidence === 'number' && normalized.confidence !== before.confidence) {
+      if (
+        typeof normalized.confidence === 'number' &&
+        normalized.confidence !== before.confidence
+      ) {
         updateData.reasoning = { ...(entry.reasoning || {}), confidence: normalized.confidence };
         changed = true;
       }
@@ -853,11 +1331,31 @@ ${refineInstruction}
         refined++;
       }
 
-      results.push({ id: entry.id, title: entry.title, refined: changed, fields: Object.keys(parsed) });
-      onProgress?.('refine:item-completed', { candidateId: entry.id, title: entry.title, refined: changed, current: processed, total: entries.length, progress: Math.round((processed / entries.length) * 100), refinedSoFar: refined });
+      results.push({
+        id: entry.id,
+        title: entry.title,
+        refined: changed,
+        fields: Object.keys(parsed),
+      });
+      onProgress?.('refine:item-completed', {
+        candidateId: entry.id,
+        title: entry.title,
+        refined: changed,
+        current: processed,
+        total: entries.length,
+        progress: Math.round((processed / entries.length) * 100),
+        refinedSoFar: refined,
+      });
     } catch (err) {
       errors.push({ id: entry.id, title: entry.title, error: err.message });
-      onProgress?.('refine:item-failed', { candidateId: entry.id, title: entry.title, error: err.message, current: processed, total: entries.length, progress: Math.round((processed / entries.length) * 100) });
+      onProgress?.('refine:item-failed', {
+        candidateId: entry.id,
+        title: entry.title,
+        error: err.message,
+        current: processed,
+        total: entries.length,
+        progress: Math.round((processed / entries.length) * 100),
+      });
     }
   }
 
@@ -875,3 +1373,28 @@ ${refineInstruction}
     meta: { tool: 'autosnippet_bootstrap', responseTimeMs: Date.now() - t0 },
   });
 }
+
+// ══════════════════════════════════════════════════════════════════
+// 内部辅助 — 维度条件化
+// ══════════════════════════════════════════════════════════════════
+
+/**
+ * 根据项目主语言和检测到的框架过滤条件维度
+ * @param {Array} allDimensions  所有维度定义（含 conditions 字段）
+ * @param {string} primaryLang   主语言
+ * @param {string[]} detectedFrameworks 检测到的框架
+ * @returns {Array} 适用的维度列表
+ */
+function _resolveActiveDimensions(allDimensions, primaryLang, detectedFrameworks = []) {
+  return allDimensions.filter((dim) => {
+    if (!dim.conditions) {
+      return true; // 无条件 → 通用维度
+    }
+    const langMatch = !dim.conditions.languages || dim.conditions.languages.includes(primaryLang);
+    const fwMatch =
+      !dim.conditions.frameworks ||
+      dim.conditions.frameworks.some((f) => detectedFrameworks.includes(f));
+    // languages 必须匹配；frameworks 为可选增强（有 frameworks 条件时必须至少命中一个）
+    return langMatch && (dim.conditions.frameworks ? fwMatch : true);
+  });
+}