autosnippet 3.3.5 → 3.3.7

package/dist/lib/external/mcp/handlers/bootstrap/pipeline/mock-pipeline.js

@@ -0,0 +1,432 @@
+/**
+ * mock-pipeline.ts — Mock AI Bootstrap 轻量管线
+ *
+ * 当 AI Provider 为 mock 时，利用 Phase 1-4 已收集的真实数据
+ * (AST、依赖图、文件列表、Panorama) 为每个维度生成模板化候选知识。
+ *
+ * 不调用 AI，但走完完整的 submit → dimension_complete 流程，
+ * 使 Dashboard 能正常展示知识库、健康雷达等 UI。
+ *
+ * @module pipeline/mock-pipeline
+ */
+import path from 'node:path';
+import Logger from '#infra/logging/Logger.js';
+import { BootstrapEventEmitter } from '#service/bootstrap/BootstrapEventEmitter.js';
+const logger = Logger.getInstance();
+// ── 模板生成器 ────────────────────────────────────────────
+/** 从 AST 指标提取代码统计 */
+function extractAstStats(ast) {
+    if (!ast) {
+        return { classes: 0, protocols: 0, functions: 0 };
+    }
+    const pm = (ast.projectMetrics ?? ast);
+    return {
+        classes: pm.totalClasses ?? 0,
+        protocols: pm.totalProtocols ?? 0,
+        functions: pm.totalFunctions ?? 0,
+    };
+}
+/** 从文件列表中按 target 分组并提取代表性文件 */
+function getRepresentativeFiles(files, targetFileMap) {
+    const result = new Map();
+    if (targetFileMap) {
+        for (const [target, paths] of Object.entries(targetFileMap)) {
+            result.set(target, paths.slice(0, 5));
+        }
+    }
+    else if (files) {
+        const grouped = new Map();
+        for (const f of files) {
+            const target = f.targetName || 'default';
+            const list = grouped.get(target) || [];
+            list.push(f.relativePath || f.name);
+            grouped.set(target, list);
+        }
+        for (const [target, paths] of grouped) {
+            result.set(target, paths.slice(0, 5));
+        }
+    }
+    return result;
+}
+/** 从文件内容中提取 import 语句（作为 headers）*/
+function extractImports(content, lang) {
+    const imports = [];
+    const lines = content.split('\n').slice(0, 30);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (lang === 'swift' && trimmed.startsWith('import ')) {
+            imports.push(trimmed);
+        }
+        else if ((lang === 'typescript' || lang === 'javascript') && trimmed.startsWith('import ')) {
+            imports.push(trimmed);
+        }
+    }
+    return [...new Set(imports)].slice(0, 5);
+}
+/** 从文件内容中提取类/结构体/协议名 */
+function extractTypes(content) {
+    const types = [];
+    for (const m of content.matchAll(/(?:class|struct|protocol|enum|interface|type)\s+(\w+)/g)) {
+        types.push(m[1]);
+    }
+    return [...new Set(types)].slice(0, 10);
+}
+/** 生成 kebab-case trigger */
+function toKebab(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '')
+        .slice(0, 40);
+}
+// ── 维度级候选生成 ────────────────────────────────────────
+/** 为单个维度生成 Mock 候选 */
+function generateDimensionCandidates(dimId, dimLabel, files, lang, projectName, astStats, targetFiles) {
+    const candidates = [];
+    // 从文件中收集有代表性的类型和源文件
+    const allTypes = [];
+    const allSources = [];
+    const allImports = [];
+    const dimFiles = files?.filter((f) => {
+        const p = f.relativePath?.toLowerCase() || f.name.toLowerCase();
+        // 根据维度 ID 做简单相关性匹配
+        switch (dimId) {
+            case 'architecture':
+                return (p.includes('coordinator') ||
+                    p.includes('delegate') ||
+                    p.includes('service') ||
+                    p.includes('manager'));
+            case 'code-pattern':
+                return p.includes('extension') || p.includes('helper') || p.includes('util');
+            case 'naming-style':
+                return true; // 全局适用
+            case 'error-handling':
+                return p.includes('error') || p.includes('result') || p.includes('handler');
+            case 'networking':
+                return (p.includes('network') ||
+                    p.includes('api') ||
+                    p.includes('request') ||
+                    p.includes('http'));
+            case 'data-model':
+                return p.includes('model') || p.includes('entity') || p.includes('dto');
+            case 'testing-quality':
+                return p.includes('test') || p.includes('spec') || p.includes('mock');
+            case 'ui-patterns':
+                return (p.includes('view') ||
+                    p.includes('controller') ||
+                    p.includes('cell') ||
+                    p.includes('component'));
+            case 'concurrency':
+                return (p.includes('actor') ||
+                    p.includes('async') ||
+                    p.includes('queue') ||
+                    p.includes('dispatch'));
+            case 'storage':
+                return (p.includes('store') ||
+                    p.includes('cache') ||
+                    p.includes('database') ||
+                    p.includes('persist'));
+            default:
+                return true;
+        }
+    }) || [];
+    // 提取文件中的类型和导入
+    for (const f of dimFiles.slice(0, 10)) {
+        allTypes.push(...extractTypes(f.content || ''));
+        allSources.push(f.relativePath || f.name);
+        allImports.push(...extractImports(f.content || '', lang));
+    }
+    // 如果没找到相关文件，用全部文件兜底
+    if (allTypes.length === 0 && files) {
+        for (const f of files.slice(0, 5)) {
+            allTypes.push(...extractTypes(f.content || ''));
+            allSources.push(f.relativePath || f.name);
+        }
+    }
+    const uniqueTypes = [...new Set(allTypes)].slice(0, 8);
+    const uniqueSources = [...new Set(allSources)].slice(0, 5);
+    const uniqueImports = [...new Set(allImports)].slice(0, 5);
+    // 为每个维度生成 3 个候选
+    const templates = getDimensionTemplates(dimId, dimLabel, uniqueTypes, uniqueSources, lang, projectName, astStats);
+    for (const tpl of templates.slice(0, 3)) {
+        candidates.push({
+            ...tpl,
+            headers: uniqueImports,
+            sourceRefs: uniqueSources.slice(0, 3),
+            reasoning: {
+                whyStandard: `基于 ${projectName} 项目 ${dimFiles.length} 个相关文件的代码分析（Mock 模式自动生成）`,
+                sources: uniqueSources.slice(0, 3),
+                confidence: 0.7,
+            },
+            tags: ['mock-generated', dimId, lang],
+        });
+    }
+    return candidates;
+}
+/** 根据维度 ID 返回候选模板 */
+function getDimensionTemplates(dimId, dimLabel, types, sources, lang, projectName, ast) {
+    const typeList = types.length > 0 ? types.slice(0, 3).join('、') : '核心模块';
+    const typeFirst = types[0] || 'AppModule';
+    const srcFirst = sources[0] || 'Sources/Main.swift';
+    const base = {
+        language: lang,
+        knowledgeType: dimId,
+    };
+    switch (dimId) {
+        case 'architecture':
+            return [
+                {
+                    ...base,
+                    title: `${projectName} 分层架构模式`,
+                    description: `项目采用分层架构，包含 ${ast.classes} 个类、${ast.protocols} 个协议`,
+                    trigger: `@${toKebab(projectName)}-layered-arch`,
+                    kind: 'pattern',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### ${projectName} 分层架构\n\n项目基于分层架构设计，核心类型包括 ${typeList}。\n\n**层次结构**:\n- 表现层: View/Controller\n- 业务层: Service/Manager\n- 数据层: Repository/Store\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ 此条目由 Mock AI 基于代码结构自动生成`,
+                        rationale: `分层架构是 ${projectName} 的核心设计决策，确保模块间关注点分离`,
+                    },
+                    coreCode: `// ${lang === 'swift' ? 'protocol' : 'interface'} ${typeFirst}Service { ... }`,
+                    doClause: `Follow the layered architecture with ${typeFirst} as the core service boundary`,
+                    dontClause: 'Do not bypass service layer to access data layer directly',
+                    whenClause: 'When adding new features or modules to the project',
+                    usageGuide: `### 使用指南\n\n遵循 ${projectName} 的分层架构进行模块设计。`,
+                },
+                {
+                    ...base,
+                    title: `${typeFirst} 依赖注入约定`,
+                    description: `${typeFirst} 等核心类型通过依赖注入管理生命周期`,
+                    trigger: `@${toKebab(typeFirst)}-di-pattern`,
+                    kind: 'pattern',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### 依赖注入约定\n\n${projectName} 使用依赖注入管理 ${typeList} 等组件的生命周期。\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '依赖注入提高可测试性和模块解耦',
+                    },
+                    coreCode: `${lang === 'swift' ? `class ${typeFirst} {\n  init(service: Service) { }\n}` : `class ${typeFirst} {\n  constructor(private service: Service) {}\n}`}`,
+                    doClause: `Use constructor injection for ${typeFirst} dependencies`,
+                    dontClause: 'Do not use service locator or global singletons',
+                    whenClause: `When creating or modifying ${typeFirst} and its dependencies`,
+                    usageGuide: `### 使用指南\n\n通过构造器注入依赖项。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 模块通信约定`,
+                    description: `模块间通过协议/接口进行通信，避免直接耦合`,
+                    trigger: `@${toKebab(projectName)}-module-comm`,
+                    kind: 'rule',
+                    category: 'Architecture',
+                    topicHint: 'architecture',
+                    content: {
+                        markdown: `### 模块通信\n\n${projectName} 的模块通信遵循接口隔离原则，${ast.protocols} 个协议定义了清晰的边界。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '接口隔离确保模块可独立演进和测试',
+                    },
+                    coreCode: `${lang === 'swift' ? `protocol ${typeFirst}Protocol {\n  func execute() async\n}` : `interface I${typeFirst} {\n  execute(): Promise<void>\n}`}`,
+                    doClause: 'Define protocols/interfaces for all cross-module communication',
+                    dontClause: 'Do not import concrete implementations across module boundaries',
+                    whenClause: 'When modules need to communicate or share data',
+                    usageGuide: `### 使用指南\n\n定义协议作为模块间通信契约。`,
+                },
+            ];
+        case 'code-pattern':
+            return [
+                {
+                    ...base,
+                    title: `${typeFirst} 扩展方法约定`,
+                    description: `使用扩展方法为 ${typeFirst} 添加功能，保持核心类型精简`,
+                    trigger: `@${toKebab(typeFirst)}-extension-pattern`,
+                    kind: 'pattern',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 扩展方法约定\n\n${projectName} 广泛使用扩展方法组织代码，${typeList} 等类型均采用此模式。\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '扩展方法使核心类型保持精简，增强可读性',
+                    },
+                    coreCode: `${lang === 'swift' ? `extension ${typeFirst} {\n  func helper() { }\n}` : `// ${typeFirst}.extensions.ts`}`,
+                    doClause: `Group related functionality in ${lang === 'swift' ? 'extensions' : 'utility modules'}`,
+                    dontClause: 'Do not bloat core types with unrelated methods',
+                    whenClause: `When adding utility or convenience methods to ${typeFirst}`,
+                    usageGuide: `### 使用指南\n\n按功能分组创建扩展文件。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 类型安全惯例`,
+                    description: `项目统一使用强类型和类型守卫确保安全`,
+                    trigger: `@${toKebab(projectName)}-type-safety`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 类型安全\n\n${projectName} 强制类型安全，包含 ${ast.classes} 个类和 ${ast.protocols} 个协议定义。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '类型安全减少运行时错误',
+                    },
+                    coreCode: `${lang === 'swift' ? 'guard let value = optional else { return }' : 'if (value === undefined) { return; }'}`,
+                    doClause: 'Use type guards and optional binding for safe access',
+                    dontClause: 'Do not use force unwrapping or type casting without checks',
+                    whenClause: 'When handling optional values or type conversions',
+                    usageGuide: `### 使用指南\n\n始终使用安全的类型转换。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} 命名约定`,
+                    description: `文件和类型命名遵循一致的约定`,
+                    trigger: `@${toKebab(projectName)}-naming-conventions`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### 命名约定\n\n${projectName} 使用一致的命名风格。类型: PascalCase, 方法/属性: camelCase。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: '统一命名提高代码可读性',
+                    },
+                    coreCode: `// ${typeFirst}.swift / ${typeFirst}.ts`,
+                    doClause: 'Follow PascalCase for types and camelCase for members',
+                    dontClause: 'Do not use abbreviations or inconsistent casing',
+                    whenClause: 'When naming new types, methods, or properties',
+                    usageGuide: `### 使用指南\n\n遵循项目既有命名风格。`,
+                },
+            ];
+        default:
+            return [
+                {
+                    ...base,
+                    title: `${projectName} ${dimLabel}实践`,
+                    description: `${dimLabel}维度的最佳实践，基于 ${typeList} 等代码分析`,
+                    trigger: `@${toKebab(projectName)}-${toKebab(dimLabel)}-practice`,
+                    kind: 'pattern',
+                    category: 'Tool',
+                    topicHint: dimId.includes('network')
+                        ? 'networking'
+                        : dimId.includes('ui')
+                            ? 'ui'
+                            : 'conventions',
+                    content: {
+                        markdown: `### ${dimLabel}\n\n${projectName} 在 ${dimLabel} 方面的实践，涉及 ${typeList} 等核心类型。\n\n**文件统计**: ${ast.classes} 类, ${ast.protocols} 协议, ${ast.functions} 函数\n\n**来源**: \`${srcFirst}\`\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `${dimLabel}是项目质量的重要维度`,
+                    },
+                    coreCode: `// See ${srcFirst}`,
+                    doClause: `Follow established ${dimLabel} patterns in the project`,
+                    dontClause: `Do not deviate from the project's ${dimLabel} conventions`,
+                    whenClause: `When working on ${dimLabel}-related code`,
+                    usageGuide: `### 使用指南\n\n遵循项目的 ${dimLabel} 约定。`,
+                },
+                {
+                    ...base,
+                    title: `${typeFirst} ${dimLabel}约定`,
+                    description: `${typeFirst} 相关的 ${dimLabel} 约定`,
+                    trigger: `@${toKebab(typeFirst)}-${toKebab(dimLabel)}`,
+                    kind: 'rule',
+                    category: 'Tool',
+                    topicHint: dimId.includes('network') ? 'networking' : 'conventions',
+                    content: {
+                        markdown: `### ${typeFirst} ${dimLabel}\n\n${typeFirst} 遵循的 ${dimLabel} 约定。\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `基于 ${typeFirst} 的实际代码模式`,
+                    },
+                    coreCode: `// ${typeFirst} — ${dimLabel}`,
+                    doClause: `Apply ${dimLabel} patterns consistent with ${typeFirst}`,
+                    dontClause: `Do not introduce inconsistent ${dimLabel} approaches`,
+                    whenClause: `When modifying ${typeFirst} or related components`,
+                    usageGuide: `### 使用指南\n\n参考 ${typeFirst} 的既有实现。`,
+                },
+                {
+                    ...base,
+                    title: `${projectName} ${dimLabel}检查清单`,
+                    description: `${dimLabel}方面的代码审查清单`,
+                    trigger: `@${toKebab(projectName)}-${toKebab(dimLabel)}-checklist`,
+                    kind: 'fact',
+                    category: 'Tool',
+                    topicHint: 'conventions',
+                    content: {
+                        markdown: `### ${dimLabel} 检查清单\n\n1. 遵循项目既有模式\n2. 确保类型安全\n3. 添加适当的错误处理\n4. 保持代码一致性\n\n> ⚠️ Mock AI 自动生成`,
+                        rationale: `${dimLabel}检查清单帮助保持代码质量`,
+                    },
+                    coreCode: `// ${dimLabel} checklist applied`,
+                    doClause: `Review code against the ${dimLabel} checklist before committing`,
+                    dontClause: `Do not skip ${dimLabel} review for shortcuts`,
+                    whenClause: `During code review for ${dimLabel}-related changes`,
+                    usageGuide: `### 使用指南\n\n在代码审查时参考此清单。`,
+                },
+            ];
+    }
+}
+// ── Mock Pipeline 入口 ────────────────────────────────────────
+/**
+ * fillDimensionsMock — Mock AI 轻量管线
+ *
+ * 利用 Phase 1-4 的真实数据（AST、文件列表、Panorama）自动生成候选知识，
+ * 不调用任何 AI API，但走完 submit → dimension_complete 的完整流程。
+ */
+export async function fillDimensionsMock(view, dimensions) {
+    const { snapshot, projectRoot } = view;
+    const ctx = view.ctx;
+    const emitter = new BootstrapEventEmitter(ctx.container);
+    const projectName = path.basename(projectRoot);
+    const primaryLang = snapshot.language.primaryLang ?? 'unknown';
+    const astStats = extractAstStats(snapshot.ast);
+    const allFiles = snapshot.allFiles;
+    const targetFileMap = view.targetFileMap;
+    const repFiles = getRepresentativeFiles(allFiles, targetFileMap);
+    logger.info(`[MockPipeline] ═══ Starting Mock bootstrap — ${dimensions.length} dimensions, ` +
+        `${allFiles?.length || 0} files, lang=${primaryLang}`);
+    emitter.emitProgress('bootstrap:mock-mode', {
+        message: '🧪 Mock AI 模式 — 基于代码结构自动生成知识候选（非 AI 深度分析）',
+        mockMode: true,
+    });
+    const knowledgeService = ctx.container.get('knowledgeService');
+    let totalCreated = 0;
+    for (const dim of dimensions) {
+        const dimStartTime = Date.now();
+        const dimLabel = dim.label ?? dim.id;
+        emitter.emitProgress('bootstrap:dimension-start', {
+            dimensionId: dim.id,
+            dimensionLabel: dimLabel,
+            mockMode: true,
+        });
+        logger.info(`[MockPipeline] ── Dimension "${dim.id}" (${dimLabel}) ──`);
+        // 生成候选
+        const candidates = generateDimensionCandidates(dim.id, dimLabel, allFiles, primaryLang, projectName, astStats, repFiles);
+        const createdIds = [];
+        for (const candidate of candidates) {
+            try {
+                const entry = await knowledgeService.create({
+                    ...candidate,
+                    source: 'mock-bootstrap',
+                }, { userId: 'mock-ai' });
+                createdIds.push(entry.id);
+                totalCreated++;
+                // 尝试自动评分（非关键路径）
+                try {
+                    await knowledgeService.updateQuality?.(entry.id, { userId: 'mock-ai' });
+                }
+                catch {
+                    /* best effort */
+                }
+                logger.info(`[MockPipeline] ✅ Created: "${candidate.title}" → ${entry.id}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.warn(`[MockPipeline] ⚠️ Failed to create "${candidate.title}": ${msg}`);
+            }
+        }
+        const durationMs = Date.now() - dimStartTime;
+        emitter.emitDimensionComplete(dim.id, {
+            type: 'candidate',
+            extracted: candidates.length,
+            created: createdIds.length,
+            status: 'mock-pipeline-complete',
+            degraded: false,
+            durationMs,
+            toolCallCount: 0,
+            source: 'mock-pipeline',
+        });
+        logger.info(`[MockPipeline] ✅ "${dim.id}": ${createdIds.length}/${candidates.length} candidates, ${durationMs}ms`);
+    }
+    emitter.emitProgress('bootstrap:mock-complete', {
+        message: `🧪 Mock Bootstrap 完成: ${totalCreated} 个候选知识已生成`,
+        totalCreated,
+        mockMode: true,
+    });
+    logger.info(`[MockPipeline] ═══ Mock bootstrap complete — ${totalCreated} candidates from ${dimensions.length} dimensions`);
+}

package/dist/lib/external/mcp/handlers/bootstrap/pipeline/orchestrator.d.ts

@@ -13,28 +13,115 @@
  *
  * @module pipeline/orchestrator
  */
+import type { DimensionDef } from '#types/project-snapshot.js';
+import type { PipelineFillView } from '#types/snapshot-views.js';
 import { clearCheckpoints } from './checkpoint.js';
-/** Extended DI container shape for orchestrator (supports buildProjectGraph etc.) */
+/** Singleton properties accessed by orchestrator */
+interface OrchestratorSingletons {
+    aiProvider?: {
+        name?: string;
+        model?: string;
+        supportsEmbedding?: () => boolean;
+        [key: string]: unknown;
+    } | null;
+    _embedProvider?: {
+        embed?: (text: string) => Promise<number[]>;
+        [key: string]: unknown;
+    } | null;
+    _fileCache?: BootstrapFileEntry[] | null;
+    _projectRoot?: string;
+    _config?: Record<string, unknown>;
+    _lang?: string | null;
+    [key: string]: unknown;
+}
+/** Services orchestrator accesses via container.get() */
+interface OrchestratorServiceKeys {
+    agentFactory: AgentFactoryLike;
+    bootstrapTaskManager: TaskManagerLike;
+    database: any;
+}
+/** Extended DI container shape for orchestrator */
 interface OrchestratorContainer {
+    get<K extends keyof OrchestratorServiceKeys>(name: K): OrchestratorServiceKeys[K];
     get(name: string): any;
-    [key: string]: any;
+    singletons: OrchestratorSingletons;
+    buildProjectGraph?(projectRoot: string, options?: Record<string, unknown>): Promise<ProjectGraphLike | null>;
+    [key: string]: unknown;
 }
-/** Orchestrator context (extended McpContext) */
-interface OrchestratorContext {
-    container: OrchestratorContainer;
-    [key: string]: any;
+/** ProjectGraph minimal shape */
+interface ProjectGraphLike {
+    getOverview(): {
+        totalClasses: number;
+        totalProtocols: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/** Bootstrap file entry */
+interface BootstrapFileEntry {
+    name: string;
+    path: string;
+    relativePath: string;
+    content: string;
+    targetName?: string;
+}
+/** Task manager minimal shape */
+interface TaskManagerLike {
+    isSessionValid(sessionId: string): boolean;
+    emitProgress?(event: string, data: Record<string, unknown>): void;
+    [key: string]: unknown;
+}
+/** Agent factory minimal shape */
+interface AgentFactoryLike {
+    createRuntime(preset: string, overrides?: Record<string, unknown>): AgentRuntimeLike;
+    createContextWindow(opts?: {
+        isSystem?: boolean;
+    }): unknown;
+    [key: string]: unknown;
+}
+/** Agent runtime minimal shape */
+interface AgentRuntimeLike {
+    execute(message: unknown, opts?: Record<string, unknown>): Promise<AgentResultLike>;
+    setFileCache(files: unknown[] | null): void;
+    aiProvider: {
+        name?: string;
+        model?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/** Agent execution result */
+interface AgentResultLike {
+    reply?: string;
+    toolCalls?: ToolCallRecord[];
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    phases?: Record<string, {
+        reply?: string;
+        artifact?: Record<string, any>;
+        [key: string]: any;
+    }>;
+    degraded?: boolean;
+    [key: string]: unknown;
 }
-/** Fill context passed from bootstrapKnowledge to fillDimensionsV3 */
-interface FillContextV3 {
-    ctx: OrchestratorContext;
-    [key: string]: any;
+/** Tool call record from runtime */
+interface ToolCallRecord {
+    tool?: string;
+    name?: string;
+    args?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+    result?: unknown;
+    [key: string]: unknown;
 }
 /**
  * fillDimensionsV3 — v3.0 AI-First 维度填充管线
  *
- * @param fillContext 由 bootstrapKnowledge 构建的上下文
+ * @param view PipelineFillView — 从 handler 传入的类型化视图
+ * @param dimensions 当前运行的维度列表（rescan 可能是 gap 子集）
  */
-export declare function fillDimensionsV3(fillContext: FillContextV3): Promise<void>;
+export declare function fillDimensionsV3(view: PipelineFillView, dimensions: DimensionDef[]): Promise<void>;
 /**
  * 清除增量 Bootstrap 快照 — 供 bootstrapKnowledge 在手动冷启动时调用
  * @param ctx { container, logger }