autosnippet 3.3.0 → 3.3.3

package/dist/lib/agent/forge/ToolForge.d.ts

@@ -0,0 +1,92 @@
+/**
+ * ToolForge — 工具锻造主编排器
+ *
+ * 三级锻造策略：
+ *   Reuse (0ms)   → 直接重用注册表中已有工具
+ *   Compose (10ms) → 通过 DynamicComposer 组合已有原子工具
+ *   Generate (5s)  → LLM 生成工具代码 → SandboxRunner 验证 → 注册
+ *
+ * 瀑布逻辑：reuse → compose → generate，首个成功即返回。
+ */
+import type { SignalBus } from '#infra/signal/SignalBus.js';
+import type { CompositionSpec } from './DynamicComposer.js';
+import type { SandboxTestCase } from './SandboxRunner.js';
+import { TemporaryToolRegistry } from './TemporaryToolRegistry.js';
+import type { AnalysisResult, ToolRequirement } from './ToolRequirementAnalyzer.js';
+import { ToolRequirementAnalyzer } from './ToolRequirementAnalyzer.js';
+interface ToolRegistryLike {
+    has(name: string): boolean;
+    getToolNames(): string[];
+    execute(name: string, params: Record<string, unknown>, context?: Record<string, unknown>): Promise<unknown>;
+    register(toolDef: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+        handler: Function;
+    }): void;
+    unregister(name: string): boolean;
+}
+export interface ForgeRequest {
+    /** 用户意图 */
+    intent: string;
+    /** 关键动作 */
+    action: string;
+    /** 目标对象 */
+    target: string;
+    /** 约束条件 */
+    constraints?: string[];
+    /** LLM 代码生成回调 — 仅 generate 模式时调用 */
+    codeGenerator?: (requirement: ToolRequirement) => Promise<GeneratedTool | null>;
+}
+export interface GeneratedTool {
+    /** 工具名 */
+    name: string;
+    /** 描述 */
+    description: string;
+    /** JSON Schema 参数 */
+    parameters: Record<string, unknown>;
+    /** 工具代码（需包含 toolHandler 函数） */
+    code: string;
+    /** 测试用例 */
+    testCases: SandboxTestCase[];
+}
+export interface ForgeResult {
+    /** 是否成功 */
+    success: boolean;
+    /** 使用的模式 */
+    mode: 'reuse' | 'compose' | 'generate';
+    /** 工具名称 */
+    toolName?: string;
+    /** 需求分析结果 */
+    analysis: AnalysisResult;
+    /** 失败原因 */
+    error?: string;
+}
+export interface ToolForgeOptions {
+    signalBus?: SignalBus;
+    /** 生成工具的默认 TTL（ms），默认 30 分钟 */
+    defaultTtlMs?: number;
+    /** compose 模式下的组合 spec 生成器 */
+    compositionSpecBuilder?: (analysis: AnalysisResult, requirement: ToolRequirement) => CompositionSpec | null;
+}
+export declare class ToolForge {
+    #private;
+    constructor(registry: ToolRegistryLike, options?: ToolForgeOptions);
+    /**
+     * 锻造工具 — 瀑布流：reuse → compose → generate
+     */
+    forge(request: ForgeRequest): Promise<ForgeResult>;
+    /**
+     * 获取临时工具注册表（暴露给 Pipeline 集成用）
+     */
+    get temporaryRegistry(): TemporaryToolRegistry;
+    /**
+     * 获取分析器
+     */
+    get analyzer(): ToolRequirementAnalyzer;
+    /**
+     * 销毁 Forge（清理临时工具和定时器）
+     */
+    dispose(): void;
+}
+export {};

package/dist/lib/agent/forge/ToolForge.js

