autosnippet 3.3.5 → 3.3.6

package/dist/lib/service/evolution/RecipeRelevanceAuditor.js

@@ -0,0 +1,492 @@
+/**
+ * RecipeRelevanceAuditor — 基于代码证据验证 Recipe 当前相关性
+ *
+ * Rescan 时主动触发，检查每个保留 Recipe 的代码证据是否仍然存在：
+ *   1. 触发模式匹配 (trigger 引用的文件类型/路径模式是否有匹配)
+ *   2. 代码符号存活 (content.pattern 引用的类名/函数名是否在 AST 中)
+ *   3. 依赖关系完整 (涉及模块依赖是否在依赖图中)
+ *   4. 源代码文件存活 (reasoning.sources + content.codeChanges 的文件是否存在)
+ *
+ * 评分后驱动快速衰退：
+ *   - healthy (80-100): 无操作
+ *   - watch (60-79): 报告警告
+ *   - decay (40-59): active → decaying (7d grace)
+ *   - severe (20-39): active → decaying (3d grace)
+ *   - dead (0-19): active → deprecated (immediate)
+ *
+ * 支持 Category 权重豁免：架构/规范类 Recipe 侧重触发模式而非具体符号。
+ *
+ * @module service/evolution/RecipeRelevanceAuditor
+ */
+// ── 常量 ────────────────────────────────────────────────────
+/** 默认证据权重
+ *
+ * 注意：不包含 sourceFileExists。DB 中 sourceFile 存储的是 Recipe md 文件路径
+ * （如 AutoSnippet/candidates/xxx.md），不是源代码路径。
+ * 真正的源代码来源在 reasoning.sources 中，由 codeFilesExist 维度检查。
+ */
+const DEFAULT_WEIGHTS = {
+    triggerStillMatches: 0.2,
+    symbolsAlive: 0.3,
+    depsIntact: 0.15,
+    codeFilesExist: 0.35,
+};
+/**
+ * 按 category 覆盖权重 — 架构/规范类侧重触发模式和来源文件
+ */
+const CATEGORY_WEIGHT_OVERRIDES = {
+    architecture: {
+        symbolsAlive: 0.05,
+        depsIntact: 0.05,
+        triggerStillMatches: 0.45,
+        codeFilesExist: 0.45,
+    },
+    'coding-standards': {
+        symbolsAlive: 0.05,
+        depsIntact: 0.05,
+        triggerStillMatches: 0.45,
+        codeFilesExist: 0.45,
+    },
+    'agent-guidelines': {
+        symbolsAlive: 0.0,
+        depsIntact: 0.0,
+        triggerStillMatches: 0.5,
+        codeFilesExist: 0.5,
+    },
+};
+/** Grace Period 常量 */
+const GRACE_PERIOD_DECAY = 7 * 24 * 60 * 60 * 1000; // 7d
+const GRACE_PERIOD_SEVERE = 3 * 24 * 60 * 60 * 1000; // 3d
+// ── RecipeRelevanceAuditor ──────────────────────────────────
+export class RecipeRelevanceAuditor {
+    #db;
+    #logger;
+    constructor(opts) {
+        const dbRaw = opts.db;
+        this.#db = typeof dbRaw?.getDb === 'function' ? dbRaw.getDb() : opts.db;
+        this.#logger = opts.logger || { info() { }, warn() { } };
+    }
+    /**
+     * 审计所有保留 Recipe 的代码证据
+     */
+    async audit(recipes, analysisData) {
+        const summary = {
+            totalAudited: 0,
+            healthy: 0,
+            watch: 0,
+            decay: 0,
+            severe: 0,
+            dead: 0,
+            results: [],
+            proposalsCreated: 0,
+            immediateDeprecated: 0,
+        };
+        // 预处理：构建快速查找集合
+        const fileSet = new Set(analysisData.fileList.map((f) => f.toLowerCase()));
+        const entityNames = new Set(analysisData.codeEntities.map((e) => e.name.toLowerCase()));
+        const depModules = new Set();
+        for (const edge of analysisData.dependencyGraph) {
+            depModules.add(edge.from.toLowerCase());
+            depModules.add(edge.to.toLowerCase());
+        }
+        for (const recipe of recipes) {
+            const fullRecipe = this.#loadFullRecipe(recipe.id);
+            if (!fullRecipe) {
+                continue;
+            }
+            const result = this.#computeRelevanceScore(fullRecipe, {
+                fileSet,
+                entityNames,
+                depModules,
+                fileList: analysisData.fileList,
+            });
+            summary.totalAudited++;
+            summary[result.verdict]++;
+            summary.results.push(result);
+            // 执行衰退状态转换
+            if (result.verdict === 'dead' || result.verdict === 'severe' || result.verdict === 'decay') {
+                const executed = this.#executeDecay(result);
+                if (result.verdict === 'dead') {
+                    summary.immediateDeprecated += executed ? 1 : 0;
+                }
+                if (executed) {
+                    summary.proposalsCreated++;
+                }
+            }
+        }
+        this.#logger.info('[RecipeRelevanceAuditor] Audit complete', {
+            total: summary.totalAudited,
+            healthy: summary.healthy,
+            watch: summary.watch,
+            decay: summary.decay,
+            severe: summary.severe,
+            dead: summary.dead,
+        });
+        return summary;
+    }
+    // ─── 内部方法 ─────────────────────────────────────────
+    /** 从 DB 加载完整 Recipe 数据 */
+    #loadFullRecipe(id) {
+        try {
+            const row = this.#db
+                .prepare(`SELECT id, title, trigger, category,
+                  content, doClause, coreCode
+           FROM knowledge_entries WHERE id = ?`)
+                .get(id);
+            return row || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** 计算单个 Recipe 的 relevanceScore */
+    #computeRelevanceScore(recipe, ctx) {
+        const category = recipe.category || '';
+        const weights = {
+            ...DEFAULT_WEIGHTS,
+            ...(CATEGORY_WEIGHT_OVERRIDES[category] || {}),
+        };
+        const decayReasons = [];
+        // 1. trigger 模式匹配
+        const triggerStillMatches = this.#checkTriggerMatch(recipe.trigger, ctx.fileList);
+        if (!triggerStillMatches) {
+            decayReasons.push(`触发条件 "${recipe.trigger}" 无匹配文件`);
+        }
+        // 2. 代码符号存活率
+        const referencedSymbols = this.#extractReferencedSymbols(recipe);
+        let symbolsAlive = 1.0;
+        if (referencedSymbols.length > 0) {
+            const aliveCount = referencedSymbols.filter((s) => ctx.entityNames.has(s.toLowerCase())).length;
+            symbolsAlive = aliveCount / referencedSymbols.length;
+            if (symbolsAlive < 0.5) {
+                decayReasons.push(`引用符号存活 ${aliveCount}/${referencedSymbols.length} (${(symbolsAlive * 100).toFixed(0)}%)`);
+            }
+        }
+        // 3. 依赖关系完整性
+        const referencedModules = this.#extractModuleReferences(recipe);
+        let depsIntact = true;
+        if (referencedModules.length > 0) {
+            const intactCount = referencedModules.filter((m) => ctx.depModules.has(m.toLowerCase())).length;
+            depsIntact = intactCount >= referencedModules.length * 0.5;
+            if (!depsIntact) {
+                decayReasons.push(`模块依赖 ${intactCount}/${referencedModules.length} 存活`);
+            }
+        }
+        // 4. 源代码文件存活率（来自 reasoning.sources + content.codeChanges）
+        const codeFiles = this.#extractCodeFiles(recipe);
+        let codeFilesExist = 1.0;
+        if (codeFiles.length > 0) {
+            const existCount = codeFiles.filter((f) => ctx.fileSet.has(f.toLowerCase())).length;
+            codeFilesExist = existCount / codeFiles.length;
+            if (codeFilesExist < 0.5) {
+                decayReasons.push(`codeChanges 文件存活 ${existCount}/${codeFiles.length}`);
+            }
+        }
+        // 加权计算 relevanceScore
+        const relevanceScore = Math.round((triggerStillMatches ? 1 : 0) * weights.triggerStillMatches * 100 +
+            symbolsAlive * weights.symbolsAlive * 100 +
+            (depsIntact ? 1 : 0) * weights.depsIntact * 100 +
+            codeFilesExist * weights.codeFilesExist * 100);
+        // 分级判定
+        let verdict;
+        if (relevanceScore >= 80) {
+            verdict = 'healthy';
+        }
+        else if (relevanceScore >= 60) {
+            verdict = 'watch';
+        }
+        else if (relevanceScore >= 40) {
+            verdict = 'decay';
+        }
+        else if (relevanceScore >= 20) {
+            verdict = 'severe';
+        }
+        else {
+            verdict = 'dead';
+        }
+        return {
+            recipeId: recipe.id,
+            title: recipe.title,
+            relevanceScore,
+            verdict,
+            evidence: {
+                triggerStillMatches,
+                symbolsAlive,
+                depsIntact,
+                codeFilesExist,
+            },
+            decayReasons,
+        };
+    }
+    /** 检查 trigger 模式是否仍有匹配文件 */
+    #checkTriggerMatch(trigger, fileList) {
+        if (!trigger || trigger.trim() === '') {
+            return true; // 无 trigger 视为匹配
+        }
+        const triggerLower = trigger.toLowerCase();
+        // 检查 @trigger 格式 (如 @bilidili-api-response-model)
+        // 这些是自定义 trigger，不与文件路径匹配，视为始终有效
+        if (triggerLower.startsWith('@')) {
+            return true;
+        }
+        // 检查文件扩展名匹配 (如 "When creating .swift files")
+        const extMatch = triggerLower.match(/\.(swift|ts|tsx|js|jsx|py|java|kt|rb|go|rs|vue|svelte)\b/);
+        if (extMatch) {
+            const ext = extMatch[0];
+            return fileList.some((f) => f.toLowerCase().endsWith(ext));
+        }
+        // 检查路径模式匹配 (如 "When modifying Packages/")
+        const pathPatterns = trigger.match(/(?:[\w.-]+\/)+[\w.-]*/g) || [];
+        if (pathPatterns.length > 0) {
+            return pathPatterns.some((pattern) => {
+                const p = pattern.toLowerCase();
+                return fileList.some((f) => f.toLowerCase().includes(p));
+            });
+        }
+        // 无法判断时视为匹配
+        return true;
+    }
+    /** 从 Recipe content 中提取引用的符号 */
+    #extractReferencedSymbols(recipe) {
+        const symbols = [];
+        // 从 content JSON 中提取
+        try {
+            const content = JSON.parse(recipe.content || '{}');
+            const pattern = content.pattern || '';
+            const markdown = content.markdown || '';
+            const text = `${pattern} ${markdown} ${recipe.doClause || ''} ${recipe.coreCode || ''}`;
+            // 匹配 PascalCase 标识符 (类名/协议名)
+            const identifiers = text.match(/\b[A-Z][a-zA-Z0-9]{2,}\b/g) || [];
+            // 去掉常见英文单词
+            const COMMON_WORDS = new Set([
+                'When',
+                'Then',
+                'The',
+                'This',
+                'That',
+                'Use',
+                'Not',
+                'All',
+                'For',
+                'With',
+                'From',
+                'Each',
+                'Must',
+                'May',
+                'Can',
+                'Will',
+                'Has',
+                'Are',
+                'New',
+                'Set',
+                'Get',
+                'Add',
+                'Run',
+                'End',
+                'Try',
+                'Nil',
+                'True',
+                'False',
+                'Void',
+                'Self',
+                'Type',
+                'Error',
+                'Result',
+                'String',
+                'Int',
+                'Bool',
+                'Array',
+                'Dict',
+                'Optional',
+                'Protocol',
+                'Class',
+                'Struct',
+                'Enum',
+                'Import',
+                'Return',
+                'Override',
+                'Private',
+                'Public',
+                'Internal',
+                'Func',
+                'Var',
+                'Let',
+                'Guard',
+                'Async',
+                'Await',
+                'Throws',
+                'Release',
+                'Debug',
+                'Swift',
+                'Function',
+                'Method',
+                'Property',
+                'Value',
+                'Default',
+                'Shared',
+                'Static',
+                'Final',
+                'Weak',
+                'Lazy',
+            ]);
+            for (const id of identifiers) {
+                if (!COMMON_WORDS.has(id) && id.length >= 3) {
+                    symbols.push(id);
+                }
+            }
+        }
+        catch {
+            /* invalid JSON */
+        }
+        // 去重
+        return [...new Set(symbols)];
+    }
+    /** 从 Recipe 中提取模块/依赖引用 */
+    #extractModuleReferences(recipe) {
+        const modules = [];
+        try {
+            const content = JSON.parse(recipe.content || '{}');
+            const text = `${content.markdown || ''} ${content.pattern || ''} ${recipe.doClause || ''}`;
+            // 匹配 import 语句中的模块名
+            const importMatches = text.match(/import\s+(\w+)/g) || [];
+            for (const m of importMatches) {
+                const name = m.replace(/^import\s+/, '');
+                if (name.length >= 2) {
+                    modules.push(name);
+                }
+            }
+        }
+        catch {
+            /* invalid JSON */
+        }
+        return [...new Set(modules)];
+    }
+    /** 从 Recipe 中提取 codeChanges 引用的文件路径 */
+    #extractCodeFiles(recipe) {
+        const files = [];
+        try {
+            const content = JSON.parse(recipe.content || '{}');
+            const codeChanges = content.codeChanges;
+            if (Array.isArray(codeChanges)) {
+                for (const change of codeChanges) {
+                    if (change.file) {
+                        files.push(change.file);
+                    }
+                }
+            }
+            // reasoning.sources 在 content 外层，由下方独立查询处理
+        }
+        catch {
+            /* invalid JSON */
+        }
+        // 也从 recipe 的 sourceFile 来源引用
+        try {
+            const row = this.#db
+                .prepare(`SELECT reasoning FROM knowledge_entries WHERE id = ?`)
+                .get(recipe.id);
+            if (row?.reasoning) {
+                const reasoning = JSON.parse(row.reasoning);
+                if (Array.isArray(reasoning.sources)) {
+                    for (const src of reasoning.sources) {
+                        if (typeof src === 'string') {
+                            files.push(src);
+                        }
+                        else if (src?.file) {
+                            files.push(src.file);
+                        }
+                        else if (src?.path) {
+                            files.push(src.path);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* invalid JSON */
+        }
+        return [...new Set(files)];
+    }
+    /** 执行衰退状态转换 */
+    #executeDecay(result) {
+        try {
+            const now = Date.now();
+            switch (result.verdict) {
+                case 'dead': {
+                    // 直接 deprecated，无需观察
+                    this.#db
+                        .prepare(`UPDATE knowledge_entries SET lifecycle = 'deprecated', updatedAt = ? WHERE id = ?`)
+                        .run(now, result.recipeId);
+                    // 记录已执行的 proposal（审计追溯）
+                    this.#createProposal({
+                        targetRecipeId: result.recipeId,
+                        type: 'deprecate',
+                        source: 'rescan-relevance-audit',
+                        status: 'executed',
+                        description: `[Rescan Relevance Audit] Score: ${result.relevanceScore}. ${result.decayReasons.join('; ')}`,
+                        evidence: { relevanceScore: result.relevanceScore, evidence: result.evidence },
+                        expiresAt: now,
+                    });
+                    this.#logger.info(`[RecipeRelevanceAuditor] DEAD: "${result.title}" → deprecated (score: ${result.relevanceScore})`);
+                    return true;
+                }
+                case 'severe': {
+                    // 加速衰退：3 天观察窗口
+                    this.#db
+                        .prepare(`UPDATE knowledge_entries SET lifecycle = 'decaying', updatedAt = ? WHERE id = ?`)
+                        .run(now, result.recipeId);
+                    this.#createProposal({
+                        targetRecipeId: result.recipeId,
+                        type: 'deprecate',
+                        source: 'rescan-relevance-audit',
+                        status: 'observing',
+                        description: `[Rescan Relevance Audit] Score: ${result.relevanceScore}. ${result.decayReasons.join('; ')}`,
+                        evidence: { relevanceScore: result.relevanceScore, evidence: result.evidence },
+                        expiresAt: now + GRACE_PERIOD_SEVERE,
+                    });
+                    this.#logger.info(`[RecipeRelevanceAuditor] SEVERE: "${result.title}" → decaying (3d grace, score: ${result.relevanceScore})`);
+                    return true;
+                }
+                case 'decay': {
+                    // 加速衰退：7 天观察窗口
+                    this.#db
+                        .prepare(`UPDATE knowledge_entries SET lifecycle = 'decaying', updatedAt = ? WHERE id = ?`)
+                        .run(now, result.recipeId);
+                    this.#createProposal({
+                        targetRecipeId: result.recipeId,
+                        type: 'deprecate',
+                        source: 'rescan-relevance-audit',
+                        status: 'observing',
+                        description: `[Rescan Relevance Audit] Score: ${result.relevanceScore}. ${result.decayReasons.join('; ')}`,
+                        evidence: { relevanceScore: result.relevanceScore, evidence: result.evidence },
+                        expiresAt: now + GRACE_PERIOD_DECAY,
+                    });
+                    this.#logger.info(`[RecipeRelevanceAuditor] DECAY: "${result.title}" → decaying (7d grace, score: ${result.relevanceScore})`);
+                    return true;
+                }
+                default:
+                    return false;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.#logger.warn(`[RecipeRelevanceAuditor] executeDecay failed for ${result.recipeId}: ${msg}`);
+            return false;
+        }
+    }
+    /** 创建 evolution proposal */
+    #createProposal(input) {
+        try {
+            const id = `ep-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+            this.#db
+                .prepare(`INSERT INTO evolution_proposals
+           (id, type, target_recipe_id, related_recipe_ids, confidence, source,
+            description, evidence, status, proposed_at, expires_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.type, input.targetRecipeId, '[]', 0.95, input.source, input.description, JSON.stringify([input.evidence]), input.status, Date.now(), input.expiresAt);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.#logger.warn(`[RecipeRelevanceAuditor] createProposal failed: ${msg}`);
+        }
+    }
+}

