autosnippet 3.2.7 → 3.2.9

package/lib/external/mcp/handlers/bootstrap/pipeline/orchestrator.js

@@ -4,11 +4,11 @@
  * ⚠️ 本文件是「内部 Agent」专用 — 由 bootstrap.js Phase 5 调用。
  *    外部 Agent (Cursor/Copilot) 不经过此管线，它们自行分析代码。
  *
- * 核心架构: Analyst → Gate → Producer (双 Agent 模式)
+ * 核心架构: PipelineStrategy 驱动 (Analyze → QualityGate → Produce → RejectionGate)
  *
- * 1. Analyst Agent 自由探索代码 (AST 工具 + 文件搜索)
- * 2. HandoffProtocol 质量门控
- * 3. Producer Agent 格式化输出 (submit_knowledge)
+ * 1. Analyze 阶段: 自由探索代码 (AST 工具 + 文件搜索)
+ * 2. QualityGate: 质量门控 (insightGateEvaluator)
+ * 3. Produce 阶段: 格式化输出 (submit_knowledge)
  * 4. TierScheduler 分层并行执行
  *
  * @module pipeline/orchestrator
@@ -17,12 +17,15 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import Logger from '../../../../../infrastructure/logging/Logger.js';
-import { AnalystAgent } from '../../../../../service/chat/AnalystAgent.js';
-import { EpisodicConsolidator } from '../../../../../service/chat/EpisodicConsolidator.js';
-import { ProducerAgent } from '../../../../../service/chat/ProducerAgent.js';
-import { ProjectSemanticMemory } from '../../../../../service/chat/ProjectSemanticMemory.js';
-import { MemoryCoordinator } from '../../../../../service/chat/memory/MemoryCoordinator.js';
-import { SessionStore } from '../../../../../service/chat/memory/SessionStore.js';
+import { EpisodicConsolidator } from '../../../../../service/agent/domain/EpisodicConsolidator.js';
+import { PersistentMemory } from '../../../../../service/agent/memory/PersistentMemory.js';
+import { MemoryCoordinator } from '../../../../../service/agent/memory/MemoryCoordinator.js';
+import { SessionStore } from '../../../../../service/agent/memory/SessionStore.js';
+import { AgentMessage } from '../../../../../service/agent/AgentMessage.js';
+import { BudgetPolicy } from '../../../../../service/agent/policies.js';
+import { PRESETS } from '../../../../../service/agent/presets.js';
+import { ContextWindow } from '../../../../../service/agent/context/ContextWindow.js';
+import { ExplorationTracker } from '../../../../../service/agent/context/ExplorationTracker.js';
 import { clearCheckpoints, loadCheckpoints, saveDimensionCheckpoint } from './checkpoint.js';
 import { buildTierReflection, DIMENSION_CONFIGS_V3, getFullDimensionConfig } from './dimension-configs.js';
 import { getDimensionFocusKeywords } from '../shared/dimension-sop.js';