@@ -0,0 +1,239 @@
+/**
+ * ToolForge — 工具锻造主编排器
+ *
+ * 三级锻造策略：
+ *   Reuse (0ms)   → 直接重用注册表中已有工具
+ *   Compose (10ms) → 通过 DynamicComposer 组合已有原子工具
+ *   Generate (5s)  → LLM 生成工具代码 → SandboxRunner 验证 → 注册
+ *
+ * 瀑布逻辑：reuse → compose → generate，首个成功即返回。
+ */
+import Logger from '#infra/logging/Logger.js';
+import { DynamicComposer } from './DynamicComposer.js';
+import { SandboxRunner } from './SandboxRunner.js';
+import { TemporaryToolRegistry } from './TemporaryToolRegistry.js';
+import { ToolRequirementAnalyzer } from './ToolRequirementAnalyzer.js';
+/* ────────────────────── Class ────────────────────── */
+export class ToolForge {
+    #registry;
+    #analyzer;
+    #composer;
+    #sandbox;
+    #tempRegistry;
+    #signalBus;
+    #logger = Logger.getInstance();
+    #defaultTtlMs;
+    #compositionSpecBuilder;
+    constructor(registry, options = {}) {
+        this.#registry = registry;
+        this.#signalBus = options.signalBus ?? null;
+        this.#defaultTtlMs = options.defaultTtlMs ?? 30 * 60 * 1000;
+        this.#compositionSpecBuilder = options.compositionSpecBuilder;
+        this.#analyzer = new ToolRequirementAnalyzer(registry);
+        this.#composer = new DynamicComposer(registry);
+        this.#sandbox = new SandboxRunner();
+        this.#tempRegistry = new TemporaryToolRegistry(registry, {
+            signalBus: this.#signalBus ?? undefined,
+        });
+    }
+    /* ────────── Public API ────────── */
+    /**
+     * 锻造工具 — 瀑布流：reuse → compose → generate
+     */
+    async forge(request) {
+        const requirement = {
+            intent: request.intent,
+            action: request.action,
+            target: request.target,
+            constraints: request.constraints,
+        };
+        // Step 1: 需求分析
+        const analysis = this.#analyzer.analyze(requirement);
+        this.#logger.info(`ToolForge: analysis for "${request.intent}" → mode=${analysis.mode}, confidence=${analysis.confidence}`);
+        // Step 2: 按推荐模式尝试，失败则降级
+        const result = (await this.#tryReuse(analysis, requirement)) ??
+            (await this.#tryCompose(analysis, requirement)) ??
+            (await this.#tryGenerate(analysis, requirement, request.codeGenerator));
+        if (result) {
+            this.#emitSignal('forge_complete', {
+                mode: result.mode,
+                tool: result.toolName,
+                analysis,
+            });
+            return result;
+        }
+        // 全部失败
+        return {
+            success: false,
+            mode: 'generate',
+            analysis,
+            error: 'All forge modes exhausted. Cannot satisfy tool requirement.',
+        };
+    }
+    /**
+     * 获取临时工具注册表（暴露给 Pipeline 集成用）
+     */
+    get temporaryRegistry() {
+        return this.#tempRegistry;
+    }
+    /**
+     * 获取分析器
+     */
+    get analyzer() {
+        return this.#analyzer;
+    }
+    /**
+     * 销毁 Forge（清理临时工具和定时器）
+     */
+    dispose() {
+        this.#tempRegistry.dispose();
+    }
+    /* ────────── Forge Modes ────────── */
+    async #tryReuse(analysis, _requirement) {
+        if (analysis.mode !== 'reuse' || !analysis.matchedTool) {
+            // 即便分析推荐 compose/generate，也尝试检查直接匹配
+            if (analysis.matchedTool && this.#registry.has(analysis.matchedTool)) {
+                return {
+                    success: true,
+                    mode: 'reuse',
+                    toolName: analysis.matchedTool,
+                    analysis,
+                };
+            }
+            return null;
+        }
+        if (!this.#registry.has(analysis.matchedTool)) {
+            return null;
+        }
+        this.#logger.debug(`ToolForge: reuse existing tool "${analysis.matchedTool}"`);
+        return {
+            success: true,
+            mode: 'reuse',
+            toolName: analysis.matchedTool,
+            analysis,
+        };
+    }
+    async #tryCompose(analysis, requirement) {
+        if (!analysis.composableTools || analysis.composableTools.length < 2) {
+            return null;
+        }
+        // 如果有外部 spec builder，使用它
+        const spec = this.#compositionSpecBuilder?.(analysis, requirement);
+        if (!spec) {
+            // 默认构建 sequential 组合
+            const defaultSpec = this.#buildDefaultCompositionSpec(analysis, requirement);
+            if (!defaultSpec) {
+                return null;
+            }
+            return this.#executeComposition(defaultSpec, analysis);
+        }
+        return this.#executeComposition(spec, analysis);
+    }
+    #buildDefaultCompositionSpec(analysis, requirement) {
+        const tools = analysis.composableTools;
+        if (!tools || tools.length < 2) {
+            return null;
+        }
+        const composedName = `composed_${requirement.action}_${requirement.target}`;
+        return {
+            name: composedName,
+            description: `Auto-composed tool for: ${requirement.intent}`,
+            steps: tools.map((tool) => ({
+                tool,
+                args: (prevResult) => {
+                    if (typeof prevResult === 'object' && prevResult !== null) {
+                        return prevResult;
+                    }
+                    return {};
+                },
+            })),
+            mergeStrategy: 'sequential',
+        };
+    }
+    async #executeComposition(spec, analysis) {
+        const result = this.#composer.compose(spec);
+        if (!result.success || !result.handler) {
+            this.#logger.debug(`ToolForge: composition failed — ${result.error}`);
+            return null;
+        }
+        // 注册为临时工具
+        this.#tempRegistry.registerTemporary({
+            name: spec.name,
+            description: spec.description,
+            parameters: spec.parameters ?? {},
+            handler: result.handler,
+            forgeMode: 'compose',
+        }, this.#defaultTtlMs);
+        this.#logger.info(`ToolForge: composed tool "${spec.name}" from ${spec.steps.length} steps`);
+        return {
+            success: true,
+            mode: 'compose',
+            toolName: spec.name,
+            analysis,
+        };
+    }
+    async #tryGenerate(analysis, requirement, codeGenerator) {
+        if (!codeGenerator) {
+            this.#logger.debug('ToolForge: generate mode skipped (no codeGenerator provided)');
+            return null;
+        }
+        // 调用 LLM 生成工具
+        const generated = await codeGenerator(requirement);
+        if (!generated) {
+            return null;
+        }
+        // 安全检查
+        const safety = this.#sandbox.checkSafety(generated.code);
+        if (!safety.passed) {
+            this.#logger.warn(`ToolForge: generated code failed safety check — ${safety.violations.join(', ')}`);
+            return {
+                success: false,
+                mode: 'generate',
+                analysis,
+                error: `Safety violations: ${safety.violations.join(', ')}`,
+            };
+        }
+        // 沙箱测试
+        if (generated.testCases.length > 0) {
+            const testResult = await this.#sandbox.run(generated.code, generated.testCases);
+            if (!testResult.success) {
+                const failures = testResult.testResults
+                    .filter((t) => !t.passed)
+                    .map((t) => t.description)
+                    .join(', ');
+                this.#logger.warn(`ToolForge: generated code failed tests — ${failures}`);
+                return {
+                    success: false,
+                    mode: 'generate',
+                    analysis,
+                    error: `Test failures: ${failures}`,
+                };
+            }
+        }
+        // 构建 handler 包装
+        const handler = this.#sandbox.createHandler(generated.code);
+        // 注册为临时工具
+        this.#tempRegistry.registerTemporary({
+            name: generated.name,
+            description: generated.description,
+            parameters: generated.parameters,
+            handler,
+            forgeMode: 'generate',
+        }, this.#defaultTtlMs);
+        this.#logger.info(`ToolForge: generated and registered tool "${generated.name}"`);
+        return {
+            success: true,
+            mode: 'generate',
+            toolName: generated.name,
+            analysis,
+        };
+    }
+    /* ────────── Signal ────────── */
+    #emitSignal(action, data) {
+        if (this.#signalBus) {
+            this.#signalBus.send('forge', 'ToolForge', 1, {
+                metadata: { action, ...data },
+            });
+        }
+    }
+}