package/dist/lib/service/evolution/createSupersedeProposal.d.ts

@@ -0,0 +1,44 @@
+/**
+ * createSupersedeProposal — 统一的 supersede 提案创建逻辑
+ *
+ * 内部 Agent 路径 (lifecycle.ts / composite.ts) 和外部 MCP 路径 (consolidated.ts)
+ * 共用此函数，确保知识替代的进化架构入口唯一。
+ *
+ * 流程：
+ *   1. 从 DI 容器获取 ProposalRepository
+ *   2. 验证旧 Recipe 存在
+ *   3. 去重检查（ProposalRepository 内部）
+ *   4. 创建 type='supersede' 提案，进入 72h 观察窗口
+ */
+import type { ProposalSource } from '../../repository/evolution/ProposalRepository.js';
+/** 最小 DI 容器接口 — 兼容 ServiceContainer / McpServiceContainer / ToolHandlerContext.container */
+interface MinimalContainer {
+    get(name: string): unknown;
+}
+export interface SupersedeInput {
+    /** 被替代的旧 Recipe ID */
+    oldRecipeId: string;
+    /** 新提交的 Recipe ID 列表 */
+    newRecipeIds: string[];
+    /** 来源标识：'ide-agent' | 'metabolism' | 'decay-scan' */
+    source?: ProposalSource;
+    /** 置信度，默认 0.8 */
+    confidence?: number;
+}
+export interface SupersedeResult {
+    proposalId: string;
+    type: 'supersede';
+    targetRecipe: {
+        id: string;
+    };
+    status: string;
+    expiresAt: number;
+    message: string;
+}
+/**
+ * 在 DI 容器中查找 ProposalRepository，验证旧 Recipe 存在后创建 supersede 提案。
+ *
+ * @returns SupersedeResult（成功）| null（ProposalRepo 不可用 / 旧 Recipe 不存在 / 去重拒绝）
+ */
+export declare function createSupersedeProposal(container: MinimalContainer, input: SupersedeInput): SupersedeResult | null;
+export {};