@@ -61,30 +64,29 @@ export async function fillDimensionsV3(fillContext) {
   const isIncremental = incrementalPlan?.canIncremental && incrementalPlan?.mode === 'incremental';
   const emitter = new BootstrapEventEmitter(ctx.container);
   logger.info(
-    `[Bootstrap-v3] ═══ fillDimensionsV3 entered — ${isIncremental ? 'INCREMENTAL' : 'FULL'} pipeline`
+    `[Insight-v3] ═══ fillDimensionsV3 entered — ${isIncremental ? 'INCREMENTAL' : 'FULL'} pipeline`
   );
 
   let allFiles = fillContext.allFiles;
   fillContext.allFiles = null;
 
   // ═══════════════════════════════════════════════════════════
-  // Step 0: AI 可用性检查
+  // Step 0: AI 可用性检查 (v7.2: 使用 AgentFactory)
   // ═══════════════════════════════════════════════════════════
-  let chatAgent = null;
+  let agentFactory = null;
   try {
-    chatAgent = ctx.container.get('chatAgent');
-    if (chatAgent && !chatAgent.hasRealAI) {
-      chatAgent = null;
-    }
-    if (chatAgent) {
-      chatAgent.resetGlobalSubmittedTitles();
+    agentFactory = ctx.container.get('agentFactory');
+    // 检查 AI Provider 是否可用
+    const aiProvider = ctx.container.singletons?.aiProvider;
+    if (!aiProvider || aiProvider.name === 'mock') {
+      agentFactory = null;
     }
   } catch {
     /* not available */
   }
 
-  if (!chatAgent) {
-    logger.info('[Bootstrap-v3] AI not available — entering rule-based fallback');
+  if (!agentFactory) {
+    logger.info('[Insight-v3] AI not available — entering rule-based fallback');
     emitter.emitProgress('bootstrap:ai-unavailable', {
       message: 'AI 不可用，将使用规则化降级提取基础知识。请配置 AI Provider 以获取完整分析。',
     });
@@ -247,21 +249,20 @@ export async function fillDimensionsV3(fillContext) {
     if (projectGraph) {
       const overview = projectGraph.getOverview();
       logger.info(
-        `[Bootstrap-v3] ProjectGraph: ${overview.totalClasses} classes, ${overview.totalProtocols} protocols (${overview.buildTimeMs}ms)`
+        `[Insight-v3] ProjectGraph: ${overview.totalClasses} classes, ${overview.totalProtocols} protocols (${overview.buildTimeMs}ms)`
       );
     }
   } catch (e) {
-    logger.warn(`[Bootstrap-v3] ProjectGraph build failed: ${e.message}`);
+    logger.warn(`[Insight-v3] ProjectGraph build failed: ${e.message}`);
   }
 
   // ═══════════════════════════════════════════════════════════
   // Step 1: 构建 Agents + 上下文
   // ═══════════════════════════════════════════════════════════
-  const analystAgent = new AnalystAgent(chatAgent, projectGraph, { maxRetries: 1 });
-  const producerAgent = new ProducerAgent(chatAgent);
+  logger.info('[Insight-v7] Using unified AgentRuntime pipeline (no legacy Analyst/Producer wrappers)');
 
-  // 注入文件缓存
-  chatAgent.setFileCache(allFiles);
+  // 注入文件缓存到容器 (v7.2: 通过容器传递)
+  ctx.container.singletons._fileCache = allFiles;
 
   // 项目信息
   const projectInfo = {
@@ -289,7 +290,7 @@ export async function fillDimensionsV3(fillContext) {
     sessionStore = incrementalPlan.restoredEpisodic;
     const restoredDims = sessionStore.getCompletedDimensions();
     logger.info(
-      `[Bootstrap-v3] Restored SessionStore: ${restoredDims.length} dims [${restoredDims.join(', ')}]`
+      `[Insight-v3] Restored SessionStore: ${restoredDims.length} dims [${restoredDims.join(', ')}]`
     );
 
     // 同步恢复 DimensionContext 的 digests (兼容)
@@ -308,23 +309,23 @@ export async function fillDimensionsV3(fillContext) {
     });
   }
 
-  // v4.1: ProjectSemanticMemory — 项目级永久语义记忆 (Tier 3)
-  // 加载历史 bootstrap 记忆 → 注入 AnalystAgent prompt
+  // v4.1: PersistentMemory — 项目级永久语义记忆 (Tier 3)
+  // 加载历史 bootstrap 记忆 → 注入 Analyst promptBuilder
   let semanticMemory = null;
   try {
     const db = ctx.container.get('database');
     if (db) {
-      semanticMemory = new ProjectSemanticMemory(db, { logger });
+      semanticMemory = new PersistentMemory(db, { logger });
       const smStats = semanticMemory.getStats();
       if (smStats.total > 0) {
         logger.info(
-          `[Bootstrap-v3] Loaded ${smStats.total} semantic memories from previous bootstrap ` +
+          `[Insight-v3] Loaded ${smStats.total} semantic memories from previous bootstrap ` +
             `(fact: ${smStats.byType.fact || 0}, insight: ${smStats.byType.insight || 0}, preference: ${smStats.byType.preference || 0})`
         );
       }
     }
   } catch (smErr) {
-    logger.warn(`[Bootstrap-v3] SemanticMemory init failed (non-blocking): ${smErr.message}`);
+    logger.warn(`[Insight-v3] SemanticMemory init failed (non-blocking): ${smErr.message}`);
   }
 
   // Phase E: CodeEntityGraph — 代码实体关系图谱 (供 Analyst prompt 注入)
@@ -337,12 +338,12 @@ export async function fillDimensionsV3(fillContext) {
       const topo = codeEntityGraphInst.getTopology();
       if (topo.totalEntities > 0) {
         logger.info(
-          `[Bootstrap-v3] CodeEntityGraph: ${topo.totalEntities} entities, ${topo.totalEdges} edges`
+          `[Insight-v3] CodeEntityGraph: ${topo.totalEntities} entities, ${topo.totalEdges} edges`
         );
       }
     }
   } catch (cegErr) {
-    logger.warn(`[Bootstrap-v3] CodeEntityGraph init failed (non-blocking): ${cegErr.message}`);
+    logger.warn(`[Insight-v3] CodeEntityGraph init failed (non-blocking): ${cegErr.message}`);
   }
 
   // v5.0: MemoryCoordinator — 统一记忆协调器 (会话级)
@@ -378,14 +379,14 @@ export async function fillDimensionsV3(fillContext) {
     }
     if (incrementalSkippedDims.length > 0) {
       logger.info(
-        `[Bootstrap-v3] ⏩ Incremental skip: [${incrementalSkippedDims.join(', ')}] ` +
+        `[Insight-v3] ⏩ Incremental skip: [${incrementalSkippedDims.join(', ')}] ` +
           `(using historical results)`
       );
     }
   }
 
   logger.info(
-    `[Bootstrap-v3] Active dimensions: [${activeDimIds.join(', ')}], concurrency=${enableParallel ? concurrency : 1}${isIncremental ? `, incremental skip: [${incrementalSkippedDims.join(', ')}]` : ''}`
+    `[Insight-v3] Active dimensions: [${activeDimIds.join(', ')}], concurrency=${enableParallel ? concurrency : 1}${isIncremental ? `, incremental skip: [${incrementalSkippedDims.join(', ')}]` : ''}`
   );
 
   // ── P3: 断点续传 — 加载有效 checkpoints ──
@@ -404,7 +405,7 @@ export async function fillDimensionsV3(fillContext) {
         ...checkpoint,
       });
       skippedDims.push(dimId);
-      logger.info(`[Bootstrap-v3] ⏩ 跳过已完成维度 (checkpoint): "${dimId}"`);
+      logger.info(`[Insight-v3] ⏩ 跳过已完成维度 (checkpoint): "${dimId}"`);
     }
   }
 