package/dist/lib/agent/forge/ToolRequirementAnalyzer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ToolRequirementAnalyzer — 工具需求分析器
+ *
+ * 分析结构化意图，确定满足需求的最佳路径：
+ *   1. Reuse  — 注册表中已有完全匹配的工具
+ *   2. Compose — 可通过组合已有工具满足
+ *   3. Generate — 必须由 LLM 生成新工具代码
+ */
+interface ToolRegistryLike {
+    has(name: string): boolean;
+    getToolNames(): string[];
+}
+export interface ToolRequirement {
+    /** 用户意图描述 */
+    intent: string;
+    /** 关键动作词（如 read / search / transform / validate） */
+    action: string;
+    /** 目标对象（如 file / database / API） */
+    target: string;
+    /** 附加约束 */
+    constraints?: string[];
+}
+export type ForgeMode = 'reuse' | 'compose' | 'generate';
+export interface AnalysisResult {
+    /** 推荐的 Forge 模式 */
+    mode: ForgeMode;
+    /** 置信度 0-1 */
+    confidence: number;
+    /** 推理理由 */
+    reasoning: string;
+    /** mode=reuse 时：匹配的工具名 */
+    matchedTool?: string;
+    /** mode=compose 时：建议参与组合的工具列表 */
+    composableTools?: string[];
+}
+export declare class ToolRequirementAnalyzer {
+    #private;
+    constructor(registry: ToolRegistryLike);
+    /**
+     * 分析需求并推荐 Forge 模式
+     */
+    analyze(requirement: ToolRequirement): AnalysisResult;
+}
+export {};