package/dist/lib/service/evolution/createSupersedeProposal.js

@@ -0,0 +1,81 @@
+/**
+ * createSupersedeProposal — 统一的 supersede 提案创建逻辑
+ *
+ * 内部 Agent 路径 (lifecycle.ts / composite.ts) 和外部 MCP 路径 (consolidated.ts)
+ * 共用此函数，确保知识替代的进化架构入口唯一。
+ *
+ * 流程：
+ *   1. 从 DI 容器获取 ProposalRepository
+ *   2. 验证旧 Recipe 存在
+ *   3. 去重检查（ProposalRepository 内部）
+ *   4. 创建 type='supersede' 提案，进入 72h 观察窗口
+ */
+/* ────────────────────── Main ────────────────────── */
+/**
+ * 在 DI 容器中查找 ProposalRepository，验证旧 Recipe 存在后创建 supersede 提案。
+ *
+ * @returns SupersedeResult（成功）| null（ProposalRepo 不可用 / 旧 Recipe 不存在 / 去重拒绝）
+ */
+export function createSupersedeProposal(container, input) {
+    const { oldRecipeId, newRecipeIds, source = 'ide-agent', confidence = 0.8 } = input;
+    if (!oldRecipeId || newRecipeIds.length === 0) {
+        return null;
+    }
+    // 1. 获取 ProposalRepository
+    let proposalRepo = null;
+    try {
+        proposalRepo = container.get('proposalRepository') ?? null;
+    }
+    catch {
+        return null;
+    }
+    if (!proposalRepo) {
+        return null;
+    }
+    // 2. 验证旧 Recipe 存在
+    if (!verifyRecipeExists(container, oldRecipeId)) {
+        return null;
+    }
+    // 3. 创建 supersede 提案（ProposalRepository 内部做去重检查）
+    const proposal = proposalRepo.create({
+        type: 'supersede',
+        targetRecipeId: oldRecipeId,
+        relatedRecipeIds: newRecipeIds,
+        confidence,
+        source,
+        description: `Agent 声明新 Recipe [${newRecipeIds.join(', ')}] 替代旧 Recipe [${oldRecipeId}]。观察窗口内将对比新旧表现。`,
+        evidence: [
+            {
+                snapshotAt: Date.now(),
+                newRecipeIds,
+                declaredBy: source,
+            },
+        ],
+    });
+    if (!proposal) {
+        return null;
+    }
+    return {
+        proposalId: proposal.id,
+        type: 'supersede',
+        targetRecipe: { id: oldRecipeId },
+        status: proposal.status,
+        expiresAt: proposal.expiresAt,
+        message: `已创建替代提案：新 Recipe 将在观察窗口到期后自动替代旧 Recipe [${oldRecipeId}]。`,
+    };
+}
+/* ────────────────────── Helpers ────────────────────── */
+function verifyRecipeExists(container, recipeId) {
+    try {
+        const db = container.get('database');
+        if (!db) {
+            return false;
+        }
+        const rawDb = db.getDb();
+        const row = rawDb.prepare('SELECT id FROM knowledge_entries WHERE id = ?').get(recipeId);
+        return row !== undefined;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/service/guard/ComplianceReporter.d.ts

@@ -72,6 +72,10 @@ interface GuardCheckEngineLike {
             }[];
         };
     };
