autosnippet 3.3.0 → 3.3.3

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

@@ -0,0 +1,73 @@
+/**
+ * ReverseGuard — Recipe→Code 反向验证
+ *
+ * 正向: 代码 → Guard → "代码是否符合知识？"  ✅ 已有
+ * 反向: Recipe → Guard → "知识是否还符合代码？" ← 本文件
+ *
+ * 对每条 active rule Recipe:
+ *   1. 提取 coreCode 中的 API 引用（类名、方法名）
+ *   2. 在 code_entities 表中查找这些符号
+ *   3. 符号不存在 → PatternDrift
+ *   4. 提取 guard regex pattern → 对项目代码运行匹配
+ *   5. 匹配率骤降 → 代码模式正在迁移
+ */
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+        get(...params: unknown[]): Record<string, unknown> | undefined;
+    };
+}
+export type DriftType = 'symbol_missing' | 'match_rate_drop' | 'api_deprecated' | 'zero_match';
+export type DriftSeverity = 'high' | 'medium' | 'low';
+export interface PatternDriftSignal {
+    type: DriftType;
+    detail: string;
+    severity: DriftSeverity;
+    evidence: {
+        expectedSymbol?: string;
+        matchRate?: {
+            current: number;
+            historical: number;
+        };
+    };
+}
+export type ReverseRecommendation = 'healthy' | 'investigate' | 'decay';
+export interface ReverseGuardResult {
+    recipeId: string;
+    title: string;
+    signals: PatternDriftSignal[];
+    recommendation: ReverseRecommendation;
+}
+interface RecipeRow {
+    id: string;
+    title: string;
+    core_code: string | null;
+    guard_pattern: string | null;
+    stats: string | null;
+}
+export declare class ReverseGuard {
+    #private;
+    constructor(db: DatabaseLike, options?: {
+        signalBus?: SignalBus;
+    });
+    /**
+     * 对一条 Recipe 执行反向验证
+     */
+    checkRecipe(recipe: RecipeRow, projectFiles: {
+        path: string;
+        content: string;
+    }[]): ReverseGuardResult;
+    /**
+     * 批量对所有 active rule Recipes 执行反向验证
+     */
+    auditAllRules(projectFiles: {
+        path: string;
+        content: string;
+    }[]): ReverseGuardResult[];
+    /**
+     * 获取需要调查/衰退的 Recipe 结果
+     */
+    getDriftResults(results: ReverseGuardResult[]): ReverseGuardResult[];
+}
+export {};

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