@@ -412,6 +413,10 @@ export async function fillDimensionsV3(fillContext) {
   const dimensionCandidates = {};
   const dimensionStats = {}; // P4.2: 维度级统计
 
+  // ── 跨维度去重集合 (实例级持久化，等效旧 ChatAgent.#globalSubmittedTitles/Patterns) ──
+  const globalSubmittedTitles = new Set();
+  const globalSubmittedPatterns = new Set();
+
   /**
    * 执行单个维度: Analyst → Gate → Producer
    */
@@ -432,7 +437,7 @@ export async function fillDimensionsV3(fillContext) {
         restoredFromIncremental: true,
       };
       dimensionStats[dimId] = dimResult;
-      logger.info(`[Bootstrap-v3] ⏩ "${dimId}" — incremental skip (historical result)`);
+      logger.info(`[Insight-v3] ⏩ "${dimId}" — incremental skip (historical result)`);
       return dimResult;
     }
 
@@ -472,7 +477,7 @@ export async function fillDimensionsV3(fillContext) {
           candidatesSummary: [],
         });
         logger.info(
-          `[Bootstrap-v3] ✅ Checkpoint "${dimId}": analysisText restored (${cp.analysisText.length} chars) — Skill generation enabled`
+          `[Insight-v3] ✅ Checkpoint "${dimId}": analysisText restored (${cp.analysisText.length} chars) — Skill generation enabled`
         );
       }
 
