autosnippet 3.3.4 → 3.3.6

package/dist/lib/injection/modules/KnowledgeModule.js

@@ -7,24 +7,29 @@
  *   - discovererRegistry, enhancementRegistry, languageService, dimensionCopy
  *   - constitution, aiProvider, projectGraph
  */
+import { DimensionCopy } from '#domain/dimension/DimensionCopy.js';
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { getDiscovererRegistry } from '../../core/discovery/index.js';
 import { getEnhancementRegistry } from '../../core/enhancement/index.js';
 import { HnswVectorAdapter } from '../../infrastructure/vector/HnswVectorAdapter.js';
 import { IndexingPipeline } from '../../infrastructure/vector/IndexingPipeline.js';
 import { JsonVectorAdapter } from '../../infrastructure/vector/JsonVectorAdapter.js';
-import { DimensionCopy } from '../../service/bootstrap/DimensionCopyRegistry.js';
+import { ProposalRepository } from '../../repository/evolution/ProposalRepository.js';
 import { ConsolidationAdvisor } from '../../service/evolution/ConsolidationAdvisor.js';
+import { ContentPatcher } from '../../service/evolution/ContentPatcher.js';
 import { ContradictionDetector } from '../../service/evolution/ContradictionDetector.js';
 import { DecayDetector } from '../../service/evolution/DecayDetector.js';
 import { EnhancementSuggester } from '../../service/evolution/EnhancementSuggester.js';
 import { KnowledgeMetabolism } from '../../service/evolution/KnowledgeMetabolism.js';
+import { ProposalExecutor } from '../../service/evolution/ProposalExecutor.js';
+import { RecipeLifecycleSupervisor } from '../../service/evolution/RecipeLifecycleSupervisor.js';
 import { RedundancyAnalyzer } from '../../service/evolution/RedundancyAnalyzer.js';
 import { StagingManager } from '../../service/evolution/StagingManager.js';
 import { CodeEntityGraph } from '../../service/knowledge/CodeEntityGraph.js';
 import { ConfidenceRouter } from '../../service/knowledge/ConfidenceRouter.js';
 import { KnowledgeGraphService } from '../../service/knowledge/KnowledgeGraphService.js';
 import { KnowledgeService } from '../../service/knowledge/KnowledgeService.js';
+import { SourceRefReconciler } from '../../service/knowledge/SourceRefReconciler.js';
 import { HybridRetriever } from '../../service/search/HybridRetriever.js';
 import { SearchEngine } from '../../service/search/SearchEngine.js';
 import { LanguageService } from '../../shared/LanguageService.js';