@@ -0,0 +1,256 @@
+/**
+ * ReverseGuard — Recipe→Code 反向验证
+ *
+ * 正向: 代码 → Guard → "代码是否符合知识？"  ✅ 已有
+ * 反向: Recipe → Guard → "知识是否还符合代码？" ← 本文件
+ *
+ * 对每条 active rule Recipe:
+ *   1. 提取 coreCode 中的 API 引用（类名、方法名）
+ *   2. 在 code_entities 表中查找这些符号
+ *   3. 符号不存在 → PatternDrift
+ *   4. 提取 guard regex pattern → 对项目代码运行匹配
+ *   5. 匹配率骤降 → 代码模式正在迁移
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+/* ────────────────────── 常量 ────────────────────── */
+/** 从 coreCode 中提取符号引用的正则（多语言通用） */
+const SYMBOL_PATTERNS = [
+    // ClassName.method / ClassName.shared / ClassName() — Swift/Java/Kotlin/TS/Dart/C#
+    /\b([A-Z][A-Za-z0-9_]+)\s*[.(]/g,
+    // [ClassName method] — ObjC 消息发送
+    /\[\s*([A-Z][A-Za-z0-9_]+)\s+\w/g,
+    // import/from 引用 — JS/TS/Python/Dart/Go
+    /(?:import|from)\s+['"]([^'"]+)['"]/g,
+    // #import / #include — ObjC/C/C++ 头文件引用
+    /^\s*#(?:import|include)\s+[<"]([^>"]+)[>"]/gm,
+    // package.function / module::Type — Go/Rust 限定名
+    /\b([a-z][a-z0-9_]+(?:::[A-Z][A-Za-z0-9_]+|\.[A-Z][A-Za-z0-9_]+))/g,
+    // @decorator — Python/TS decorator 引用
+    /@([A-Z][A-Za-z0-9_]+)/g,
+];
+/** 定义多少条 drift signal 算 investigate / decay */
+const DRIFT_THRESHOLDS = {
+    /** ≥1 high → investigate */
+    INVESTIGATE_HIGH: 1,
+    /** ≥2 high → decay */
+    DECAY_HIGH: 2,
+    /** ≥3 medium → investigate */
+    INVESTIGATE_MEDIUM: 3,
+};
+/* ────────────────────── Class ────────────────────── */
+export class ReverseGuard {
+    #db;
+    #signalBus;
+    #logger = Logger.getInstance();
+    constructor(db, options = {}) {
+        this.#db = db;
+        this.#signalBus = options.signalBus ?? null;
+    }
+    /**
+     * 对一条 Recipe 执行反向验证
+     */
+    checkRecipe(recipe, projectFiles) {
+        const signals = [];
+        // 1. 检查 coreCode 中引用的符号是否还存在于代码库
+        if (recipe.core_code) {
+            signals.push(...this.#checkSymbolExistence(recipe.core_code));
+        }
+        // 2. 检查 guard pattern 在项目代码中的匹配率
+        if (recipe.guard_pattern) {
+            signals.push(...this.#checkPatternMatchRate(recipe.id, recipe.guard_pattern, projectFiles));
+        }
+        // 3. 综合判定
+        const recommendation = this.#computeRecommendation(signals);
+        // 4. 发射信号
+        if (this.#signalBus && signals.length > 0) {
+            const severity = recommendation === 'decay' ? 1 : recommendation === 'investigate' ? 0.5 : 0;
+            this.#signalBus.send('quality', 'ReverseGuard', severity, {
+                target: recipe.id,
+                metadata: {
+                    signalCount: signals.length,
+                    recommendation,
+                    driftTypes: [...new Set(signals.map((s) => s.type))],
+                },
+            });
+        }
+        return {
+            recipeId: recipe.id,
+            title: recipe.title,
+            signals,
+            recommendation,
+        };
+    }
+    /**
+     * 批量对所有 active rule Recipes 执行反向验证
+     */
+    auditAllRules(projectFiles) {
+        const recipes = this.#loadActiveRuleRecipes();
+        const results = [];
+        for (const recipe of recipes) {
+            try {
+                results.push(this.checkRecipe(recipe, projectFiles));
+            }
+            catch (err) {
+                this.#logger.debug(`ReverseGuard: failed to check recipe ${recipe.id}: ${err.message}`);
+            }
+        }
+        return results;
+    }
+    /**
+     * 获取需要调查/衰退的 Recipe 结果
+     */
+    getDriftResults(results) {
+        return results.filter((r) => r.recommendation !== 'healthy');
+    }
+    /* ── 内部方法 ── */
+    #loadActiveRuleRecipes() {
+        try {
+            const rows = this.#db
+                .prepare(`SELECT id, title,
+                json_extract(content, '$.coreCode') AS core_code,
+                json_extract(content, '$.pattern') AS guard_pattern,
+                stats
+         FROM knowledge_entries
+         WHERE lifecycle = 'active'
+           AND kind = 'rule'`)
+                .all();
+            return rows.map((r) => ({
+                id: r.id,
+                title: r.title,
+                core_code: r.core_code ?? null,
+                guard_pattern: r.guard_pattern ?? null,
+                stats: r.stats ?? null,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 检查 coreCode 中引用的符号是否存在于 code_entities 表
+     */
+    #checkSymbolExistence(coreCode) {
+        const symbols = this.#extractSymbols(coreCode);
+        if (symbols.size === 0) {
+            return [];
+        }
+        const signals = [];
+        for (const symbol of symbols) {
+            try {
+                const row = this.#db
+                    .prepare(`SELECT name FROM code_entities WHERE name = ? LIMIT 1`)
+                    .get(symbol);
+                if (!row) {
+                    signals.push({
+                        type: 'symbol_missing',
+                        detail: `Symbol "${symbol}" referenced in recipe coreCode not found in codebase`,
+                        severity: 'high',
+                        evidence: { expectedSymbol: symbol },
+                    });
+                }
+            }
+            catch {
+                // code_entities 表不存在时静默跳过
+                break;
+            }
+        }
+        return signals;
+    }
+    /**
+     * 检查 guard pattern 在项目代码中的匹配情况
+     */
+    #checkPatternMatchRate(recipeId, guardPattern, projectFiles) {
+        let re;
+        try {
+            re = new RegExp(guardPattern, 'gm');
+        }
+        catch {
+            return []; // 无效正则，不产出 drift（由 UncertaintyCollector 处理）
+        }
+        // 统计当前匹配数
+        let currentMatches = 0;
+        for (const file of projectFiles) {
+            const matches = file.content.match(re);
+            if (matches) {
+                currentMatches += matches.length;
+            }
+        }
+        // 获取历史匹配率（从 stats.guardHits 推断）
+        const historicalHits = this.#getHistoricalHits(recipeId);
+        const signals = [];
+        if (currentMatches === 0 && projectFiles.length > 0) {
+            // 完全匹配不到 — 场景已不存在
+            signals.push({
+                type: 'zero_match',
+                detail: `Guard pattern matches 0 times across ${projectFiles.length} files — scenario may no longer exist`,
+                severity: 'high',
+                evidence: {
+                    matchRate: { current: 0, historical: historicalHits },
+                },
+            });
+        }
+        else if (historicalHits > 0 && currentMatches > 0) {
+            // 匹配率大幅下降
+            const dropRatio = currentMatches / historicalHits;
+            if (dropRatio < 0.3) {
+                signals.push({
+                    type: 'match_rate_drop',
+                    detail: `Guard pattern match count dropped significantly: ${currentMatches} current vs ${historicalHits} historical (${Math.round(dropRatio * 100)}%)`,
+                    severity: 'medium',
+                    evidence: {
+                        matchRate: { current: currentMatches, historical: historicalHits },
+                    },
+                });
+            }
+        }
+        return signals;
+    }
+    #extractSymbols(coreCode) {
+        const symbols = new Set();
+        for (const pattern of SYMBOL_PATTERNS) {
+            // 重置 lastIndex（全局正则需要重置）
+            const re = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = re.exec(coreCode)) !== null) {
+                const symbol = match[1];
+                if (!symbol || symbol.length < 3) {
+                    continue;
+                }
+                // 过滤纯小写短词（if/for/var 等关键词），但允许含大写、含分隔符（::/.）、含路径分隔符（/）的符号
+                if (/^[a-z]+$/.test(symbol) && symbol.length < 6) {
+                    continue;
+                }
+                symbols.add(symbol);
+            }
+        }
+        return symbols;
+    }
+    #getHistoricalHits(recipeId) {
+        try {
+            const row = this.#db
+                .prepare(`SELECT json_extract(stats, '$.guardHits') AS hits FROM knowledge_entries WHERE id = ?`)
+                .get(recipeId);
+            return row?.hits ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    #computeRecommendation(signals) {
+        if (signals.length === 0) {
+            return 'healthy';
+        }
+        const highCount = signals.filter((s) => s.severity === 'high').length;
+        const mediumCount = signals.filter((s) => s.severity === 'medium').length;
+        if (highCount >= DRIFT_THRESHOLDS.DECAY_HIGH) {
+            return 'decay';
+        }
+        if (highCount >= DRIFT_THRESHOLDS.INVESTIGATE_HIGH) {
+            return 'investigate';
+        }
+        if (mediumCount >= DRIFT_THRESHOLDS.INVESTIGATE_MEDIUM) {
+            return 'investigate';
+        }
+        return 'healthy';
+    }
+}

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

@@ -3,6 +3,7 @@
  * 追踪规则触发与用户反馈，计算 P/R/F1，识别高误报规则并给出优化建议
  * 持久化到 AutoSnippet/guard-learner.json（Git 友好）
  */
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
 interface RuleStat {
     triggers: number;
     correct: number;
@@ -17,6 +18,7 @@ export declare class RuleLearner {
     constructor(projectRoot: string, options?: {
         knowledgeBaseDir?: string;
         internalDir?: string;
+        signalBus?: SignalBus;
     });
     /**
      * 记录规则触发
@@ -82,5 +84,15 @@ export declare class RuleLearner {
         recommendation: string;
         daysSinceFirstTrigger: number;
     };
+    /**
+     * RuleLearner→Recipe 桥接: 检查是否有高误报规则需要触发衰退
+     * 当 FP > 40% && triggers >= minTriggers 时，发射衰退信号到 SignalBus
+     * @returns 需要衰退检查的规则列表
+     */
+    checkPrecisionDrop(): {
+        ruleId: string;
+        falsePositiveRate: number;
+        recommendation: string;
+    }[];
 }
 export {};

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

@@ -16,12 +16,14 @@ const PROBLEMATIC_THRESHOLD = {
 export class RuleLearner {
     #learnerPath;
     #data;
+    #signalBus;
     constructor(projectRoot, options = {}) {
         const kbDir = options.knowledgeBaseDir || DEFAULT_KNOWLEDGE_BASE_DIR;
         this.#learnerPath = join(projectRoot, kbDir, 'guard-learner.json');
         pathGuard.assertProjectWriteSafe(this.#learnerPath);
         this.#migrateOldPath(projectRoot, options.internalDir || '.autosnippet');
         this.#data = this.#load();
+        this.#signalBus = options.signalBus || null;
     }
     /**
      * 记录规则触发
@@ -51,6 +53,14 @@ export class RuleLearner {
         }
         stat.lastFeedback = new Date().toISOString();
         this.#save();
+        // ── Signal: quality feedback ──
+        if (this.#signalBus) {
+            const metrics = this.getMetrics(ruleId);
+            this.#signalBus.send('quality', 'RuleLearner', 1 - metrics.falsePositiveRate, {
+                target: ruleId,
+                metadata: { feedbackType, precision: metrics.precision },
+            });
+        }
     }
     /**
      * 获取规则精准度指标
@@ -227,6 +237,34 @@ export class RuleLearner {
             daysSinceFirstTrigger: Math.round(daysSinceFirstTrigger),
         };
     }
+    /**
+     * RuleLearner→Recipe 桥接: 检查是否有高误报规则需要触发衰退
+     * 当 FP > 40% && triggers >= minTriggers 时，发射衰退信号到 SignalBus
+     * @returns 需要衰退检查的规则列表
+     */
+    checkPrecisionDrop() {
+        const problematic = this.getProblematicRules();
+        const results = [];
+        for (const p of problematic) {
+            results.push({
+                ruleId: p.ruleId,
+                falsePositiveRate: p.metrics.falsePositiveRate,
+                recommendation: p.recommendation,
+            });
+            // 发射衰退信号
+            if (this.#signalBus) {
+                this.#signalBus.send('quality', 'RuleLearner.precisionDrop', p.metrics.falsePositiveRate, {
+                    target: p.ruleId,
+                    metadata: {
+                        recommendation: p.recommendation,
+                        precision: p.metrics.precision,
+                        triggers: p.metrics.triggers,
+                    },
+                });
+            }
+        }
+        return results;
+    }
     // ─── 私有 ─────────────────────────────────────────────
     #ensureStat(ruleId) {
         if (!this.#data.ruleStats[ruleId]) {

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

@@ -0,0 +1,83 @@
+/**
+ * UncertaintyCollector — Guard uncertain 三态收集器
+ *
+ * 当 Guard 各层检测遇到能力边界（AST 不可用、跨文件缺失、正则冲突等）时，
+ * 收集 skip 原因并产出结构化的 uncertain 结果。
+ *
+ * 设计原则:
+ *   - uncertain 不是"错误"，是"承认能力边界"
+ *   - Guard 不调用 AI，uncertain 是确定性输出
+ *   - 保持 <10ms 性能
+ */
+export type SkipLayer = 'regex' | 'code_level' | 'ast' | 'cross_file';
+export type SkipReason = 'invalid_regex' | 'lang_unsupported' | 'ast_unavailable' | 'file_missing' | 'scope_mismatch' | 'layer_conflict';
+export type SkipImpact = 'high' | 'medium' | 'low';
+export interface SkippedCheck {
+    layer: SkipLayer;
+    ruleId?: string;
+    reason: SkipReason;
+    detail: string;
+    impact: SkipImpact;
+}
+export type BoundaryType = 'ast_language_gap' | 'cross_file_incomplete' | 'rule_regex_invalid' | 'scope_unchecked' | 'transitive_cycle';
+export interface CapabilityBoundary {
+    type: BoundaryType;
+    description: string;
+    affectedRules: string[];
+    suggestedAction: string;
+}
+export interface UncertainResult {
+    ruleId: string;
+    message: string;
+    layer: SkipLayer;
+    reason: SkipReason;
+    detail: string;
+}
+export interface GuardCapabilityReport {
+    executedChecks: {
+        regex: {
+            total: number;
+            executed: number;
+            skipped: number;
+        };
+        codeLevel: {
+            total: number;
+            executed: number;
+            skipped: number;
+        };
+        ast: {
+            total: number;
+            executed: number;
+            skipped: number;
+        };
+        crossFile: {
+            total: number;
+            executed: number;
+            skipped: number;
+        };
+    };
+    skippedChecks: SkippedCheck[];
+    boundaries: CapabilityBoundary[];
+    uncertainResults: UncertainResult[];
+    checkCoverage: number;
+}
+export declare class UncertaintyCollector {
+    #private;
+    /** 记录某个规则在某层被跳过 */
+    recordSkip(layer: SkipLayer, reason: SkipReason, detail: string, options?: {
+        ruleId?: string;
+        impact?: SkipImpact;
+    }): void;
+    /** 追加一条 uncertain 结果 */
+    addUncertain(ruleId: string, message: string, layer: SkipLayer, reason: SkipReason, detail: string): void;
+    /** 记录各层的检查总数和执行数 */
+    recordLayerStats(layer: SkipLayer, total: number, executed: number): void;
+    /** 生成能力报告 */
+    buildReport(): GuardCapabilityReport;
+    /** 获取 uncertain 结果数量 */
+    get uncertainCount(): number;
+    /** 获取 skipped 总数 */
+    get skippedCount(): number;
+    /** 重置状态（供多文件审计复用） */
+    reset(): void;
+}

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

@@ -0,0 +1,149 @@
+/**
+ * UncertaintyCollector — Guard uncertain 三态收集器
+ *
+ * 当 Guard 各层检测遇到能力边界（AST 不可用、跨文件缺失、正则冲突等）时，
+ * 收集 skip 原因并产出结构化的 uncertain 结果。
+ *
+ * 设计原则:
+ *   - uncertain 不是"错误"，是"承认能力边界"
+ *   - Guard 不调用 AI，uncertain 是确定性输出
+ *   - 保持 <10ms 性能
+ */
+/* ────────────────────── Collector ────────────────────── */
+export class UncertaintyCollector {
+    #skippedChecks = [];
+    #uncertainResults = [];
+    #layerCounts = {
+        regex: { total: 0, executed: 0, skipped: 0 },
+        codeLevel: { total: 0, executed: 0, skipped: 0 },
+        ast: { total: 0, executed: 0, skipped: 0 },
+        crossFile: { total: 0, executed: 0, skipped: 0 },
+    };
+    /** 记录某个规则在某层被跳过 */
+    recordSkip(layer, reason, detail, options = {}) {
+        const impact = options.impact ?? this.#inferImpact(layer, reason);
+        this.#skippedChecks.push({
+            layer,
+            ruleId: options.ruleId,
+            reason,
+            detail,
+            impact,
+        });
+        const key = layer === 'code_level' ? 'codeLevel' : layer === 'cross_file' ? 'crossFile' : layer;
+        this.#layerCounts[key].skipped++;
+    }
+    /** 追加一条 uncertain 结果 */
+    addUncertain(ruleId, message, layer, reason, detail) {
+        this.#uncertainResults.push({ ruleId, message, layer, reason, detail });
+    }
+    /** 记录各层的检查总数和执行数 */
+    recordLayerStats(layer, total, executed) {
+        const key = layer === 'code_level' ? 'codeLevel' : layer === 'cross_file' ? 'crossFile' : layer;
+        this.#layerCounts[key].total += total;
+        this.#layerCounts[key].executed += executed;
+    }
+    /** 生成能力报告 */
+    buildReport() {
+        const boundaries = this.#detectBoundaries();
+        const totalChecks = this.#layerCounts.regex.total +
+            this.#layerCounts.codeLevel.total +
+            this.#layerCounts.ast.total +
+            this.#layerCounts.crossFile.total;
+        const executedChecks = this.#layerCounts.regex.executed +
+            this.#layerCounts.codeLevel.executed +
+            this.#layerCounts.ast.executed +
+            this.#layerCounts.crossFile.executed;
+        const checkCoverage = totalChecks > 0 ? Math.round((executedChecks / totalChecks) * 100) : 100;
+        return {
+            executedChecks: { ...this.#layerCounts },
+            skippedChecks: [...this.#skippedChecks],
+            boundaries,
+            uncertainResults: [...this.#uncertainResults],
+            checkCoverage,
+        };
+    }
+    /** 获取 uncertain 结果数量 */
+    get uncertainCount() {
+        return this.#uncertainResults.length;
+    }
+    /** 获取 skipped 总数 */
+    get skippedCount() {
+        return this.#skippedChecks.length;
+    }
+    /** 重置状态（供多文件审计复用） */
+    reset() {
+        this.#skippedChecks = [];
+        this.#uncertainResults = [];
+        this.#layerCounts = {
+            regex: { total: 0, executed: 0, skipped: 0 },
+            codeLevel: { total: 0, executed: 0, skipped: 0 },
+            ast: { total: 0, executed: 0, skipped: 0 },
+            crossFile: { total: 0, executed: 0, skipped: 0 },
+        };
+    }
+    /* ── 内部 ── */
+    #inferImpact(layer, reason) {
+        // AST 和跨文件中的结构化检查更重要
+        if (layer === 'ast' && reason === 'ast_unavailable') {
+            return 'high';
+        }
+        if (layer === 'cross_file' && reason === 'file_missing') {
+            return 'medium';
+        }
+        if (reason === 'invalid_regex') {
+            return 'medium';
+        }
+        if (reason === 'layer_conflict') {
+            return 'high';
+        }
+        return 'low';
+    }
+    #detectBoundaries() {
+        const boundaries = [];
+        // 按层+原因分组
+        const groups = new Map();
+        for (const skip of this.#skippedChecks) {
+            const key = `${skip.layer}:${skip.reason}`;
+            const list = groups.get(key) || [];
+            list.push(skip);
+            groups.set(key, list);
+        }
+        for (const [key, skips] of groups) {
+            const [layer, reason] = key.split(':');
+            const affectedRules = [...new Set(skips.map((s) => s.ruleId).filter(Boolean))];
+            if (reason === 'ast_unavailable') {
+                boundaries.push({
+                    type: 'ast_language_gap',
+                    description: `AST 检查因 tree-sitter 不可用被跳过 (${skips.length} 条规则)`,
+                    affectedRules,
+                    suggestedAction: '确认 tree-sitter 支持该语言，或降级为正则匹配',
+                });
+            }
+            else if (reason === 'file_missing' && layer === 'cross_file') {
+                boundaries.push({
+                    type: 'cross_file_incomplete',
+                    description: `跨文件检查因文件缺失被跳过 (${skips.length} 次)`,
+                    affectedRules,
+                    suggestedAction: '确保审计时传入完整文件列表',
+                });
+            }
+            else if (reason === 'invalid_regex') {
+                boundaries.push({
+                    type: 'rule_regex_invalid',
+                    description: `${skips.length} 条规则的正则表达式编译失败`,
+                    affectedRules,
+                    suggestedAction: '修复或替换无效的正则表达式',
+                });
+            }
+            else if (reason === 'layer_conflict') {
+                boundaries.push({
+                    type: 'scope_unchecked',
+                    description: `${skips.length} 个检查结果因层间冲突存疑`,
+                    affectedRules,
+                    suggestedAction: '人工审核冲突规则',
+                });
+            }
+        }
+        return boundaries;
+    }
+}

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

@@ -36,6 +36,7 @@ export declare class ViolationsStore {
     constructor(db: DatabaseLike, drizzle?: DrizzleDB);
     /**
      * 追加一次 Guard 运行记录
+     * ★ 去重：同一文件、同一违规集合不重复入库，仅更新时间戳
      * ★ Drizzle 类型安全 INSERT + raw SQL 截断
      */
     appendRun(run: RunInput): string;