@@ -521,110 +526,259 @@ export async function fillDimensionsV3(fillContext) {
 
     // Session 有效性检查
     if (taskManager && !taskManager.isSessionValid(sessionId)) {
-      logger.warn(`[Bootstrap-v3] Session superseded — skipping "${dimId}"`);
+      logger.warn(`[Insight-v3] Session superseded — skipping "${dimId}"`);
       return { candidateCount: 0, error: 'session-superseded' };
     }
 
     emitter.emitDimensionStart(dimId);
-    logger.info(`[Bootstrap-v3] ── Dimension "${dimId}" (${dimConfig.label}) ──`);
+    logger.info(`[Insight-v3] ── Dimension "${dimId}" (${dimConfig.label}) ──`);
 
     const dimStartTime = Date.now();
 
     try {
-      // v5.0: 为每个维度创建独立的 ActiveContext 作用域
+      // ═══ v3.0: 增强 PipelineStrategy 驱动 ═══
       const analystScopeId = `${dimId}:analyst`;
       memoryCoordinator.createDimensionScope(analystScopeId);
 
-      // ── Phase 1: Analyst ──
-      const analysisReport = await Promise.race([
-        analystAgent.analyze(dimConfig, projectInfo, {
-          sessionId,
-          dimensionContext: dimContext,
-          // v5.0: 统一 MemoryCoordinator
-          memoryCoordinator,
-          // v4.1: Semantic Memory (历史 bootstrap 记忆)
-          semanticMemory,
-          // Phase E: Code Entity Graph 代码实体图谱
-          codeEntityGraph: codeEntityGraphInst,
-        }),
+      const v3OutputType = DIMENSION_CONFIGS_V3[dimId]?.outputType;
+      const needsCandidates = v3OutputType
+        ? v3OutputType !== 'skill'
+        : !dimConfig.skillWorthy || dimConfig.dualOutput;
+
+      // ── 获取 Preset 的标准 stages 配置作为基础 ──
+      const presetStages = PRESETS.insight.strategy.stages;
+
+      // ── 构建 per-dimension 的 stages ──
+      // NOTE: onToolCall 不再注入 ac.recordToolCall — ToolExecutionPipeline 的
+      // traceRecord 中间件已通过 loopCtx.trace 统一记录,避免同一 AC 上双重记录。
+      const analyzeStage = {
+        ...presetStages[0],
+      };
+
+      let stages;
+      if (needsCandidates) {
+        // 候选维度: Analyze→QualityGate→Produce→RejectionGate
+        const produceStage = {
+          ...presetStages[2],
+          promptBuilder: (ctx) => {
+            memoryCoordinator.allocateBudget('producer');
+            return presetStages[2].promptBuilder(ctx);
+          },
+        };
+        stages = [
+          analyzeStage,
+          presetStages[1], // quality_gate
+          produceStage,
+          presetStages[3], // rejection_gate
+        ];
+      } else {
+        // Skill-only 维度: 仅 Analyze
+        stages = [analyzeStage];
+      }
+
+      // ── 创建 Runtime (使用增强 PipelineStrategy) ──
+      const runtime = agentFactory.createRuntime('insight', {
+        lang: primaryLang || projectInfo.lang || null,
+        strategy: {
+          type: 'pipeline',
+          maxRetries: 1,
+          stages,
+        },
+      });
+      runtime.setFileCache(allFiles);
+
+      // ── 构建消息 + strategyContext ──
+      const message = AgentMessage.internal(`Bootstrap dimension: ${dimConfig.label}`, {
+        sessionId,
+        dimension: dimId,
+        phase: 'bootstrap',
+      });
+
+      const strategyContext = {
+        dimConfig,
+        projectInfo,
+        dimContext,
+        sessionStore,
+        semanticMemory,
+        codeEntityGraph: codeEntityGraphInst,
+        projectGraph: null, // ProjectGraph 在 orchestrator 级别可用时注入
+        dimId,
+        activeContext: memoryCoordinator.getActiveContext(analystScopeId),
+        outputType: dimConfig.outputType || 'analysis',
+        // ── 引擎增强参数 (PipelineStrategy → reactLoop 透传) ──
+        contextWindow: agentFactory.createContextWindow({ isSystem: true }),
+        tracker: ExplorationTracker.resolve(
+          { source: 'system', dimensionMeta: dimConfig },
+          { maxIterations: PRESETS.insight.strategy.stages[0].budget?.maxIterations || 24 },
+        ),
+        trace: memoryCoordinator.getActiveContext(analystScopeId),
+        memoryCoordinator,
+        sharedState: {
+          submittedTitles: globalSubmittedTitles,
+          submittedPatterns: globalSubmittedPatterns,
+          _dimensionMeta: {
+            id: dimId,
+            outputType: dimConfig.outputType || 'candidate',
+            allowedKnowledgeTypes: dimConfig.allowedKnowledgeTypes || [],
+          },
+          _projectLanguage: primaryLang || projectInfo.lang || null,
+          _dimensionScopeId: analystScopeId,
+        },
+        source: 'system',
+      };
+
+      // ── 执行 ──
+      // 外层超时 = 安全网 (各阶段已有独立超时: Analyst 300s + Producer 180s + 硬缓冲 60s)
+      const outerTimeoutMs = 600_000;
+      const runResult = await Promise.race([
+        runtime.execute(message, { strategyContext }),
         new Promise((_, reject) =>
-          setTimeout(() => reject(new Error(`Analyst timeout for "${dimId}"`)), 300_000)
+          setTimeout(() => reject(new Error(`Bootstrap runtime timeout for "${dimId}"`)), outerTimeoutMs),
         ),
       ]);
 
-      // v5.0: 通过 coordinator 蒸馏 ActiveContext → SessionStore
+      // ── 提取结果 ──
+      const analyzeResult = runResult?.phases?.analyze;
+      const gateResult = runResult?.phases?.quality_gate;
+      const produceResult = runResult?.phases?.produce;
+      const analysisText = (analyzeResult?.reply || runResult?.reply || '').trim();
+      const artifact = gateResult?.artifact || {
+        analysisText,
+        referencedFiles: [],
+        findings: [],
+        metadata: { toolCallCount: 0 },
+      };
+
+      const runtimeToolCalls = runResult?.toolCalls || [];
+      const combinedTokenUsage = runResult?.tokenUsage || { input: 0, output: 0 };
+
+      // 引用文件: 优先从 artifact 取, 回退从 toolCalls 提取
+      const referencedFiles = artifact.referencedFiles?.length > 0
+        ? artifact.referencedFiles
+        : [...new Set(runtimeToolCalls.flatMap((tc) => {
+            const a = tc?.args || tc?.params || {};
+            const files = [];
+            if (typeof a.filePath === 'string' && a.filePath.trim()) files.push(a.filePath.trim());
+            if (Array.isArray(a.filePaths)) {
+              for (const f of a.filePaths) {
+                if (typeof f === 'string' && f.trim()) files.push(f.trim());
+              }
+            }
+            return files;
+          }))];
+
+      const analysisReport = {
+        dimensionId: dimId,
+        analysisText: artifact.analysisText || analysisText,
+        findings: artifact.findings || [],
+        referencedFiles,
+        evidenceMap: artifact.evidenceMap || null,
+        negativeSignals: artifact.negativeSignals || [],
+        metadata: {
+          toolCallCount: runtimeToolCalls.length,
+          tokenUsage: combinedTokenUsage,
+          artifactVersion: artifact.metadata?.artifactVersion || 1,
+        },
+      };
+
+      // ── Producer 结果统计 ──
+      const submitCalls = runtimeToolCalls.filter(tc => {
+        const tool = tc?.tool || tc?.name;
+        return tool === 'submit_knowledge' || tool === 'submit_with_check';
+      });
+      const successCount = submitCalls.filter(tc => {
+        const res = tc?.result;
+        if (!res) return true;
+        if (typeof res === 'string') return !res.includes('rejected') && !res.includes('error');
+        return res.status !== 'rejected' && res.status !== 'error';
+      }).length;
+      const rejectedCount = submitCalls.length - successCount;
+
+      const producerResult = {
+        candidateCount: needsCandidates ? successCount : 0,
+        rejectedCount: needsCandidates ? rejectedCount : 0,
+        toolCalls: runtimeToolCalls,
+        reply: produceResult?.reply || analysisText,
+        tokenUsage: combinedTokenUsage,
+      };
+
+      candidateResults.created += producerResult.candidateCount;
+      dimensionCandidates[dimId] = { analysisReport, producerResult };
+
+      // ── Memory Update ──
       const ac = memoryCoordinator.getActiveContext(analystScopeId);
       const distilled = ac ? ac.distill() : { keyFindings: [], totalObservations: 0, toolCallSummary: [] };
       sessionStore.storeDimensionReport(dimId, {
         analysisText: analysisReport.analysisText,
-        findings: analysisReport.findings || distilled.keyFindings,
+        findings: analysisReport.findings.length > 0 ? analysisReport.findings : distilled.keyFindings,
         referencedFiles: analysisReport.referencedFiles || [],
         candidatesSummary: [],
         workingMemoryDistilled: distilled,
       });
 
-      // v4.2: 记录 Artifact 增强数据 (如果使用了 v2 pipeline)
-      const isArtifact = !!analysisReport.evidenceMap;
-      const evidenceMapSize = isArtifact ? analysisReport.evidenceMap.size : 0;
-      const negativeSignalCount = isArtifact ? analysisReport.negativeSignals?.length || 0 : 0;
-      const qualityScore = isArtifact ? analysisReport.qualityReport?.totalScore : null;
-
       logger.info(
-        `[Bootstrap-v3] Analyst "${dimId}": ${analysisReport.analysisText.length} chars, ` +
-          `${analysisReport.referencedFiles.length} files, ` +
-          `${distilled.keyFindings.length} key findings, ` +
-          `${distilled.totalObservations} observations` +
-          (isArtifact
-            ? `, evidence: ${evidenceMapSize} files, negative: ${negativeSignalCount}, quality: ${qualityScore}`
-            : '') +
-          ` (${Date.now() - dimStartTime}ms)`
+        `[Insight-v3] Dimension "${dimId}": analysis=${analysisReport.analysisText.length} chars, ` +
+          `files=${analysisReport.referencedFiles.length}, findings=${(analysisReport.findings || distilled.keyFindings).length}, ` +
+          `toolCalls=${runtimeToolCalls.length}, degraded=${runResult?.degraded || false} (${Date.now() - dimStartTime}ms)`,
       );
 
-      // ── Phase 2: Producer (如果需要候选输出) ──
-      let producerResult = { candidateCount: 0, toolCalls: [], reply: '' };
-      // v3 优先使用 DIMENSION_CONFIGS_V3 的 outputType，回退到 baseDimension 的 skillWorthy/dualOutput
-      const v3OutputType = DIMENSION_CONFIGS_V3[dimId]?.outputType;
-      const needsCandidates = v3OutputType
-        ? v3OutputType !== 'skill' // 'dual' 或 'candidate' 都产出候选
-        : !dimConfig.skillWorthy || dimConfig.dualOutput;
-
-      // 先保存 Analyst 结果，确保即使 Producer 失败也能生成 Skill
-      dimensionCandidates[dimId] = {
-        analysisReport,
-        producerResult,
-      };
+      // ── Token 用量持久化 (fire-and-forget) ──
+      try {
+        const tokenStore = ctx.container?.get?.('tokenUsageStore');
+        if (tokenStore) {
+          const aiProv = runtime.aiProvider;
+          tokenStore.record({
+            source: 'system',
+            dimension: dimId,
+            provider: aiProv?.name || null,
+            model: aiProv?.model || null,
+            inputTokens: combinedTokenUsage.input || 0,
+            outputTokens: combinedTokenUsage.output || 0,
+            durationMs: Date.now() - dimStartTime,
+            toolCalls: runtimeToolCalls.length,
+            sessionId: sessionId || null,
+          });
+          try {
+            const realtime = ctx.container?.get?.('realtimeService');
+            realtime?.broadcastTokenUsageUpdated?.();
+          } catch { /* optional */ }
+        }
+      } catch { /* token logging should never break execution */ }
 
-      if (needsCandidates && analysisReport.analysisText.length >= 100) {
-        try {
-          // v5.0: 为 Producer 创建独立作用域
-          const producerScopeId = `${dimId}:producer`;
-          memoryCoordinator.createDimensionScope(producerScopeId);
-
-          producerResult = await Promise.race([
-            producerAgent.produce(analysisReport, dimConfig, projectInfo, {
-              sessionId,
-              memoryCoordinator,
+      // ── v5.1: analysisText 过短补强 ──
+      if (needsCandidates && analysisReport.analysisText.length < 100) {
+        const findings = analysisReport.findings || [];
+        if (findings.length >= 3) {
+          const dimLabel = dimConfig.label || dimId;
+          const synthesized = [
+            `## ${dimLabel}`,
+            '',
+            analysisReport.analysisText.trim(),
+            '',
+            '### 关键发现',
+            '',
+            ...findings.slice(0, 10).map((f, i) => {
+              const text = typeof f === 'string' ? f : f.finding;
+              return `${i + 1}. ${text}`;
             }),
-            new Promise((_, reject) =>
-              setTimeout(() => reject(new Error(`Producer timeout for "${dimId}"`)), 180_000)
-            ),
-          ]);
-
-          candidateResults.created += producerResult.candidateCount;
-          // 更新 dimensionCandidates 以包含 Producer 结果
-          dimensionCandidates[dimId].producerResult = producerResult;
+          ];
+          const memDistilled = distilled;
+          if (memDistilled?.toolCallSummary?.length > 0) {
+            synthesized.push('', '### 探索记录', '');
+            for (const s of memDistilled.toolCallSummary.slice(0, 10)) {
+              synthesized.push(`- ${s}`);
+            }
+          }
+          const originalLen = analysisReport.analysisText.length;
+          analysisReport.analysisText = synthesized.join('\n');
           logger.info(
-            `[Bootstrap-v3] Producer "${dimId}": ${producerResult.candidateCount} candidates (${Date.now() - dimStartTime}ms total)`
-          );
-        } catch (producerErr) {
-          logger.error(
-            `[Bootstrap-v3] Producer "${dimId}" failed: ${producerErr.message} — Analyst result preserved for Skill generation`
+            `[Insight-v3] analysisText 补强 "${dimId}": ${originalLen} → ${analysisReport.analysisText.length} chars ` +
+              `(from ${findings.length} findings)`,
           );
-          candidateResults.errors.push({ dimId, error: `Producer: ${producerErr.message}` });
         }
       }
 
-      // ── Phase 3: 记录 DimensionDigest ──
+      // ── DimensionDigest ──
       const digest = parseDimensionDigest(producerResult.reply) || {
         summary: `v3 分析: ${analysisReport.analysisText.substring(0, 200)}...`,
         candidateCount: producerResult.candidateCount,
@@ -633,21 +787,19 @@ export async function fillDimensionsV3(fillContext) {
         gaps: [],
       };
       dimContext.addDimensionDigest(dimId, digest);
-
-      // v4.0: 同步 digest 到 SessionStore
       sessionStore.addDimensionDigest(dimId, digest);
 
-      // 记录到 DimensionContext + EpisodicMemory
+      // 候选摘要记录到 DimensionContext + SessionStore
       for (const tc of producerResult.toolCalls || []) {
         const tool = tc.tool || tc.name;
         if (tool === 'submit_knowledge' || tool === 'submit_with_check') {
+          const args = tc.params || tc.args || {};
           const candidateSummary = {
-            title: tc.params?.title || '',
-            subTopic: tc.params?.category || '',
-            summary: tc.params?.summary || '',
+            title: args.title || '',
+            subTopic: args.category || '',
+            summary: args.summary || '',
           };
           dimContext.addSubmittedCandidate(dimId, candidateSummary);
-          // v4.0: 同步到 SessionStore
           sessionStore.addSubmittedCandidate(dimId, candidateSummary);
         }
       }
@@ -656,44 +808,41 @@ export async function fillDimensionsV3(fillContext) {
         type: needsCandidates ? 'candidate' : 'skill',
         extracted: producerResult.candidateCount,
         created: producerResult.candidateCount,
-        status: 'v3-complete',
+        skillPending: dimConfig.skillWorthy && producerResult.candidateCount === 0,
+        status: 'v3-pipeline-complete',
+        degraded: runResult?.degraded || false,
         durationMs: Date.now() - dimStartTime,
-        toolCallCount:
-          (analysisReport.metadata?.toolCallCount || 0) + (producerResult.toolCalls?.length || 0),
-        source: 'internal-agent',
+        toolCallCount: runtimeToolCalls.length,
+        source: 'enhanced-pipeline-strategy',
       });
 
-      // P4.1: 聚合 token 用量
-      const analystTokens = analysisReport.metadata?.tokenUsage || { input: 0, output: 0 };
-      const producerTokens = producerResult.tokenUsage || { input: 0, output: 0 };
-      const dimTokenUsage = {
-        input: (analystTokens.input || 0) + (producerTokens.input || 0),
-        output: (analystTokens.output || 0) + (producerTokens.output || 0),
-      };
-
+      const dimTokenUsage = combinedTokenUsage;
       const dimResult = {
         candidateCount: producerResult.candidateCount,
         rejectedCount: producerResult.rejectedCount || 0,
         analysisChars: analysisReport.analysisText.length,
         referencedFiles: analysisReport.referencedFiles.length,
         durationMs: Date.now() - dimStartTime,
-        toolCallCount:
-          (analysisReport.metadata?.toolCallCount || 0) + (producerResult.toolCalls?.length || 0),
+        toolCallCount: runtimeToolCalls.length,
         tokenUsage: dimTokenUsage,
-        // P3+: 保存 analysisText 供 checkpoint 恢复后 Skill 生成使用
         analysisText: analysisReport.analysisText,
         referencedFilesList: analysisReport.referencedFiles || [],
       };
 
-      // P4.2: 记录维度统计
       dimensionStats[dimId] = dimResult;
 
-      // P3: 保存 checkpoint
-      await saveDimensionCheckpoint(projectRoot, sessionId, dimId, dimResult, digest);
+      // P3: 保存 checkpoint — 仅当有实质分析内容时（避免 degraded/空结果污染后续 run）
+      if (analysisReport.analysisText.length >= 50) {
+        await saveDimensionCheckpoint(projectRoot, sessionId, dimId, dimResult, digest);
+      } else {
+        logger.warn(
+          `[Insight-v3] ⚠ 跳过 checkpoint 保存: "${dimId}" analysisText 过短 (${analysisReport.analysisText.length} chars)`
+        );
+      }
 
       return dimResult;
     } catch (err) {
-      logger.error(`[Bootstrap-v3] Dimension "${dimId}" failed: ${err.message}`);
+      logger.error(`[Insight-v3] Dimension "${dimId}" failed: ${err.message}`);
       candidateResults.errors.push({ dimId, error: err.message });
       emitter.emitDimensionComplete(dimId, { type: 'error', reason: err.message });
       return { candidateCount: 0, error: err.message };
@@ -723,7 +872,7 @@ export async function fillDimensionsV3(fillContext) {
         const tierStats = [...tierResults.values()];
         const totalCandidates = tierStats.reduce((s, r) => s + (r.candidateCount || 0), 0);
         logger.info(
-          `[Bootstrap-v3] Tier ${tierIndex + 1} complete: ${tierResults.size} dimensions, ${totalCandidates} candidates`
+          `[Insight-v3] Tier ${tierIndex + 1} complete: ${tierResults.size} dimensions, ${totalCandidates} candidates`
         );
 
         // v4.0: Tier 级 Reflection — 综合本 Tier 所有维度的发现
@@ -731,29 +880,29 @@ export async function fillDimensionsV3(fillContext) {
           const reflection = buildTierReflection(tierIndex, tierResults, sessionStore);
           sessionStore.addTierReflection(tierIndex, reflection);
           logger.info(
-            `[Bootstrap-v3] Tier ${tierIndex + 1} reflection: ` +
+            `[Insight-v3] Tier ${tierIndex + 1} reflection: ` +
               `${reflection.topFindings.length} top findings, ` +
               `${reflection.crossDimensionPatterns.length} patterns`
           );
         } catch (refErr) {
-          logger.warn(`[Bootstrap-v3] Tier ${tierIndex + 1} reflection failed: ${refErr.message}`);
+          logger.warn(`[Insight-v3] Tier ${tierIndex + 1} reflection failed: ${refErr.message}`);
         }
       },
     });
 
     logger.info(
-      `[Bootstrap-v3] All tiers complete: ${results.size} dimensions in ${Date.now() - t0}ms`
+      `[Insight-v3] All tiers complete: ${results.size} dimensions in ${Date.now() - t0}ms`
     );
     // v4.0: 记录 SessionStore 统计
     const emStats = sessionStore.getStats();
     logger.info(
-      `[Bootstrap-v3] Memory stats: ${emStats.completedDimensions} dims, ` +
+      `[Insight-v3] Memory stats: ${emStats.completedDimensions} dims, ` +
         `${emStats.totalFindings} findings, ${emStats.referencedFiles} files, ` +
         `${emStats.crossReferences} cross-refs, ${emStats.tierReflections} reflections`
     );
     if (emStats.cacheStats) {
       logger.info(
-        `[Bootstrap-v3] Cache stats: ${emStats.cacheStats.hitRate} hit rate, ` +
+        `[Insight-v3] Cache stats: ${emStats.cacheStats.hitRate} hit rate, ` +
           `${emStats.cacheStats.searchCacheSize} searches, ${emStats.cacheStats.fileCacheSize} files`
       );
     }
@@ -770,7 +919,7 @@ export async function fillDimensionsV3(fillContext) {
         await executeDimension(dimId);
       }
     }
-    logger.info(`[Bootstrap-v3] Serial execution complete in ${Date.now() - t0}ms`);
+    logger.info(`[Insight-v3] Serial execution complete in ${Date.now() - t0}ms`);
   }
 
   // ═══════════════════════════════════════════════════════════
@@ -827,7 +976,7 @@ export async function fillDimensionsV3(fillContext) {
           }
           effectiveText = synthesized.join('\n');
           logger.info(
-            `[Bootstrap-v3] Skill "${dim.id}": analysisText too short (${analysisText.trim().length} chars), ` +
+            `[Insight-v3] Skill "${dim.id}": analysisText too short (${analysisText.trim().length} chars), ` +
             `synthesized from ${keyFindings.length} findings → ${effectiveText.length} chars`
           );
         }
@@ -851,14 +1000,14 @@ export async function fillDimensionsV3(fillContext) {
           emitter.emitDimensionFailed(dim.id, new Error(result.error));
         }
       } catch (err) {
-        logger.warn(`[Bootstrap-v3] Skill generation failed for "${dim.id}": ${err.message}`);
+        logger.warn(`[Insight-v3] Skill generation failed for "${dim.id}": ${err.message}`);
         skillResults.failed++;
         skillResults.errors.push({ dimId: dim.id, error: err.message });
         emitter.emitDimensionFailed(dim.id, err);
       }
     }
   } catch (e) {
-    logger.warn(`[Bootstrap-v3] Skill generation module import failed: ${e.message}`);
+    logger.warn(`[Insight-v3] Skill generation module import failed: ${e.message}`);
   }
 
   // ═══════════════════════════════════════════════════════════
