autosnippet 3.3.4 → 3.3.6

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

@@ -192,10 +192,10 @@ export async function consolidatedSkill(ctx, args) {
  * 统一提交管线：单条与批量走同一代码路径。
  *
  * 流程:
- *   1. 解析 items[] → 限流
- *   2. 严格校验所有条目（UnifiedValidator）→ valid[] + rejected[]
- *   3. 融合分析（ConsolidationAdvisor.analyzeBatch）→ submittable[] + blocked[]
- *   4. 提交 submittable → enrich + service.create()
+ *   1. 限流
+ *   2. V3 字段增强（MCP 特有预处理）
+ *   3. RecipeProductionGateway.create() — 统一管道
+ *   4. Bootstrap session 追踪
  *   5. 返回统一结果
  *
  * 设计原则：
@@ -205,8 +205,7 @@ export async function consolidatedSkill(ctx, args) {
  *   - 单条/批量完全一致的校验与融合逻辑
  */
 export async function enhancedSubmitKnowledge(ctx, args) {
-    const { submitKnowledge } = await import('./knowledge.js');
-    const { UnifiedValidator } = await import('#domain/knowledge/UnifiedValidator.js');
+    const { RecipeProductionGateway } = await import('#service/knowledge/RecipeProductionGateway.js');
     const items = args.items;
     if (!items || !Array.isArray(items) || items.length === 0) {
         return envelope({
@@ -220,6 +219,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');
@@ -233,175 +233,85 @@ export async function enhancedSubmitKnowledge(ctx, args) {
             meta: { tool: 'autosnippet_submit_knowledge' },
         });
     }
-    // ── Step 2: 严格校验所有条目 ──
-    const validator = new UnifiedValidator();
-    const validItems = [];
-    const rejectedItems = [];
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        // 合并批次级选项到条目
+    // ── Step 2: MCP 特有预处理 ──
+    // 注入批次级选项到各条目
+    for (const item of items) {
         if (!item.source) {
             item.source = source;
         }
         if (dimensionId && !item.dimensionId) {
             item.dimensionId = dimensionId;
         }
-        const validation = validator.validate(item, { skipUniqueness: false });
-        if (validation.pass) {
-            validItems.push({ index: i, item });
-            // 记录标题/指纹供后续去重检测
-            validator.recordSubmission(item.title, item.content?.pattern);
-        }
-        else {
-            rejectedItems.push({
-                index: i,
-                title: item.title || '(untitled)',
-                errors: validation.errors,
-                warnings: validation.warnings,
-            });
-            // 记录拒绝到 BootstrapSession tracker
-            _trackRejection(ctx, item, dimensionId);
-            // 仍然记录标题/指纹防止后续条目重复
-            validator.recordSubmission(item.title, item.content?.pattern);
+    }
+    // 获取 bootstrapSession 已提交标题用于跨维度去重
+    let existingTitles;
+    try {
+        const sessionManager = ctx.container.get('bootstrapSessionManager');
+        const bsSession = sessionManager?.getSession?.();
+        if (bsSession?.submissionTracker?.getAllSubmittedTitles) {
+            existingTitles = bsSession.submissionTracker.getAllSubmittedTitles();
         }
     }
-    // 全部被拒绝
-    if (validItems.length === 0) {
-        const allMissing = [...new Set(rejectedItems.flatMap((it) => it.errors))];
-        return envelope({
-            success: false,
-            errorCode: 'INCOMPLETE_SUBMISSION',
-            message: `全部 ${items.length} 条知识条目被拒绝。请在单次调用中补齐所有字段后重新提交。`,
-            data: {
-                rejectedItems,
-                requiredFields: getRequiredFieldsDescription(),
-                commonErrors: allMissing,
-            },
-            meta: { tool: 'autosnippet_submit_knowledge' },
-        });
+    catch {
+        /* best effort */
     }
-    // ── Step 3: 融合分析（统一对所有有效条目运行） ──
-    const submittableItems = [];
-    const blockedItems = [];
-    if (skipConsolidation) {
-        submittableItems.push(...validItems);
-    }
-    else {
-        const advisor = ctx.container.get('consolidationAdvisor');
-        if (!advisor || typeof advisor.analyzeBatch !== 'function') {
-            // DI 未注册时降级放行
-            submittableItems.push(...validItems);
-        }
-        else {
-            try {
-                const candidates = validItems.map((v) => ({
-                    title: v.item.title || '',
-                    description: v.item.description || '',
-                    doClause: v.item.doClause,
-                    dontClause: v.item.dontClause,
-                    coreCode: v.item.coreCode,
-                    category: v.item.category,
-                    trigger: v.item.trigger,
-                    whenClause: v.item.whenClause,
-                    kind: v.item.kind,
-                    content: v.item.content,
-                }));
-                const batchAdvice = advisor.analyzeBatch(candidates);
-                for (const { index: adviceIdx, advice } of batchAdvice.items) {
-                    const validEntry = validItems[adviceIdx];
-                    if (advice.action === 'create') {
-                        submittableItems.push(validEntry);
-                    }
-                    else {
-                        blockedItems.push({
-                            index: validEntry.index,
-                            title: validEntry.item.title || '(untitled)',
-                            consolidation: advice,
-                        });
-                    }
-                }
-                // 将批次内重叠信息附加到 blockedItems
-                if (batchAdvice.internalOverlaps.length > 0) {
-                    for (const overlap of batchAdvice.internalOverlaps) {
-                        const entryB = validItems[overlap.indexB];
-                        // 如果 B 已经被放行，降级为 blocked（批次内碎片化警告）
-                        const alreadyBlocked = blockedItems.some((b) => b.index === entryB.index);
-                        if (!alreadyBlocked) {
-                            const entryA = validItems[overlap.indexA];
-                            blockedItems.push({
-                                index: entryB.index,
-                                title: entryB.item.title || '(untitled)',
-                                consolidation: {
-                                    action: 'merge',
-                                    reason: `与同批次候选「${entryA.item.title || ''}」高度重叠（${(overlap.similarity * 100).toFixed(0)}%），建议合并后再提交。`,
-                                    internalOverlap: true,
-                                    overlapWith: {
-                                        index: entryA.index,
-                                        title: entryA.item.title,
-                                        similarity: overlap.similarity,
-                                    },
-                                },
-                            });
-                            // 从 submittable 中移除
-                            const subIdx = submittableItems.findIndex((s) => s.index === entryB.index);
-                            if (subIdx >= 0) {
-                                submittableItems.splice(subIdx, 1);
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                // 分析失败时静默降级放行
-                submittableItems.push(...validItems.filter((v) => !submittableItems.some((s) => s.index === v.index)));
-            }
-        }
+    // ── Step 3: 委托 RecipeProductionGateway 统一管道 ──
+    const knowledgeService = ctx.container.get('knowledgeService');
+    let consolidationAdvisor = null;
+    try {
+        consolidationAdvisor = ctx.container.get('consolidationAdvisor');
     }
-    // ── Step 4: 提交所有通过的条目 ──
-    let successCount = 0;
-    const successIds = [];
-    const submitErrors = [];
-    for (const { index, item } of submittableItems) {
-        try {
-            const result = await submitKnowledge(ctx, {
-                ...item,
-                source: item.source || source,
-                client_id: clientId,
-            });
-            if (result?.success && result.data?.id) {
-                successCount++;
-                const recipeId = result.data.id;
-                successIds.push(recipeId);
-                _trackSubmission(ctx, item, dimensionId, recipeId);
-            }
-            else {
-                submitErrors.push({
-                    index,
-                    title: item.title || '(untitled)',
-                    error: result?.message || 'unknown error',
-                });
-            }
-        }
-        catch (err) {
-            submitErrors.push({
-                index,
-                title: item.title || '(untitled)',
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
+    catch {
+        /* not registered */
+    }
+    let proposalRepository = null;
+    try {
+        proposalRepository = ctx.container.get('proposalRepository');
+    }
+    catch {
+        /* not registered */
+    }
+    const gateway = new RecipeProductionGateway({
+        knowledgeService,
+        projectRoot,
+        consolidationAdvisor: consolidationAdvisor ?? null,
+        proposalRepository: proposalRepository ?? null,
+    });
+    const gatewayResult = await gateway.create({
+        source: 'mcp-external',
+        items: items,
+        options: {
+            skipSimilarityCheck: true,
+            skipConsolidation,
+            supersedes,
+            existingTitles,
+            userId: 'mcp',
+        },
+    });
+    // ── Step 4: Bootstrap session 追踪 ──
+    for (const created of gatewayResult.created) {
+        _trackSubmission(ctx, items.find((it) => it.title === created.title) || {}, dimensionId, created.id);
+    }
+    for (const rej of gatewayResult.rejected) {
+        const item = items[rej.index] || {};
+        _trackRejection(ctx, item, dimensionId);
     }
     // ── Step 5: 构建统一响应 ──
+    const successCount = gatewayResult.created.length;
     const data = {
         count: successCount,
         total: items.length,
     };
-    if (successIds.length > 0) {
-        data.ids = successIds;
-    }
-    if (submitErrors.length > 0) {
-        data.errors = submitErrors;
+    if (gatewayResult.created.length > 0) {
+        data.ids = gatewayResult.created.map((c) => c.id);
     }
-    if (rejectedItems.length > 0) {
+    if (gatewayResult.rejected.length > 0) {
+        const rejectedItems = gatewayResult.rejected.map((r) => ({
+            index: r.index,
+            title: r.title,
+            errors: r.errors,
+            warnings: r.warnings,
+        }));
         const allMissing = [...new Set(rejectedItems.flatMap((it) => it.errors))];
         data.rejectedItems = rejectedItems;
         data.rejectedSummary = {
@@ -410,13 +320,56 @@ export async function enhancedSubmitKnowledge(ctx, args) {
             message: `${rejectedItems.length}/${items.length} 条知识条目因校验未通过被拒绝。`,
         };
     }
-    if (blockedItems.length > 0) {
-        data.blockedItems = blockedItems;
+    if (gatewayResult.blocked.length > 0) {
+        data.blockedItems = gatewayResult.blocked;
         data.blockedSummary = {
-            blockedCount: blockedItems.length,
-            message: `${blockedItems.length} 条因融合分析被阻塞（与已有 Recipe 重叠或实质性不足）。设 skipConsolidation: true 可跳过。`,
+            blockedCount: gatewayResult.blocked.length,
+            message: `${gatewayResult.blocked.length} 条因融合分析被阻塞（与已有 Recipe 重叠或实质性不足）。设 skipConsolidation: true 可跳过。`,
+        };
+    }
+    const createdProposals = [];
+    for (const m of gatewayResult.merged) {
+        createdProposals.push({
+            proposalId: m.proposalId,
+            type: m.type,
+            targetRecipe: { id: m.targetRecipeId, title: m.targetTitle },
+            status: m.status,
+            expiresAt: m.expiresAt,
+            message: m.message,
+        });
+    }
+    if (gatewayResult.supersedeProposal) {
+        createdProposals.push({
+            proposalId: gatewayResult.supersedeProposal.proposalId,
+            type: 'supersede',
+            targetRecipe: { id: supersedes, title: supersedes },
+            status: 'observing',
+            expiresAt: 0,
+            message: `已创建替代提案。`,
+        });
+    }
+    if (createdProposals.length > 0) {
+        data.proposals = createdProposals;
+        data.proposalSummary = {
+            proposalCount: createdProposals.length,
+            message: `${createdProposals.length} 条已创建进化提案，系统将在观察窗口到期后自动执行。无需额外操作。`,
         };
     }
+    // 全部拒绝 → 特殊错误响应
+    if (successCount === 0 && gatewayResult.rejected.length === items.length) {
+        const allMissing = [...new Set(gatewayResult.rejected.flatMap((it) => it.errors))];
+        return envelope({
+            success: false,
+            errorCode: 'INCOMPLETE_SUBMISSION',
+            message: `全部 ${items.length} 条知识条目被拒绝。请在单次调用中补齐所有字段后重新提交。`,
+            data: {
+                rejectedItems: data.rejectedItems,
+                requiredFields: getRequiredFieldsDescription(),
+                commonErrors: allMissing,
+            },
+            meta: { tool: 'autosnippet_submit_knowledge' },
+        });
+    }
     const allOk = successCount === items.length;
     return envelope({
         success: successCount > 0,

package/dist/lib/external/mcp/handlers/dimension-complete-external.js

@@ -298,8 +298,9 @@ export async function dimensionComplete(ctx, args) {
         emitter.emitAllComplete(session.id, progress.total, 'external-agent');
     }
     // ═══════════════════════════════════════════════════════════
-    // 6.5 Bootstrap 完成后，自动触发 Delivery / Wiki / SemanticMemory (R4/R5/R6)
+    // 6.5 Bootstrap 完成后，自动触发 Delivery / Panorama / Wiki / SemanticMemory (R4/R4.5/R5/R6)
     // ═══════════════════════════════════════════════════════════
+    let deliveryVerification = null;
     if (isComplete) {
         // R4: 自动触发 Cursor Delivery
         try {
@@ -318,6 +319,44 @@ export async function dimensionComplete(ctx, args) {
         catch (e) {
             logger.warn(`[DimensionComplete] Auto CursorDelivery failed (non-blocking): ${e instanceof Error ? e.message : String(e)}`);
         }
+        // R4+: DeliveryVerifier — 交付完整性检查
+        try {
+            const { DeliveryVerifier } = await import('#service/bootstrap/DeliveryVerifier.js');
+            const { resolveProjectRoot } = await import('#shared/resolveProjectRoot.js');
+            const projectRoot = resolveProjectRoot(ctx.container);
+            const verifier = new DeliveryVerifier(projectRoot);
+            const verification = verifier.verify();
+            if (!verification.allPassed) {
+                logger.warn('[DimensionComplete] Delivery verification incomplete', {
+                    failures: verification.failures,
+                });
+            }
+            else {
+                logger.info('[DimensionComplete] Delivery verification passed — all channels OK');
+            }
+            // 附加到响应中的 completionExtras
+            deliveryVerification = verification;
+        }
+        catch (e) {
+            logger.warn(`[DimensionComplete] DeliveryVerifier failed (non-blocking): ${e instanceof Error ? e.message : String(e)}`);
+        }
+        // R4.5: Panorama 数据刷新（冷启动完成后知识库已填充，需重新计算全景）
+        try {
+            const { getServiceContainer: getPanoramaContainer } = await import('#inject/ServiceContainer.js');
+            const panoramaContainer = getPanoramaContainer();
+            const panoramaService = panoramaContainer.services.panoramaService
+                ? panoramaContainer.get('panoramaService')
+                : null;
+            if (panoramaService &&
+                typeof panoramaService.rescan === 'function') {
+                await panoramaService.rescan();
+                const overview = panoramaService.getOverview();
+                logger.info(`[DimensionComplete] Panorama refreshed — ${overview.moduleCount} modules, ${overview.gapCount} gaps`);
+            }
+        }
+        catch (e) {
+            logger.warn(`[DimensionComplete] Panorama refresh failed (non-blocking): ${e instanceof Error ? e.message : String(e)}`);
+        }
         // R5: 自动触发 Wiki 生成 (fire-and-forget)
         setImmediate(async () => {
             try {
@@ -392,6 +431,31 @@ export async function dimensionComplete(ctx, args) {
     }
     // Wiki 生成提示（冷启动完成时）
     const nextActions = isComplete ? BOOTSTRAP_COMPLETE_ACTIONS : undefined;
+    // §9: 子包覆盖校验 — 检查 referencedFiles 是否覆盖了关键本地子包
+    let subpackageCoverageWarning;
+    try {
+        const snapshotCache = session.getSnapshotCache?.();
+        const localPkgs = snapshotCache?.localPackageModules;
+        if (localPkgs && localPkgs.length > 0 && referencedFiles.length > 0) {
+            const uncoveredPkgs = [];
+            for (const pkg of localPkgs) {
+                const pkgPrefix = pkg.packageName.replace(/\/$/, '');
+                const covered = referencedFiles.some((f) => f.includes(pkgPrefix) || f.includes(pkg.name));
+                if (!covered) {
+                    uncoveredPkgs.push(pkg.name);
+                }
+            }
+            if (uncoveredPkgs.length > 0) {
+                subpackageCoverageWarning =
+                    `本维度未覆盖以下本地子包: ${uncoveredPkgs.join(', ')}。` +
+                        `建议在分析中纳入这些模块的源码，以确保知识库完整性。`;
+                logger.info(`[DimensionComplete] Subpackage coverage gap for "${dimensionId}": ${uncoveredPkgs.join(', ')}`);
+            }
+        }
+    }
+    catch {
+        /* best effort */
+    }
     // v2: 为下游维度构建结构化提示 (基于累积证据)
     let evidenceHints;
     if (!isComplete &&
@@ -450,6 +514,10 @@ export async function dimensionComplete(ctx, args) {
             qualityFeedback,
             // v2: 跨维度证据 (供后续维度利用)
             evidenceHints,
+            // v3: 子包覆盖校验警告
+            subpackageCoverageWarning,
+            // v3.1: 交付完整性验证 (仅 bootstrap 完成时)
+            deliveryVerification: isComplete ? deliveryVerification : undefined,
             nextActions,
         },
         meta: {

package/dist/lib/external/mcp/handlers/evolve-external.d.ts

@@ -0,0 +1,54 @@
+/**
+ * MCP Handler — autosnippet_evolve (批量 Recipe 进化决策)
+ *
+ * 双入口工具：
+ *   - Rescan 模式: 每个维度内先 evolve 再 gap-fill，与内部 Agent Pipeline 一致
+ *   - 独立模式: 用户通过提示词触发，验证已有 Recipe 的有效性
+ *
+ * 三种决策委托给 evolution-tools.ts 中已有的 handler 实现：
+ *   - propose_evolution → ProposalRepository.create (观察窗口)
+ *   - confirm_deprecation → RecipeLifecycleSupervisor.transition → deprecated (优先) / KnowledgeService.deprecate (回退)
+ *   - skip → 不变更状态，skip(still_valid) 刷新 stats.lastVerifiedAt
+ *
+ * @module handlers/evolve-external
+ */
+import type { ServiceContainer } from '#inject/ServiceContainer.js';
+import type { EvolveInput } from '#shared/schemas/mcp-tools.js';
+/** MCP handler context */
+interface McpContext {
+    container: ServiceContainer;
+    logger: {
+        info(msg: string, meta?: Record<string, unknown>): void;
+        warn(msg: string, meta?: Record<string, unknown>): void;
+    };
+    startedAt?: number;
+    [key: string]: unknown;
+}
+interface EvolveResult {
+    processed: number;
+    proposed: number;
+    deprecated: number;
+    skipped: number;
+    refreshed: number;
+    quotaChange: {
+        freed: number;
+        occupied: number;
+    };
+    errors: Array<{
+        recipeId: string;
+        error: string;
+    }>;
+}
+export declare function evolveExternal(ctx: McpContext, args: EvolveInput): Promise<{
+    success: boolean;
+    errorCode: string | null;
+    message: string;
+    data: EvolveResult | null;
+    meta: {
+        source?: string | undefined;
+        responseTimeMs?: number | undefined;
+        version: string;
+        tool?: string | undefined;
+    };
+}>;
+export {};