autosnippet 3.3.4 → 3.3.5

package/dist/lib/external/mcp/handlers/consolidated.js

@@ -220,6 +220,7 @@ export async function enhancedSubmitKnowledge(ctx, args) {
     const source = args.source || 'mcp';
     const dimensionId = args.dimensionId;
     const clientId = args.client_id;
+    const supersedes = args.supersedes;
     // ── Step 1: 限流 ──
     const { checkRecipeSave } = await import('#http/middleware/RateLimiter.js');
     const { resolveProjectRoot } = await import('#shared/resolveProjectRoot.js');
@@ -283,6 +284,7 @@ export async function enhancedSubmitKnowledge(ctx, args) {
     // ── Step 3: 融合分析（统一对所有有效条目运行） ──
     const submittableItems = [];
     const blockedItems = [];
+    const createdProposals = [];
     if (skipConsolidation) {
         submittableItems.push(...validItems);
     }
@@ -307,11 +309,37 @@ export async function enhancedSubmitKnowledge(ctx, args) {
                     content: v.item.content,
                 }));
                 const batchAdvice = advisor.analyzeBatch(candidates);
+                // 尝试获取 ProposalRepository 以创建 Proposal（降级容忍）
+                let proposalRepo = null;
+                try {
+                    proposalRepo = ctx.container.get('proposalRepository') ?? null;
+                }
+                catch {
+                    /* ProposalRepository 未注册，降级为旧的 blocked 模式 */
+                }
                 for (const { index: adviceIdx, advice } of batchAdvice.items) {
                     const validEntry = validItems[adviceIdx];
                     if (advice.action === 'create') {
                         submittableItems.push(validEntry);
                     }
+                    else if (proposalRepo &&
+                        (advice.action === 'merge' ||
+                            advice.action === 'reorganize' ||
+                            advice.action === 'insufficient')) {
+                        // 创建 Proposal 而非简单 block — 系统后续自动处理
+                        const proposal = _createProposalFromAdvice(proposalRepo, advice, validEntry.item);
+                        if (proposal) {
+                            createdProposals.push(proposal);
+                        }
+                        else {
+                            // Proposal 创建失败（可能去重）→ 仍作为 blocked 返回
+                            blockedItems.push({
+                                index: validEntry.index,
+                                title: validEntry.item.title || '(untitled)',
+                                consolidation: advice,
+                            });
+                        }
+                    }
                     else {
                         blockedItems.push({
                             index: validEntry.index,
@@ -390,6 +418,63 @@ export async function enhancedSubmitKnowledge(ctx, args) {
             });
         }
     }
+    // ── Step 4b: Supersede 提案创建 ──
+    // 当 Agent 声明 supersedes 旧 Recipe 时，创建 supersede Proposal
+    if (supersedes && successIds.length > 0) {
+        let proposalRepo = null;
+        try {
+            proposalRepo = ctx.container.get('proposalRepository') ?? null;
+        }
+        catch {
+            /* ProposalRepository 未注册，跳过 */
+        }
+        if (proposalRepo) {
+            // 验证旧 Recipe 存在
+            const oldRecipeExists = (() => {
+                try {
+                    const db = ctx.container.get('database');
+                    if (!db) {
+                        return false;
+                    }
+                    const rawDb = db.getDb();
+                    const row = rawDb
+                        .prepare('SELECT id FROM knowledge_entries WHERE id = ?')
+                        .get(supersedes);
+                    return row !== undefined;
+                }
+                catch {
+                    return false;
+                }
+            })();
+            if (oldRecipeExists) {
+                const proposal = proposalRepo.create({
+                    type: 'supersede',
+                    targetRecipeId: supersedes,
+                    relatedRecipeIds: successIds,
+                    confidence: 0.8,
+                    source: 'ide-agent',
+                    description: `Agent 声明新 Recipe [${successIds.join(', ')}] 替代旧 Recipe [${supersedes}]。观察窗口内将对比新旧表现。`,
+                    evidence: [
+                        {
+                            snapshotAt: Date.now(),
+                            newRecipeIds: successIds,
+                            declaredBy: 'agent',
+                        },
+                    ],
+                });
+                if (proposal) {
+                    createdProposals.push({
+                        proposalId: proposal.id,
+                        type: 'supersede',
+                        targetRecipe: { id: supersedes, title: supersedes },
+                        status: proposal.status,
+                        expiresAt: proposal.expiresAt,
+                        message: `已创建替代提案：新 Recipe 将在观察窗口到期后自动替代旧 Recipe [${supersedes}]。`,
+                    });
+                }
+            }
+        }
+    }
     // ── Step 5: 构建统一响应 ──
     const data = {
         count: successCount,
@@ -417,6 +502,13 @@ export async function enhancedSubmitKnowledge(ctx, args) {
             message: `${blockedItems.length} 条因融合分析被阻塞（与已有 Recipe 重叠或实质性不足）。设 skipConsolidation: true 可跳过。`,
         };
     }
+    if (createdProposals.length > 0) {
+        data.proposals = createdProposals;
+        data.proposalSummary = {
+            proposalCount: createdProposals.length,
+            message: `${createdProposals.length} 条已创建进化提案，系统将在观察窗口到期后自动执行。无需额外操作。`,
+        };
+    }
     const allOk = successCount === items.length;
     return envelope({
         success: successCount > 0,
@@ -467,3 +559,89 @@ function _trackRejection(ctx, item, dimensionId) {
         /* best effort */
     }
 }
+// ── Proposal 创建辅助函数 ───────────────────────────
+/**
+ * 将 ConsolidationAdvisor 分析结果转为 evolution_proposals 记录。
+ *
+ * merge → Proposal(type: merge, target: 已有 Recipe)
+ * reorganize → Proposal(type: reorganize, 高风险 → pending 等开发者确认)
+ * insufficient → Proposal(type: enhance, target: 最相似 Recipe)
+ */
+function _createProposalFromAdvice(repo, advice, candidateItem) {
+    const evidence = [
+        {
+            snapshotAt: Date.now(),
+            candidateTitle: candidateItem.title,
+            candidateCategory: candidateItem.category,
+            analysisReason: advice.reason,
+            mergeDirection: advice.mergeDirection,
+        },
+    ];
+    if (advice.action === 'merge' && advice.targetRecipe) {
+        const proposal = repo.create({
+            type: 'merge',
+            targetRecipeId: advice.targetRecipe.id,
+            confidence: advice.confidence,
+            source: 'ide-agent',
+            description: advice.reason,
+            evidence,
+        });
+        if (!proposal) {
+            return null;
+        }
+        return {
+            proposalId: proposal.id,
+            type: 'merge',
+            targetRecipe: { id: advice.targetRecipe.id, title: advice.targetRecipe.title },
+            status: proposal.status,
+            expiresAt: proposal.expiresAt,
+            message: `已为「${advice.targetRecipe.title}」创建融合提案，${proposal.status === 'observing' ? '观察窗口 72h 后自动执行' : '等待开发者确认'}。`,
+        };
+    }
+    if (advice.action === 'reorganize' && advice.reorganizeTargets?.length) {
+        const target = advice.reorganizeTargets[0];
+        const proposal = repo.create({
+            type: 'reorganize',
+            targetRecipeId: target.id,
+            relatedRecipeIds: advice.reorganizeTargets.slice(1).map((t) => t.id),
+            confidence: advice.confidence,
+            source: 'ide-agent',
+            description: advice.reason,
+            evidence,
+        });
+        if (!proposal) {
+            return null;
+        }
+        return {
+            proposalId: proposal.id,
+            type: 'reorganize',
+            targetRecipe: { id: target.id, title: target.title },
+            status: proposal.status,
+            expiresAt: proposal.expiresAt,
+            message: `已为 ${advice.reorganizeTargets.length} 条 Recipe 创建重组提案，需开发者在 Dashboard 确认。`,
+        };
+    }
+    if (advice.action === 'insufficient' && advice.coveredBy?.length) {
+        const target = advice.coveredBy[0];
+        const proposal = repo.create({
+            type: 'enhance',
+            targetRecipeId: target.id,
+            confidence: advice.confidence,
+            source: 'ide-agent',
+            description: advice.reason,
+            evidence,
+        });
+        if (!proposal) {
+            return null;
+        }
+        return {
+            proposalId: proposal.id,
+            type: 'enhance',
+            targetRecipe: { id: target.id, title: target.title },
+            status: proposal.status,
+            expiresAt: proposal.expiresAt,
+            message: `候选独立价值不足，已创建增强提案建议补充到「${target.title}」。`,
+        };
+    }
+    return null;
+}

package/dist/lib/external/mcp/tools.js

@@ -147,8 +147,9 @@ export const TOOLS = [
         description: 'Submit knowledge entries (single/batch unified pipeline). Pass 1~N items via the items array.\n' +
             '• All entries undergo strict validation; all V3 fields must be provided at once\n' +
             '• Unified consolidation analysis: detects overlap with existing Recipes and batch candidates\n' +
-            '• Handle CONSOLIDATION_MERGE / CONSOLIDATION_REORGANIZE / CONSOLIDATION_INSUFFICIENT responses\n' +
+            '• Overlap detected → evolution proposal created automatically (merge/enhance/reorganize); system auto-executes after observation window\n' +
             '• Set skipConsolidation: true to skip consolidation check. content and reasoning must be objects.\n' +
+            '• Set supersedes: "old-recipe-id" to declare the new Recipe replaces an existing one (creates a supersede proposal with observation window).\n' +
             '⚠️ Batch rule: items in the array must NOT be cross-redundant — no highly overlapping doClause/coreCode/trigger within the same batch. ' +
             'If two entries share 80%+ content, merge into one or split into primary + extends supplementary entries.',
         inputSchema: zodToMcpSchema(SubmitKnowledgeInput),

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

@@ -65,7 +65,10 @@ export function register(c) {
     });
     c.singleton('knowledgeSyncService', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
-        return new KnowledgeSyncService(projectRoot);
+        const sourceRefReconciler = ct.singletons.sourceRefReconciler;
+        return new KnowledgeSyncService(projectRoot, {
+            sourceRefReconciler: sourceRefReconciler || undefined,
+        });
     });
     // ═══ ReportStore ═══
     c.singleton('reportStore', (ct) => {

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

@@ -13,18 +13,21 @@ 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 { ProposalRepository } from '../../repository/evolution/ProposalRepository.js';
 import { DimensionCopy } from '../../service/bootstrap/DimensionCopyRegistry.js';
 import { ConsolidationAdvisor } from '../../service/evolution/ConsolidationAdvisor.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 { 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 +132,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 +175,19 @@ 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('proposalExecutor', (ct) => {
+        const db = ct.get('database');
+        return new ProposalExecutor(db.getDb(), ct.get('proposalRepository'), {
+            signalBus: ct.singletons.signalBus || undefined,
         });
     });
     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;
+    }
+}