autosnippet 3.3.5 → 3.3.7

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`);

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

@@ -678,13 +678,14 @@ export class GuardCheckEngine {
         }
         // 如果有 scope，按层级过滤：project ⊇ target ⊇ file
         // project 范围包含所有维度的规则；target 包含 file+target；file 仅匹配 file
+        // 'universal' 维度在所有 scope 下都生效
         if (scope) {
             const SCOPE_HIERARCHY = {
-                project: ['file', 'target', 'project'],
-                target: ['file', 'target'],
-                file: ['file'],
+                project: ['file', 'target', 'project', 'universal'],
+                target: ['file', 'target', 'universal'],
+                file: ['file', 'universal'],
             };
-            const allowedDimensions = SCOPE_HIERARCHY[scope] || [scope];
+            const allowedDimensions = SCOPE_HIERARCHY[scope] || [scope, 'universal'];
             rules = rules.filter((r) => !r.dimension || allowedDimensions.includes(r.dimension));
         }
         const lines = (code || '').split(/\r?\n/);

package/dist/lib/service/knowledge/CodeEntityGraph.d.ts

@@ -85,6 +85,12 @@ interface DepGraphNode {
     id?: string;
     label?: string;
     type?: string;
+    layer?: string;
+    version?: string;
+    group?: string;
+    fullPath?: string;
+    indirect?: boolean;
+    [key: string]: unknown;
 }
 interface DepGraphData {
     nodes?: (DepGraphNode | string)[];

package/dist/lib/service/knowledge/CodeEntityGraph.js

@@ -169,10 +169,26 @@ export class CodeEntityGraph {
                     name: nodeObj.label || nodeObj.id || String(node),
                     metadata: {
                         nodeType: nodeObj.type || 'module',
+                        ...(nodeObj.layer != null ? { layer: nodeObj.layer } : {}),
+                        ...(nodeObj.version != null ? { version: nodeObj.version } : {}),
+                        ...(nodeObj.group != null ? { group: nodeObj.group } : {}),
+                        ...(nodeObj.fullPath != null ? { fullPath: nodeObj.fullPath } : {}),
+                        ...(nodeObj.indirect != null ? { indirect: nodeObj.indirect } : {}),
                     },
                 });
                 entities++;
             }
+            // 存储 layers 元数据（如果存在）到特殊实体
+            const layers = depGraphData.layers;
+            if (layers?.length) {
+                this.#upsertEntity({
+                    entityId: '__config_layers__',
+                    entityType: 'config',
+                    name: 'Config Layers',
+                    metadata: { layers },
+                });
+                entities++;
+            }
         });
         run();
         const result = { entitiesUpserted: entities, edgesCreated: 0, durationMs: Date.now() - t0 };

package/dist/lib/service/knowledge/ConfidenceRouter.js

@@ -20,7 +20,7 @@ const DEFAULT_CONFIG = {
     /** 自动通过要求 reasoning.isValid() */
     requireReasoning: true,
     /** 来源白名单（这些来源可以适用更宽松的阈值） */
-    trustedSources: ['bootstrap', 'cursor-scan'],
+    trustedSources: ['bootstrap', 'cursor-scan', 'mcp'],
     /** 可信来源的自动通过阈值 */
     trustedAutoApproveThreshold: 0.7,
     /** 极高置信度阈值 (≥0.90 → 24h Grace) */

package/dist/lib/service/knowledge/KnowledgeService.d.ts

@@ -105,8 +105,16 @@ export declare class KnowledgeService {
     _triggerCursorDeliveryAsync(): void;
     /** 弃用 (pending|active → deprecated) */
     deprecate(id: string, reason: string, context: ServiceContext): Promise<KnowledgeEntry>;
-    /** 重新激活 (deprecated → pending) */
+    /** 重新激活 (deprecated|staging → pending) */
     reactivate(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
+    /** 进入暂存期 (pending → staging) */
+    stage(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
+    /** 进入进化态 (active → evolving) */
+    evolve(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
+    /** 进入衰退观察 (active|evolving → decaying) */
+    decay(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
+    /** 恢复为已发布 (decaying|evolving → active) */
+    restore(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
     /** @deprecated 简化后所有条目直接进 pending */
     submit(id: string, _context: ServiceContext): Promise<KnowledgeEntry>;
     /** @deprecated 简化后 approve = publish */
@@ -171,6 +179,8 @@ export declare class KnowledgeService {
     _syncRelationsToGraph(id: string, relations: unknown): void;
     /** 删除所有关联边 */
     _removeAllEdges(id: string): void;
+    /** 删除关联的 evolution_proposals（target_recipe_id 无 CASCADE） */
+    _removeRelatedProposals(id: string): void;
     /** 落盘到 .md 文件 + 回写 sourceFile */
     _persistToFile(entry: KnowledgeEntry): void;
     /** 删除 .md 文件 */

package/dist/lib/service/knowledge/KnowledgeService.js

@@ -49,6 +49,13 @@ export class KnowledgeService {
     async create(data, context) {
         try {
             this._validateCreateInput(data);
+            // ── 标题去重：防止跨维度/跨调用创建同名条目 ──
+            if (data.title) {
+                const existing = await this.repository.findByTitle(data.title);
+                if (existing) {
+                    throw new ConflictError(`Knowledge entry with title "${data.title}" already exists (id: ${existing.id})`, { existingId: existing.id, title: data.title });
+                }
+            }
             const entry = KnowledgeEntry.fromJSON({
                 ...data,
                 lifecycle: Lifecycle.PENDING,
@@ -280,6 +287,8 @@ export class KnowledgeService {
             this._removeFile(entry);
             // 清除 knowledge_edges
             this._removeAllEdges(id);
+            // 清除 evolution_proposals（无 ON DELETE CASCADE，需手动删除）
+            this._removeRelatedProposals(id);
             await this.repository.delete(id);
             await this._audit('delete_knowledge', id, context.userId, {
                 title: entry.title,
@@ -340,10 +349,26 @@ export class KnowledgeService {
             entityArgs: [reason],
         });
     }
-    /** 重新激活 (deprecated → pending) */
+    /** 重新激活 (deprecated|staging → pending) */
     async reactivate(id, context) {
         return this._lifecycleTransition(id, 'reactivate', context);
     }
+    /** 进入暂存期 (pending → staging) */
+    async stage(id, context) {
+        return this._lifecycleTransition(id, 'stage', context);
+    }
+    /** 进入进化态 (active → evolving) */
+    async evolve(id, context) {
+        return this._lifecycleTransition(id, 'evolve', context);
+    }
+    /** 进入衰退观察 (active|evolving → decaying) */
+    async decay(id, context) {
+        return this._lifecycleTransition(id, 'decay', context);
+    }
+    /** 恢复为已发布 (decaying|evolving → active) */
+    async restore(id, context) {
+        return this._lifecycleTransition(id, 'restore', context);
+    }
     // ── 向后兼容别名 ──
     /** @deprecated 简化后所有条目直接进 pending */
     async submit(id, _context) {
@@ -495,17 +520,28 @@ export class KnowledgeService {
             // 为 QualityScorer 适配输入字段
             const scorerInput = this._adaptForScorer(entry);
             const result = this._qualityScorer.score(scorerInput);
-            // 更新 Quality 值对象
-            await this.repository.update(id, {
-                quality: JSON.stringify({
-                    completeness: result.dimensions.completeness,
-                    adaptation: result.dimensions.metadata,
-                    documentation: result.dimensions.format,
-                    overall: result.score,
-                    grade: result.grade,
-                }),
+            // 更新 Quality 值对象；同步计算 authority（0‑5）
+            const qualityJson = {
+                completeness: result.dimensions.completeness,
+                adaptation: result.dimensions.metadata,
+                documentation: result.dimensions.format,
+                overall: result.score,
+                grade: result.grade,
+            };
+            // 当 authority 从未手动设置（仍为 0）时，从 quality.overall 自动推导
+            const currentAuthority = entry.stats?.authority ?? 0;
+            const updatePayload = {
+                quality: JSON.stringify(qualityJson),
                 updatedAt: Math.floor(Date.now() / 1000),
-            });
+            };
+            if (currentAuthority === 0 && result.score > 0) {
+                const statsObj = entry.stats?.toJSON?.() ?? (typeof entry.stats === 'object' ? { ...entry.stats } : {});
+                updatePayload.stats = JSON.stringify({
+                    ...statsObj,
+                    authority: Math.round(result.score * 5),
+                });
+            }
+            await this.repository.update(id, updatePayload);
             if (context.userId) {
                 await this._audit('update_knowledge_quality', id, context.userId, {
                     score: result.score,
@@ -540,6 +576,8 @@ export class KnowledgeService {
                     detail: `Lifecycle ${method} failed for ${id}`,
                 });
             }
+            // 标记操作人到最后一条 lifecycleHistory 条目
+            entry.stampLastTransition(context.userId);
             // 构建 DB 更新
             // 注意: 不在此处 JSON.stringify — repository.update() 内部
             // 通过 _entityToRow() 统一执行序列化, 传入原始值即可
@@ -555,9 +593,8 @@ export class KnowledgeService {
             if (entry.reviewedAt) {
                 dbUpdates.reviewedAt = entry.reviewedAt;
             }
-            if (entry.rejectionReason !== null) {
-                dbUpdates.rejectionReason = entry.rejectionReason;
-            }
+            // 驳回原因（含清除：reactivate 后 rejectionReason = null 需写入 DB）
+            dbUpdates.rejectionReason = entry.rejectionReason;
             // 发布字段
             if (entry.publishedAt) {
                 dbUpdates.publishedAt = entry.publishedAt;
@@ -781,6 +818,22 @@ export class KnowledgeService {
             });
         }
     }
+    /** 删除关联的 evolution_proposals（target_recipe_id 无 CASCADE） */
+    _removeRelatedProposals(id) {
+        const gs = this._knowledgeGraphService;
+        if (!gs) {
+            return;
+        }
+        try {
+            gs.db.prepare(`DELETE FROM evolution_proposals WHERE target_recipe_id = ?`).run(id);
+        }
+        catch (err) {
+            this.logger.warn('Failed to remove related proposals', {
+                id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     /* ═══ 文件落盘 ═════════════════════════════════ */
     /** 落盘到 .md 文件 + 回写 sourceFile */
     _persistToFile(entry) {

package/dist/lib/service/knowledge/RecipeProductionGateway.d.ts

@@ -0,0 +1,225 @@
+/**
+ * RecipeProductionGateway — 统一 Recipe 生产入口
+ *
+ * 所有 Recipe 创建（Agent Tool / MCP / IDE Agent / Batch Import）
+ * 通过此 Gateway 的统一管道，保证前置校验一致：
+ *
+ *   1. Schema Validation (UnifiedValidator)
+ *   2. Similarity Check — 去重检测（可选跳过）
+ *   3. Consolidation Scan — 融合/重组建议（可选）
+ *   4. KnowledgeService.create() — 包含 ConfidenceRouter → staging / pending
+ *   5. Quality Scoring — 质量评分
+ *   6. Supersede Proposal — 创建替代提案
+ *   7. Audit — 统一审计
+ *
+ * @see docs/copilot/recipe-lifecycle-management.md §6
+ */
+/** Lightweight log interface — avoids importing static-only Logger class. */
+interface GatewayLogger {
+    info(msg: string): void;
+    warn(msg: string): void;
+}
+export type GatewaySource = 'agent-tool' | 'mcp-external' | 'ide-agent' | 'batch-import';
+export interface CreateRecipeItem {
+    title?: string;
+    description?: string;
+    content?: {
+        markdown?: string;
+        pattern?: string;
+        rationale?: string;
+        [key: string]: unknown;
+    };
+    trigger?: string;
+    kind?: string;
+    topicHint?: string;
+    whenClause?: string;
+    doClause?: string;
+    dontClause?: string;
+    coreCode?: string;
+    sourceRefs?: string[];
+    tags?: string[];
+    reasoning?: {
+        whyStandard?: string;
+        sources?: string[];
+        confidence?: number;
+    };
+    headers?: string[];
+    usageGuide?: string;
+    scope?: string;
+    complexity?: string;
+    sourceFile?: string;
+    knowledgeType?: string;
+    language?: string;
+    category?: string;
+    source?: string;
+    [key: string]: unknown;
+}
+export interface CreateRecipeRequest {
+    source: GatewaySource;
+    items: CreateRecipeItem[];
+    options?: {
+        /** 跳过相似度检测（仅 batch-import 可用） */
+        skipSimilarityCheck?: boolean;
+        /** 跳过 ConsolidationAdvisor 分析 */
+        skipConsolidation?: boolean;
+        /** 被替代的旧 Recipe ID */
+        supersedes?: string;
+        /** 相似度阈值，默认 0.7 */
+        similarityThreshold?: number;
+        /** 已提交标题集（批量去重用） */
+        existingTitles?: Set<string>;
+        /** 已提交指纹集（批量去重用） */
+        existingFingerprints?: Set<string>;
+        /** UnifiedValidator 跳过系统注入字段列表 */
+        systemInjectedFields?: string[];
+        /** 跳过唯一性校验 */
+        skipUniqueness?: boolean;
+        /** 操作用户 ID */
+        userId?: string;
+    };
+}
+export interface CreatedRecipeInfo {
+    id: string;
+    title: string;
+    lifecycle: string;
+    /** Raw saved entry from KnowledgeService.create() */
+    raw: Record<string, unknown>;
+}
+export interface RejectedRecipeInfo {
+    index: number;
+    title: string;
+    reason: string;
+    errors: string[];
+    warnings: string[];
+}
+export interface MergedRecipeInfo {
+    index: number;
+    proposalId: string;
+    type: string;
+    targetRecipeId: string;
+    targetTitle: string;
+    status: string;
+    expiresAt: number;
+    message: string;
+}
+export interface BlockedRecipeInfo {
+    index: number;
+    title: string;
+    consolidation: unknown;
+}
+export interface SimilarRecipeInfo {
+    index: number;
+    title: string;
+    similarTo: {
+        file: string;
+        title: string;
+        similarity: number;
+    }[];
+}
+export interface CreateRecipeResult {
+    created: CreatedRecipeInfo[];
+    rejected: RejectedRecipeInfo[];
+    merged: MergedRecipeInfo[];
+    blocked: BlockedRecipeInfo[];
+    duplicates: SimilarRecipeInfo[];
+    supersedeProposal: {
+        proposalId: string;
+    } | null;
+}
+interface GatewayKnowledgeService {
+    create(data: Record<string, unknown>, context: {
+        userId: string;
+    }): Promise<{
+        id: string;
+        title: string;
+        lifecycle: string;
+        kind?: string;
+        [key: string]: unknown;
+    }>;
+    updateQuality(id: string, context: {
+        userId: string;
+    }): Promise<unknown>;
+}
+interface GatewayConsolidationAdvisor {
+    analyzeBatch(candidates: Array<{
+        title: string;
+        category?: string;
+        [key: string]: unknown;
+    }>): {
+        items: Array<{
+            index: number;
+            advice: {
+                action: string;
+                confidence: number;
+                reason: string;
+                targetRecipe?: {
+                    id: string;
+                    title: string;
+                    similarity: number;
+                };
+                reorganizeTargets?: {
+                    id: string;
+                    title: string;
+                    similarity: number;
+                }[];
+                coveredBy?: {
+                    id: string;
+                    title: string;
+                    similarity: number;
+                }[];
+                mergeDirection?: {
+                    addedDimensions: string[];
+                    summary: string;
+                };
+            };
+        }>;
+    };
+}
+interface GatewayProposalRepository {
+    create(data: Record<string, unknown>): {
+        id: string;
+        status: string;
+        expiresAt: number;
+        [key: string]: unknown;
+    } | null;
+}
+type GatewaySimilarityFn = (projectRoot: string, candidate: {
+    title: string;
+    summary: string;
+    code: string;
+}, opts: {
+    threshold: number;
+    topK: number;
+}) => {
+    file: string;
+    title: string;
+    similarity: number;
+}[];
+export interface GatewayDeps {
+    knowledgeService: GatewayKnowledgeService;
+    projectRoot: string;
+    logger?: GatewayLogger;
+    /** ConsolidationAdvisor（可选 — MCP 路径使用） */
+    consolidationAdvisor?: GatewayConsolidationAdvisor | null;
+    /** ProposalRepository（可选 — supersede 提案需要） */
+    proposalRepository?: GatewayProposalRepository | null;
+    /** 相似度检测函数（可选 — 默认导入 SimilarityService） */
+    findSimilarRecipes?: GatewaySimilarityFn | null;
+}
+export declare class RecipeProductionGateway {
+    #private;
+    constructor(deps: GatewayDeps);
+    /**
+     * 统一创建入口
+     *
+     * Pipeline:
+     *   1. Schema Validation (UnifiedValidator)
+     *   2. Similarity Check (除非 skipSimilarityCheck)
+     *   3. Consolidation Scan (除非 skipConsolidation)
+     *   4. KnowledgeService.create() — ConfidenceRouter → staging / pending
+     *   5. Quality Scoring
+     *   6. Supersede Proposal 创建 (if supersedes)
+     */
+    create(request: CreateRecipeRequest): Promise<CreateRecipeResult>;
+}
+export {};