@@ -892,13 +1041,13 @@ export async function fillDimensionsV3(fillContext) {
       if (allCandidates.length > 0) {
         const relResult = ceg.populateFromCandidateRelations(allCandidates);
         logger.info(
-          `[Bootstrap-v3] Code Entity Graph relations: ${relResult.edgesCreated} edges from ${allCandidates.length} candidates (${relResult.durationMs}ms)`
+          `[Insight-v3] Code Entity Graph relations: ${relResult.edgesCreated} edges from ${allCandidates.length} candidates (${relResult.durationMs}ms)`
         );
       }
     }
   } catch (cegErr) {
     logger.warn(
-      `[Bootstrap-v3] Code Entity Graph relations failed (non-blocking): ${cegErr.message}`
+      `[Insight-v3] Code Entity Graph relations failed (non-blocking): ${cegErr.message}`
     );
   }
 
@@ -912,7 +1061,7 @@ export async function fillDimensionsV3(fillContext) {
   try {
     const db = ctx.container.get('database');
     if (db) {
-      const semanticMemory = new ProjectSemanticMemory(db, { logger });
+      const semanticMemory = new PersistentMemory(db, { logger });
       const consolidator = new EpisodicConsolidator(semanticMemory, { logger });
 
       consolidationResult = consolidator.consolidate(sessionStore, {
@@ -922,18 +1071,18 @@ export async function fillDimensionsV3(fillContext) {
 
       const smStats = semanticMemory.getStats();
       logger.info(
-        `[Bootstrap-v3] Semantic Memory consolidation: ` +
+        `[Insight-v3] Semantic Memory consolidation: ` +
           `+${consolidationResult.total.added} ADD, ` +
           `~${consolidationResult.total.updated} UPDATE, ` +
           `⊕${consolidationResult.total.merged} MERGE | ` +
           `Total: ${smStats.total} memories (avg importance: ${smStats.avgImportance})`
       );
     } else {
-      logger.warn('[Bootstrap-v3] Database not available — skipping Semantic Memory consolidation');
+      logger.warn('[Insight-v3] Database not available — skipping Semantic Memory consolidation');
     }
   } catch (consolidateErr) {
     logger.warn(
-      `[Bootstrap-v3] Semantic Memory consolidation failed (non-blocking): ${consolidateErr.message}`
+      `[Insight-v3] Semantic Memory consolidation failed (non-blocking): ${consolidateErr.message}`
     );
   }
 
@@ -957,7 +1106,7 @@ export async function fillDimensionsV3(fillContext) {
 
   logger.info(
     [
-      `[Bootstrap-v3] ═══ Pipeline complete ═══`,
+      `[Insight-v3] ═══ Pipeline complete ═══`,
       isIncremental
         ? `  Mode: INCREMENTAL (${incrementalPlan.affectedDimensions.length} affected, ${incrementalSkippedDims.length} skipped)`
         : '',
@@ -1070,9 +1219,9 @@ export async function fillDimensionsV3(fillContext) {
       path.join(reportDir, 'bootstrap-report.json'),
       JSON.stringify(report, null, 2)
     );
-    logger.info(`[Bootstrap-v3] 📊 Bootstrap report saved to .autosnippet/bootstrap-report.json`);
+    logger.info(`[Insight-v3] 📊 Bootstrap report saved to .autosnippet/bootstrap-report.json`);
   } catch (reportErr) {
-    logger.warn(`[Bootstrap-v3] Bootstrap report generation failed: ${reportErr.message}`);
+    logger.warn(`[Insight-v3] Bootstrap report generation failed: ${reportErr.message}`);
   }
 
   // P3: 成功完成后清理 checkpoints
@@ -1095,15 +1244,15 @@ export async function fillDimensionsV3(fillContext) {
         },
         plan: isIncremental ? incrementalPlan : null,
       });
-      logger.info(`[Bootstrap-v3] 📸 Snapshot saved: ${snapshotId}`);
+      logger.info(`[Insight-v3] 📸 Snapshot saved: ${snapshotId}`);
     }
   } catch (snapErr) {
-    logger.warn(`[Bootstrap-v3] Snapshot save failed (non-blocking): ${snapErr.message}`);
+    logger.warn(`[Insight-v3] Snapshot save failed (non-blocking): ${snapErr.message}`);
   }
 
   // 释放文件缓存
   allFiles = null;
-  chatAgent.setFileCache(null);
+  ctx.container.singletons._fileCache = null;
 
   // ── Cursor Delivery: 生成 4 通道交付物料 ──
   try {
@@ -1113,7 +1262,7 @@ export async function fillDimensionsV3(fillContext) {
       const pipeline = container.get('cursorDeliveryPipeline');
       const deliveryResult = await pipeline.deliver();
       logger.info(
-        `[Bootstrap-v3] 🚀 Cursor Delivery complete — ` +
+        `[Insight-v3] 🚀 Cursor Delivery complete — ` +
           `A: ${deliveryResult.channelA.rulesCount} rules, ` +
           `B: ${deliveryResult.channelB.topicCount} topics, ` +
           `C: ${deliveryResult.channelC.synced} skills, ` +
@@ -1122,7 +1271,7 @@ export async function fillDimensionsV3(fillContext) {
       );
     }
   } catch (deliveryErr) {
-    logger.warn(`[Bootstrap-v3] Cursor Delivery failed (non-blocking): ${deliveryErr.message}`);
+    logger.warn(`[Insight-v3] Cursor Delivery failed (non-blocking): ${deliveryErr.message}`);
   }
 
   // ── Repo Wiki: 自动生成项目文档 Wiki ──
@@ -1199,7 +1348,7 @@ export async function fillDimensionsV3(fillContext) {
     const wikiResult = await wiki.generate();
     if (wikiResult.success) {
       logger.info(
-        `[Bootstrap-v3] 📖 Wiki generated — ${wikiResult.filesGenerated} files, ` +
+        `[Insight-v3] 📖 Wiki generated — ${wikiResult.filesGenerated} files, ` +
           `AI: ${wikiResult.aiComposed || 0}, Synced: ${wikiResult.syncedDocs || 0}, ` +
           `Dedup removed: ${wikiResult.dedup?.removed?.length || 0}`
       );
@@ -1223,7 +1372,7 @@ export async function fillDimensionsV3(fillContext) {
       } catch { /* non-critical */ }
     }
   } catch (wikiErr) {
-    logger.warn(`[Bootstrap-v3] Wiki generation failed (non-blocking): ${wikiErr.message}`);
+    logger.warn(`[Insight-v3] Wiki generation failed (non-blocking): ${wikiErr.message}`);
     try {
       const wikiRoute = await import('../../../../../http/routes/wiki.js');
       wikiRoute.patchWikiTask?.({