+    /** Enhancement Pack 注入（可选，引擎不一定暴露） */
+    isEpInjected?(): boolean;
+    injectExternalRules?(rules: unknown[]): void;
+    markEpInjected?(): void;
 }
 interface ViolationItem {
     ruleId: string;

package/dist/lib/service/guard/ComplianceReporter.js

@@ -82,6 +82,53 @@ export class ComplianceReporter {
             });
         }
     }
+    /**
+     * 确保 Enhancement Pack 规则已注入到 engine
+     * 与 MCP guard handler 的 _injectEnhancementGuardRules 逻辑一致
+     */
+    async #ensureEnhancementPackRules() {
+        if (!this.engine.isEpInjected || this.engine.isEpInjected()) {
+            return;
+        }
+        try {
+            const { initEnhancementRegistry } = await import('#core/enhancement/index.js');
+            const enhReg = await initEnhancementRegistry();
+            const allPacks = enhReg.all();
+            const allGuardRules = [];
+            for (const pack of allPacks) {
+                try {
+                    const rules = pack.getGuardRules();
+                    if (rules.length > 0) {
+                        allGuardRules.push(...rules);
+                    }
+                }
+                catch {
+                    /* graceful degradation per pack */
+                }
+            }
+            if (allGuardRules.length > 0 && this.engine.injectExternalRules) {
+                this.engine.injectExternalRules(allGuardRules);
+                this.logger.info(`[ComplianceReporter] Injected ${allGuardRules.length} Enhancement Pack rules`);
+            }
+            this.engine.markEpInjected?.();
+        }
+        catch {
+            /* Enhancement registry not available — non-critical */
+        }
+    }
+    /**
+     * 确保 AST 语言插件已加载（Tree-sitter WASM）
+     * 未加载时 _runAstLayer2Checks 会静默跳过，导致 AST 类违规无法检测
+     */
+    async #ensureAstPlugins() {
+        try {
+            const { loadPlugins } = await import('../../core/ast/index.js');
+            await loadPlugins();
+        }
+        catch {
+            /* AST not available — graceful degradation */
+        }
+    }
     /**
      * 生成全项目合规报告
      * @param projectRoot 项目根目录
@@ -91,6 +138,10 @@ export class ComplianceReporter {
     async generate(projectRoot, options = {}) {
         const thresholds = { ...this.qualityGateConfig, ...(options.qualityGate || {}) };
         const maxFiles = options.maxFiles || 500;
+        // 0. 确保 Enhancement Pack 规则已注入（与 MCP guard handler 保持一致）
+        await this.#ensureEnhancementPackRules();
+        // 0b. 确保 AST 语言插件已加载（Tree-sitter WASM）
+        await this.#ensureAstPlugins();
         // 1. 收集源文件
         const files = await collectSourceFilesWithContent(projectRoot, { maxFiles });
         this.logger.info(`[ComplianceReporter] Collected ${files.length} source files`);