package/dist/lib/agent/forge/ToolRequirementAnalyzer.js

@@ -0,0 +1,119 @@
+/**
+ * ToolRequirementAnalyzer — 工具需求分析器
+ *
+ * 分析结构化意图，确定满足需求的最佳路径：
+ *   1. Reuse  — 注册表中已有完全匹配的工具
+ *   2. Compose — 可通过组合已有工具满足
+ *   3. Generate — 必须由 LLM 生成新工具代码
+ */
+import Logger from '#infra/logging/Logger.js';
+/* ────────────── Action → Tool Keyword mapping ────────────── */
+const ACTION_TOOL_HINTS = {
+    read: ['read', 'get', 'fetch', 'load', 'file'],
+    search: ['search', 'find', 'query', 'lookup'],
+    write: ['write', 'save', 'create', 'update', 'set'],
+    delete: ['delete', 'remove', 'clear'],
+    transform: ['transform', 'convert', 'parse', 'format'],
+    validate: ['validate', 'check', 'guard', 'lint'],
+    analyse: ['analyze', 'analyse', 'inspect', 'stats'],
+    list: ['list', 'browse', 'enumerate'],
+    execute: ['execute', 'run', 'invoke', 'call'],
+};
+/* ────────────────────── Class ────────────────────── */
+export class ToolRequirementAnalyzer {
+    #registry;
+    #logger = Logger.getInstance();
+    constructor(registry) {
+        this.#registry = registry;
+    }
+    /**
+     * 分析需求并推荐 Forge 模式
+     */
+    analyze(requirement) {
+        // 1. 尝试精确匹配
+        const exactMatch = this.#tryExactMatch(requirement);
+        if (exactMatch) {
+            return exactMatch;
+        }
+        // 2. 尝试组合匹配
+        const composeMatch = this.#tryComposeMatch(requirement);
+        if (composeMatch) {
+            return composeMatch;
+        }
+        // 3. Fallback: 需要生成
+        return {
+            mode: 'generate',
+            confidence: 0.5,
+            reasoning: `No existing tool matches "${requirement.action} ${requirement.target}". Code generation required.`,
+        };
+    }
+    /* ── Internal ── */
+    #tryExactMatch(req) {
+        // 直接检查 action_target 形式的工具名
+        const directName = `${req.action}_${req.target}`.toLowerCase();
+        if (this.#registry.has(directName)) {
+            return {
+                mode: 'reuse',
+                confidence: 1.0,
+                reasoning: `Exact tool match: "${directName}"`,
+                matchedTool: directName,
+            };
+        }
+        // 模糊匹配：遍历已注册工具，看名称是否同时包含 action 和 target 关键词
+        const allTools = this.#registry.getToolNames();
+        const actionLower = req.action.toLowerCase();
+        const targetLower = req.target.toLowerCase();
+        for (const tool of allTools) {
+            const toolLower = tool.toLowerCase();
+            if (toolLower.includes(actionLower) && toolLower.includes(targetLower)) {
+                return {
+                    mode: 'reuse',
+                    confidence: 0.85,
+                    reasoning: `Fuzzy match: tool "${tool}" contains both "${req.action}" and "${req.target}"`,
+                    matchedTool: tool,
+                };
+            }
+        }
+        // 通过 action hint 词尝试
+        const hints = ACTION_TOOL_HINTS[actionLower] ?? [actionLower];
+        for (const tool of allTools) {
+            const toolLower = tool.toLowerCase();
+            const matchesHint = hints.some((h) => toolLower.includes(h));
+            const matchesTarget = toolLower.includes(targetLower);
+            if (matchesHint && matchesTarget) {
+                return {
+                    mode: 'reuse',
+                    confidence: 0.7,
+                    reasoning: `Hint match: tool "${tool}" matches action hint and target "${req.target}"`,
+                    matchedTool: tool,
+                };
+            }
+        }
+        return null;
+    }
+    #tryComposeMatch(req) {
+        const allTools = this.#registry.getToolNames();
+        const actionLower = req.action.toLowerCase();
+        const targetLower = req.target.toLowerCase();
+        const hints = ACTION_TOOL_HINTS[actionLower] ?? [actionLower];
+        // 寻找和 action 相关的工具
+        const actionRelated = allTools.filter((t) => {
+            const tl = t.toLowerCase();
+            return hints.some((h) => tl.includes(h));
+        });
+        // 寻找和 target 相关的工具
+        const targetRelated = allTools.filter((t) => t.toLowerCase().includes(targetLower));
+        // 取并集
+        const candidates = [...new Set([...actionRelated, ...targetRelated])];
+        if (candidates.length >= 2) {
+            this.#logger.debug(`ToolRequirementAnalyzer: compose candidates for "${req.intent}": ${candidates.join(', ')}`);
+            return {
+                mode: 'compose',
+                confidence: 0.65,
+                reasoning: `Found ${candidates.length} composable tools for "${req.action} ${req.target}"`,
+                composableTools: candidates.slice(0, 5),
+            };
+        }
+        return null;
+    }
+}