@@ -129,6 +134,13 @@ export function register(c) {
     c.register('aiProvider', () => c.singletons.aiProvider || null);
     c.register('projectGraph', () => c.singletons.projectGraph || null);
     // ═══ Governance / Evolution ═══
+    c.singleton('sourceRefReconciler', (ct) => {
+        const db = ct.get('database');
+        const projectRoot = resolveProjectRoot();
+        return new SourceRefReconciler(projectRoot, db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
     c.singleton('stagingManager', (ct) => {
         const db = ct.get('database');
         return new StagingManager(db.getDb(), {
@@ -165,6 +177,31 @@ export function register(c) {
             redundancyAnalyzer: ct.get('redundancyAnalyzer'),
             decayDetector: ct.get('decayDetector'),
             signalBus: ct.singletons.signalBus || undefined,
+            proposalRepository: ct.services.proposalRepository
+                ? ct.get('proposalRepository')
+                : undefined,
+        });
+    });
+    c.singleton('proposalRepository', (ct) => {
+        const db = ct.get('database');
+        return new ProposalRepository(db.getDb());
+    });
+    c.singleton('contentPatcher', (ct) => {
+        const db = ct.get('database');
+        return new ContentPatcher(db.getDb());
+    });
+    c.singleton('lifecycleSupervisor', (ct) => {
+        const db = ct.get('database');
+        return new RecipeLifecycleSupervisor(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('proposalExecutor', (ct) => {
+        const db = ct.get('database');
+        return new ProposalExecutor(db.getDb(), ct.get('proposalRepository'), {
+            signalBus: ct.singletons.signalBus || undefined,
+            contentPatcher: ct.get('contentPatcher'),
+            supervisor: ct.get('lifecycleSupervisor'),
         });
     });
     c.singleton('consolidationAdvisor', (ct) => {

package/dist/lib/repository/evolution/ProposalRepository.d.ts

@@ -0,0 +1,99 @@
+/**
+ * ProposalRepository — evolution_proposals 表 CRUD
+ *
+ * 操作 evolution_proposals 表，存储进化提案（merge/supersede/enhance/deprecate/
+ * reorganize/contradiction/correction）。
+ *
+ * 设计要求：
+ *   - 去重：同 target + 同 type 不允许多个 observing 状态的 Proposal
+ *   - Rate Limit：同一 target 不允许同时存在多个相同类型的 observing Proposal
+ *   - JSON 字段（evidence/related_recipe_ids）序列化/反序列化
+ */
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+        get(...params: unknown[]): Record<string, unknown> | undefined;
+        run(...params: unknown[]): {
+            changes: number;
+        };
+    };
+}
+/** Proposal 类型 — 统一标准 */
+export type ProposalType = 'merge' | 'supersede' | 'enhance' | 'deprecate' | 'reorganize' | 'contradiction' | 'correction';
+/** Proposal 来源 */
+export type ProposalSource = 'ide-agent' | 'metabolism' | 'decay-scan';
+/** Proposal 状态 */
+export type ProposalStatus = 'pending' | 'observing' | 'executed' | 'rejected' | 'expired';
+/** evolution_proposals 行对象 */
+export interface ProposalRecord {
+    id: string;
+    type: ProposalType;
+    targetRecipeId: string;
+    relatedRecipeIds: string[];
+    confidence: number;
+    source: ProposalSource;
+    description: string;
+    evidence: Record<string, unknown>[];
+    status: ProposalStatus;
+    proposedAt: number;
+    expiresAt: number;
+    resolvedAt: number | null;
+    resolvedBy: string | null;
+    resolution: string | null;
+}
+/** 创建 Proposal 输入 */
+export interface CreateProposalInput {
+    type: ProposalType;
+    targetRecipeId: string;
+    relatedRecipeIds?: string[];
+    confidence: number;
+    source: ProposalSource;
+    description: string;
+    evidence?: Record<string, unknown>[];
+    status?: ProposalStatus;
+    expiresAt?: number;
+}
+/** 查询过滤器 */
+export interface ProposalFilter {
+    status?: ProposalStatus | ProposalStatus[];
+    type?: ProposalType;
+    targetRecipeId?: string;
+    source?: ProposalSource;
+    expiredBefore?: number;
+}
+export declare class ProposalRepository {
+    #private;
+    constructor(db: DatabaseLike);
+    /**
+     * 创建 Proposal 并写入 DB。
+     *
+     * - 自动生成 ID（ep-{timestamp}-{random}）
+     * - 自动设定 expiresAt（按 type 默认窗口）
+     * - 自动判断 status（低风险 + 高置信度 → observing，否则 pending）
+     * - 去重：同 target + 同 type 已有 pending/observing 时拒绝创建
+     */
+    create(input: CreateProposalInput): ProposalRecord | null;
+    /** 按 ID 查询 */
+    findById(id: string): ProposalRecord | null;
+    /** 按条件查询 */
+    find(filter?: ProposalFilter): ProposalRecord[];
+    /** 查询已到期的 observing 状态 Proposal */
+    findExpiredObserving(): ProposalRecord[];
+    /** 查询所有未完成的 Proposal（pending + observing） */
+    findActive(): ProposalRecord[];
+    /** 按 target Recipe ID 查询活跃 Proposal */
+    findByTarget(targetRecipeId: string): ProposalRecord[];
+    /** 将 Proposal 状态转为 observing */
+    startObserving(id: string): boolean;
+    /** 标记 Proposal 为已执行 */
+    markExecuted(id: string, resolution: string, resolvedBy?: string): boolean;
+    /** 标记 Proposal 为已拒绝 */
+    markRejected(id: string, resolution: string, resolvedBy?: string): boolean;
+    /** 标记 Proposal 为过期 */
+    markExpired(id: string): boolean;
+    /** 更新 evidence（用于追加观察期指标快照） */
+    updateEvidence(id: string, evidence: Record<string, unknown>[]): boolean;
+    /** 统计各状态的 Proposal 数量 */
+    stats(): Record<ProposalStatus, number>;
+}
+export {};

package/dist/lib/repository/evolution/ProposalRepository.js

@@ -0,0 +1,255 @@
+/**
+ * ProposalRepository — evolution_proposals 表 CRUD
+ *
+ * 操作 evolution_proposals 表，存储进化提案（merge/supersede/enhance/deprecate/
+ * reorganize/contradiction/correction）。
+ *
+ * 设计要求：
+ *   - 去重：同 target + 同 type 不允许多个 observing 状态的 Proposal
+ *   - Rate Limit：同一 target 不允许同时存在多个相同类型的 observing Proposal
+ *   - JSON 字段（evidence/related_recipe_ids）序列化/反序列化
+ */
+import { randomBytes } from 'node:crypto';
+/* ────────────────────── Constants ────────────────────── */
+/** 默认观察窗口：7 天 */
+const DEFAULT_OBSERVATION_WINDOW = 7 * 24 * 60 * 60 * 1000;
+/** 各 Proposal 类型的默认观察窗口（ms） */
+const OBSERVATION_WINDOWS = {
+    enhance: 48 * 60 * 60 * 1000, // 48h
+    correction: 24 * 60 * 60 * 1000, // 24h
+    merge: 72 * 60 * 60 * 1000, // 72h
+    supersede: 72 * 60 * 60 * 1000, // 72h
+    deprecate: 7 * 24 * 60 * 60 * 1000, // 7d
+    contradiction: 7 * 24 * 60 * 60 * 1000, // 7d
+    reorganize: 7 * 24 * 60 * 60 * 1000, // 7d
+};
+/** 自动进入观察状态的置信度阈值 */
+const AUTO_OBSERVE_THRESHOLDS = {
+    enhance: 0.7,
+    correction: 0.7,
+    merge: 0.75,
+    supersede: 0.8,
+    deprecate: 0.0, // decayScore ≤ 40 即可
+    contradiction: Infinity, // 需开发者确认
+    reorganize: Infinity, // 需开发者确认
+};
+/* ────────────────────── Class ────────────────────── */
+export class ProposalRepository {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    /* ═══════════════════ Create ═══════════════════ */
+    /**
+     * 创建 Proposal 并写入 DB。
+     *
+     * - 自动生成 ID（ep-{timestamp}-{random}）
+     * - 自动设定 expiresAt（按 type 默认窗口）
+     * - 自动判断 status（低风险 + 高置信度 → observing，否则 pending）
+     * - 去重：同 target + 同 type 已有 pending/observing 时拒绝创建
+     */
+    create(input) {
+        const now = Date.now();
+        // 去重检查
+        if (this.#hasDuplicate(input.targetRecipeId, input.type)) {
+            return null;
+        }
+        const id = ProposalRepository.#generateId(now);
+        const expiresAt = input.expiresAt ?? now + (OBSERVATION_WINDOWS[input.type] ?? DEFAULT_OBSERVATION_WINDOW);
+        const status = input.status ?? this.#resolveInitialStatus(input.type, input.confidence);
+        const record = {
+            id,
+            type: input.type,
+            targetRecipeId: input.targetRecipeId,
+            relatedRecipeIds: input.relatedRecipeIds ?? [],
+            confidence: input.confidence,
+            source: input.source,
+            description: input.description,
+            evidence: input.evidence ?? [],
+            status,
+            proposedAt: now,
+            expiresAt,
+            resolvedAt: null,
+            resolvedBy: null,
+            resolution: null,
+        };
+        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(record.id, record.type, record.targetRecipeId, JSON.stringify(record.relatedRecipeIds), record.confidence, record.source, record.description, JSON.stringify(record.evidence), record.status, record.proposedAt, record.expiresAt);
+        return record;
+    }
+    /* ═══════════════════ Read ═══════════════════ */
+    /** 按 ID 查询 */
+    findById(id) {
+        const row = this.#db.prepare(`SELECT * FROM evolution_proposals WHERE id = ?`).get(id);
+        return row ? ProposalRepository.#mapRow(row) : null;
+    }
+    /** 按条件查询 */
+    find(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.status) {
+            if (Array.isArray(filter.status)) {
+                const placeholders = filter.status.map(() => '?').join(', ');
+                conditions.push(`status IN (${placeholders})`);
+                params.push(...filter.status);
+            }
+            else {
+                conditions.push('status = ?');
+                params.push(filter.status);
+            }
+        }
+        if (filter.type) {
+            conditions.push('type = ?');
+            params.push(filter.type);
+        }
+        if (filter.targetRecipeId) {
+            conditions.push('target_recipe_id = ?');
+            params.push(filter.targetRecipeId);
+        }
+        if (filter.source) {
+            conditions.push('source = ?');
+            params.push(filter.source);
+        }
+        if (filter.expiredBefore) {
+            conditions.push('expires_at <= ?');
+            params.push(filter.expiredBefore);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = this.#db
+            .prepare(`SELECT * FROM evolution_proposals ${where} ORDER BY proposed_at DESC`)
+            .all(...params);
+        return rows.map(ProposalRepository.#mapRow);
+    }
+    /** 查询已到期的 observing 状态 Proposal */
+    findExpiredObserving() {
+        return this.find({
+            status: 'observing',
+            expiredBefore: Date.now(),
+        });
+    }
+    /** 查询所有未完成的 Proposal（pending + observing） */
+    findActive() {
+        return this.find({
+            status: ['pending', 'observing'],
+        });
+    }
+    /** 按 target Recipe ID 查询活跃 Proposal */
+    findByTarget(targetRecipeId) {
+        return this.find({
+            targetRecipeId,
+            status: ['pending', 'observing'],
+        });
+    }
+    /* ═══════════════════ Update ═══════════════════ */
+    /** 将 Proposal 状态转为 observing */
+    startObserving(id) {
+        const now = Date.now();
+        const proposal = this.findById(id);
+        if (!proposal || proposal.status !== 'pending') {
+            return false;
+        }
+        const expiresAt = now + (OBSERVATION_WINDOWS[proposal.type] ?? DEFAULT_OBSERVATION_WINDOW);
+        const result = this.#db
+            .prepare(`UPDATE evolution_proposals SET status = 'observing', expires_at = ? WHERE id = ? AND status = 'pending'`)
+            .run(expiresAt, id);
+        return result.changes > 0;
+    }
+    /** 标记 Proposal 为已执行 */
+    markExecuted(id, resolution, resolvedBy = 'auto') {
+        const result = this.#db
+            .prepare(`UPDATE evolution_proposals SET status = 'executed', resolved_at = ?, resolved_by = ?, resolution = ? WHERE id = ? AND status = 'observing'`)
+            .run(Date.now(), resolvedBy, resolution, id);
+        return result.changes > 0;
+    }
+    /** 标记 Proposal 为已拒绝 */
+    markRejected(id, resolution, resolvedBy = 'auto') {
+        const result = this.#db
+            .prepare(`UPDATE evolution_proposals SET status = 'rejected', resolved_at = ?, resolved_by = ?, resolution = ? WHERE id = ? AND status IN ('pending', 'observing')`)
+            .run(Date.now(), resolvedBy, resolution, id);
+        return result.changes > 0;
+    }
+    /** 标记 Proposal 为过期 */
+    markExpired(id) {
+        const result = this.#db
+            .prepare(`UPDATE evolution_proposals SET status = 'expired', resolved_at = ? WHERE id = ? AND status IN ('pending', 'observing')`)
+            .run(Date.now(), id);
+        return result.changes > 0;
+    }
+    /** 更新 evidence（用于追加观察期指标快照） */
+    updateEvidence(id, evidence) {
+        const result = this.#db
+            .prepare(`UPDATE evolution_proposals SET evidence = ? WHERE id = ?`)
+            .run(JSON.stringify(evidence), id);
+        return result.changes > 0;
+    }
+    /* ═══════════════════ Stats ═══════════════════ */
+    /** 统计各状态的 Proposal 数量 */
+    stats() {
+        const rows = this.#db
+            .prepare(`SELECT status, COUNT(*) as count FROM evolution_proposals GROUP BY status`)
+            .all();
+        const result = {
+            pending: 0,
+            observing: 0,
+            executed: 0,
+            rejected: 0,
+            expired: 0,
+        };
+        for (const row of rows) {
+            result[row.status] = row.count;
+        }
+        return result;
+    }
+    /* ═══════════════════ Private ═══════════════════ */
+    /** 去重检查：同 target + 同 type 是否已有 pending/observing Proposal */
+    #hasDuplicate(targetRecipeId, type) {
+        const row = this.#db
+            .prepare(`SELECT 1 FROM evolution_proposals WHERE target_recipe_id = ? AND type = ? AND status IN ('pending', 'observing') LIMIT 1`)
+            .get(targetRecipeId, type);
+        return row !== undefined;
+    }
+    /** 根据 type + confidence 判断初始状态 */
+    #resolveInitialStatus(type, confidence) {
+        const threshold = AUTO_OBSERVE_THRESHOLDS[type];
+        return confidence >= threshold ? 'observing' : 'pending';
+    }
+    /** 生成 Proposal ID */
+    static #generateId(timestamp) {
+        const rand = randomBytes(4).toString('hex');
+        return `ep-${timestamp}-${rand}`;
+    }
+    /** DB 行 → ProposalRecord */
+    static #mapRow(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            targetRecipeId: row.target_recipe_id,
+            relatedRecipeIds: safeJsonParse(row.related_recipe_ids, []),
+            confidence: row.confidence,
+            source: row.source,
+            description: row.description,
+            evidence: safeJsonParse(row.evidence, []),
+            status: row.status,
+            proposedAt: row.proposed_at,
+            expiresAt: row.expires_at,
+            resolvedAt: row.resolved_at ?? null,
+            resolvedBy: row.resolved_by ?? null,
+            resolution: row.resolution ?? null,
+        };
+    }
+}
+/* ────────────────────── Util ────────────────────── */
+function safeJsonParse(json, fallback) {
+    if (!json) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/lib/repository/knowledge/KnowledgeRepository.impl.d.ts

@@ -40,6 +40,10 @@ export declare class KnowledgeRepositoryImpl extends BaseRepository {
      * ★ Drizzle 类型安全 INSERT — 列名拼写编译期检查
      */
     create(entry: KnowledgeEntry): Promise<unknown>;
+    /**
+     * 按标题精确查找（大小写不敏感）
+     */
+    findByTitle(title: string): Promise<KnowledgeEntry | null>;
     /**
      * 更新 KnowledgeEntry（接受完整实体或部分数据）
      * ★ Drizzle 类型安全 UPDATE

package/dist/lib/repository/knowledge/KnowledgeRepository.impl.js

@@ -1,4 +1,4 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import { inferKind, KnowledgeEntry } from '../../domain/knowledge/index.js';
 import { getDrizzle } from '../../infrastructure/database/drizzle/index.js';
 import { knowledgeEntries } from '../../infrastructure/database/drizzle/schema.js';
@@ -45,6 +45,21 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             throw error;
         }
     }
+    /**
+     * 按标题精确查找（大小写不敏感）
+     */
+    async findByTitle(title) {
+        const rows = this.#drizzle
+            .select()
+            .from(knowledgeEntries)
+            .where(sql `lower(${knowledgeEntries.title}) = lower(${title})`)
+            .limit(1)
+            .all();
+        if (rows.length === 0) {
+            return null;
+        }
+        return this._rowToEntity(rows[0]);
+    }
     /**
      * 更新 KnowledgeEntry（接受完整实体或部分数据）
      * ★ Drizzle 类型安全 UPDATE

package/dist/lib/service/bootstrap/BootstrapEventEmitter.d.ts

@@ -6,6 +6,7 @@
  *
  * @module shared/BootstrapEventEmitter
  */
+import type { DimensionCompletePayload, ProgressPayload } from './bootstrap-event-types.js';
 export declare class BootstrapEventEmitter {
     #private;
     /** @param container DI Container */
@@ -23,7 +24,7 @@ export declare class BootstrapEventEmitter {
      * @param [data.skillCreated] 是否生成了 Skill
      * @param [data.recipesBound] 关联的 recipe 数量
      */
-    emitDimensionComplete(dimId: string, data?: Record<string, unknown>): void;
+    emitDimensionComplete(dimId: string, data: DimensionCompletePayload): void;
     /**
      * 推送全部维度完成事件
      *
@@ -51,6 +52,6 @@ export declare class BootstrapEventEmitter {
      * @param event 事件名
      * @param data 事件数据
      */
-    emitProgress(event: string, data?: Record<string, unknown>): void;
+    emitProgress(event: string, data?: ProgressPayload): void;
 }
 export default BootstrapEventEmitter;

package/dist/lib/service/bootstrap/BootstrapEventEmitter.js

@@ -39,7 +39,7 @@ export class BootstrapEventEmitter {
      * @param [data.skillCreated] 是否生成了 Skill
      * @param [data.recipesBound] 关联的 recipe 数量
      */
-    emitDimensionComplete(dimId, data = {}) {
+    emitDimensionComplete(dimId, data) {
         // TaskManager 标记
         try {
             this.#taskManager?.markTaskCompleted?.(dimId, data);

package/dist/lib/service/bootstrap/DeliveryVerifier.d.ts

@@ -0,0 +1,51 @@
+/**
+ * DeliveryVerifier — Bootstrap/Rescan 完成后交付完整性检查
+ *
+ * 验证以下交付物是否正确生成:
+ *   - Channel A: autosnippet-project-rules.mdc
+ *   - Channel B: autosnippet-patterns 系列文件
+ *   - Channel C: .cursor/skills/ 目录
+ *   - Channel F: AGENTS.md, CLAUDE.md, copilot-instructions.md
+ *   - Wiki: meta.json
+ *   - Skills: project 级 Skill 目录
+ *   - 向量索引: asvec 文件
+ *
+ * @module service/bootstrap/DeliveryVerifier
+ */
+/** §10.5 交付通道标识 */
+export type DeliveryChannel = 'channelA' | 'channelB' | 'channelC' | 'channelF' | 'wiki' | 'skills' | 'vectorIndex';
+/** 单通道验证结果 */
+export interface ChannelVerification {
+    generated: boolean;
+    file?: string;
+    files?: string[];
+    count?: number;
+    size?: number;
+    skillCount?: number;
+    pageCount?: number;
+    documentCount?: number;
+    agentsMd?: boolean;
+    claudeMd?: boolean;
+    copilotInstructions?: boolean;
+    rebuilt?: boolean;
+}
+/** 完整验证结果 */
+export interface DeliveryVerification {
+    channelA: ChannelVerification;
+    channelB: ChannelVerification;
+    channelC: ChannelVerification;
+    channelF: ChannelVerification;
+    wiki: ChannelVerification;
+    skills: ChannelVerification;
+    vectorIndex: ChannelVerification;
+    allPassed: boolean;
+    failures: string[];
+}
+export declare class DeliveryVerifier {
+    #private;
+    constructor(projectRoot: string);
+    /**
+     * 验证所有交付物是否正确生成
+     */
+    verify(): DeliveryVerification;
+}