autosnippet 3.3.3 → 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/handlers/task.js

@@ -44,6 +44,10 @@ const _taskRules = {
  * Unified entry point
  */
 export async function taskHandler(ctx, args) {
+    // Normalize taskId → id (schema accepts both for convenience)
+    if (!args.id && typeof args.taskId === 'string') {
+        args.id = args.taskId;
+    }
     let result;
     switch (args.operation) {
         case 'prime':
@@ -88,11 +92,20 @@ async function _prime(ctx, args) {
     if (pipeline && extracted.queries[0]?.trim()) {
         try {
             searchResult = await pipeline.search(extracted);
+            if (!searchResult) {
+                process.stderr.write('[MCP/Task] prime: pipeline.search returned null (all filtered)\n');
+            }
         }
-        catch {
-            // search failure is non-fatal
+        catch (err) {
+            process.stderr.write(`[MCP/Task] prime search error: ${err instanceof Error ? err.stack || err.message : String(err)}\n`);
         }
     }
+    else if (!pipeline) {
+        process.stderr.write('[MCP/Task] prime: pipeline is null, skipping search\n');
+    }
+    else {
+        process.stderr.write(`[MCP/Task] prime: queries empty, skipping search. queries=${JSON.stringify(extracted.queries)}\n`);
+    }
     // ─── Lifecycle: initialize IntentState ───
     const freshIntent = createIdleIntent();
     freshIntent.phase = 'active';
@@ -175,14 +188,16 @@ async function _create(ctx, args) {
 }
 // ═══ close ══════════════════════════════════════════════
 async function _close(ctx, args) {
-    if (!args.id) {
+    const intent = ctx.session?.intent;
+    // Resolve id: explicit arg > session intent > fail
+    const id = args.id || (intent?.taskId ?? '');
+    if (!id) {
         return envelope({
             success: false,
-            message: 'id is required',
+            message: 'id is required (pass id or ensure a task was created in this session)',
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const intent = ctx.session?.intent;
     const reason = args.reason || 'Completed';
     // Persist intent chain via SignalBus
     if (intent && intent.phase === 'active') {
@@ -192,13 +207,13 @@ async function _close(ctx, args) {
     if (ctx.session) {
         ctx.session.intent = createIdleIntent();
     }
-    const lines = [`✅ Closed: ${args.id} — ${reason}`];
+    const lines = [`✅ Closed: ${id} — ${reason}`];
     lines.push('');
     lines.push('⚠️ REQUIRED: You MUST call autosnippet_guard (no args) NOW to review changed files for compliance violations.');
     return envelope({
         success: true,
         data: {
-            closed: { id: args.id, reason, closedAt: Date.now() },
+            closed: { id, reason, closedAt: Date.now() },
             nextAction: {
                 tool: 'autosnippet_guard',
                 args: {},
@@ -212,14 +227,16 @@ async function _close(ctx, args) {
 }
 // ═══ fail ═══════════════════════════════════════════════
 async function _fail(ctx, args) {
-    if (!args.id) {
+    const intent = ctx.session?.intent;
+    // Resolve id: explicit arg > session intent > fail
+    const id = args.id || (intent?.taskId ?? '');
+    if (!id) {
         return envelope({
             success: false,
-            message: 'id is required',
+            message: 'id is required (pass id or ensure a task was created in this session)',
             meta: { tool: 'autosnippet_task' },
         });
     }
-    const intent = ctx.session?.intent;
     const reason = args.reason || 'Agent execution failed';
     // Persist intent chain via SignalBus
     if (intent && intent.phase === 'active') {
@@ -232,9 +249,9 @@ async function _fail(ctx, args) {
     return envelope({
         success: true,
         data: {
-            failed: { id: args.id, reason, failedAt: Date.now() },
+            failed: { id, reason, failedAt: Date.now() },
         },
-        message: `❌ Failed: ${args.id} — ${reason}`,
+        message: `❌ Failed: ${id} — ${reason}`,
         meta: { tool: 'autosnippet_task' },
     });
 }
@@ -323,9 +340,14 @@ function _computeDriftScore(intent) {
 }
 function _getPipeline(container) {
     try {
-        return container.get('primeSearchPipeline');
+        const p = container.get('primeSearchPipeline');
+        if (!p) {
+            process.stderr.write('[MCP/Task] _getPipeline: container returned null/undefined\n');
+        }
+        return p;
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[MCP/Task] _getPipeline failed: ${err instanceof Error ? err.message : String(err)}\n`);
         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 {};