package/dist/lib/agent/tools/ToolRegistry.d.ts

@@ -46,6 +46,8 @@ export declare class ToolRegistry {
     execute(name: string, params: Record<string, unknown>, context?: Record<string, unknown>): Promise<unknown>;
     /** 检查工具是否存在 */
     has(name: string): boolean;
+    /** 移除一个已注册的工具（Forge TTL 回收用） */
+    unregister(name: string): boolean;
     /** 获取所有工具名 */
     getToolNames(): string[];
     /** 工具数量 */

package/dist/lib/agent/tools/ToolRegistry.js

@@ -174,6 +174,10 @@ export class ToolRegistry {
     has(name) {
         return this.#tools.has(name);
     }
+    /** 移除一个已注册的工具（Forge TTL 回收用） */
+    unregister(name) {
+        return this.#tools.delete(name);
+    }
     /** 获取所有工具名 */
     getToolNames() {
         return [...this.#tools.keys()];

package/dist/lib/agent/tools/composite.js

@@ -214,7 +214,6 @@ export const submitWithCheck = {
                     existingFingerprints: ctx._submittedPatterns || new Set(),
                 });
             const validResult = validator.validate(params, {
-                mode: 'strict',
                 systemInjectedFields: getSystemInjectedFields(),
             });
             if (!validResult.pass) {

package/dist/lib/agent/tools/index.d.ts

@@ -9,12 +9,12 @@ import { analyzeCode, getToolDetails, knowledgeOverview, planTask, reviewMyOutpu
 import { getRecommendations, guardCheckCode, listGuardRules, queryViolations } from './guard.js';
 import { bootstrapKnowledgeTool, createSkillTool, graphImpactAnalysis, loadSkill, queryAuditLog, rebuildIndex, suggestSkills } from './infrastructure.js';
 import { addGraphEdge, checkDuplicate } from './knowledge-graph.js';
-import { approveCandidate, deprecateRecipe, getFeedbackStats, publishRecipe, qualityScore, recordUsage, rejectCandidate, saveDocument, submitCandidate, updateRecipe, validateCandidate } from './lifecycle.js';
+import { approveCandidate, deprecateRecipe, getFeedbackStats, publishRecipe, qualityScore, recordUsage, rejectCandidate, submitCandidate, updateRecipe, validateCandidate } from './lifecycle.js';
 import { getFileSummary, listProjectStructure, readProjectFile, searchProjectCode, semanticSearchCode } from './project-access.js';
 import { getProjectStats, getRecipeDetail, getRelatedRecipes, searchCandidates, searchKnowledge, searchRecipes } from './query.js';
 import { collectScanRecipe } from './scan-recipe.js';
 import { getEnvironmentInfo, runSafeCommand, writeProjectFile } from './system-interaction.js';
-export { searchProjectCode, readProjectFile, listProjectStructure, getFileSummary, semanticSearchCode, searchRecipes, searchCandidates, getRecipeDetail, getProjectStats, searchKnowledge, getRelatedRecipes, enrichCandidate, refineBootstrapCandidates, listGuardRules, getRecommendations, guardCheckCode, queryViolations, checkDuplicate, addGraphEdge, submitCandidate, saveDocument, approveCandidate, rejectCandidate, publishRecipe, deprecateRecipe, updateRecipe, recordUsage, qualityScore, validateCandidate, getFeedbackStats, graphImpactAnalysis, rebuildIndex, queryAuditLog, loadSkill, createSkillTool, suggestSkills, bootstrapKnowledgeTool, analyzeCode, knowledgeOverview, submitWithCheck, getToolDetails, planTask, reviewMyOutput, getProjectOverview, getClassHierarchy, getClassInfo, getProtocolInfo, getMethodOverrides, getCategoryMap, getPreviousAnalysis, noteFinding, getPreviousEvidence, queryCodeGraph, queryCallGraph, collectScanRecipe, runSafeCommand, writeProjectFile, getEnvironmentInfo, };
+export { searchProjectCode, readProjectFile, listProjectStructure, getFileSummary, semanticSearchCode, searchRecipes, searchCandidates, getRecipeDetail, getProjectStats, searchKnowledge, getRelatedRecipes, enrichCandidate, refineBootstrapCandidates, listGuardRules, getRecommendations, guardCheckCode, queryViolations, checkDuplicate, addGraphEdge, submitCandidate, approveCandidate, rejectCandidate, publishRecipe, deprecateRecipe, updateRecipe, recordUsage, qualityScore, validateCandidate, getFeedbackStats, graphImpactAnalysis, rebuildIndex, queryAuditLog, loadSkill, createSkillTool, suggestSkills, bootstrapKnowledgeTool, analyzeCode, knowledgeOverview, submitWithCheck, getToolDetails, planTask, reviewMyOutput, getProjectOverview, getClassHierarchy, getClassInfo, getProtocolInfo, getMethodOverrides, getCategoryMap, getPreviousAnalysis, noteFinding, getPreviousEvidence, queryCodeGraph, queryCallGraph, collectScanRecipe, runSafeCommand, writeProjectFile, getEnvironmentInfo, };
 export declare const ALL_TOOLS: ({
     name: string;
     description: string;
@@ -1028,54 +1028,6 @@ export declare const ALL_TOOLS: ({
         required: string[];
     };
     handler: (params: import("./lifecycle.js").SubmitKnowledgeParams, ctx: import("./_shared.js").ToolHandlerContext) => Promise<any>;
-} | {
-    name: string;
-    description: string;
-    parameters: {
-        type: string;
-        properties: {
-            title: {
-                type: string;
-                description: string;
-            };
-            markdown: {
-                type: string;
-                description: string;
-            };
-            description: {
-                type: string;
-                description: string;
-            };
-            tags: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            scope: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    handler: (params: import("./lifecycle.js").SaveDocumentParams, ctx: import("./_shared.js").ToolHandlerContext) => Promise<{
-        error: boolean;
-        message: string;
-        id?: undefined;
-        title?: undefined;
-        lifecycle?: undefined;
-        knowledgeType?: undefined;
-    } | {
-        id: any;
-        title: any;
-        lifecycle: string;
-        knowledgeType: string;
-        message: string;
-        error?: undefined;
-    }>;
 } | {
     name: string;
     description: string;

package/dist/lib/agent/tools/index.js

@@ -16,7 +16,7 @@ import { bootstrapKnowledgeTool, createSkillTool, graphImpactAnalysis, loadSkill
 // ── 知识图谱类 (2) ──
 import { addGraphEdge, checkDuplicate } from './knowledge-graph.js';
 // ── 生命周期操作类 (11) ──
-import { approveCandidate, deprecateRecipe, getFeedbackStats, publishRecipe, qualityScore, recordUsage, rejectCandidate, saveDocument, submitCandidate, updateRecipe, validateCandidate, } from './lifecycle.js';
+import { approveCandidate, deprecateRecipe, getFeedbackStats, publishRecipe, qualityScore, recordUsage, rejectCandidate, submitCandidate, updateRecipe, validateCandidate, } from './lifecycle.js';
 // ── 项目数据访问 (5) ──
 import { getFileSummary, listProjectStructure, readProjectFile, searchProjectCode, semanticSearchCode, } from './project-access.js';
 // ── 查询类 (6) ──
@@ -38,7 +38,7 @@ listGuardRules, getRecommendations, guardCheckCode, queryViolations,
 // 知识图谱类
 checkDuplicate, addGraphEdge, 
 // 生命周期操作类
-submitCandidate, saveDocument, approveCandidate, rejectCandidate, publishRecipe, deprecateRecipe, updateRecipe, recordUsage, qualityScore, validateCandidate, getFeedbackStats, 
+submitCandidate, approveCandidate, rejectCandidate, publishRecipe, deprecateRecipe, updateRecipe, recordUsage, qualityScore, validateCandidate, getFeedbackStats, 
 // 基础设施类
 graphImpactAnalysis, rebuildIndex, queryAuditLog, loadSkill, createSkillTool, suggestSkills, bootstrapKnowledgeTool, 
 // 组合工具 + 元工具
@@ -80,7 +80,6 @@ export const ALL_TOOLS = [
     queryViolations,
     // 生命周期操作类 (7)
     submitCandidate,
-    saveDocument,
     approveCandidate,
     rejectCandidate,
     publishRecipe,