@jack200714/mafw 4.5.1

package/gateway/dist/core/mcp/validator.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGoalCreation = validateGoalCreation;
+exports.validatePhaseCompletion = validatePhaseCompletion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Validate that a goal creation request has all required artifacts.
+ * Checks: goals/{goalId}.md and requests/{goalId}.json exist and are non-empty.
+ */
+async function validateGoalCreation(goalId, projectDir = '.') {
+    const errors = [];
+    const warnings = [];
+    const goalsDir = path.join(projectDir, '.mafw/goals');
+    const requestsDir = path.join(projectDir, '.mafw/requests');
+    const charterPath = path.join(goalsDir, `${goalId}.md`);
+    const requestPath = path.join(requestsDir, `${goalId}.json`);
+    // Validate charter file
+    if (!fs.existsSync(charterPath)) {
+        errors.push(`Goal charter not found: ${charterPath}`);
+    }
+    else {
+        const stat = fs.statSync(charterPath);
+        if (stat.size === 0) {
+            warnings.push(`Goal charter is empty: ${charterPath}`);
+        }
+    }
+    // Validate request file
+    if (!fs.existsSync(requestPath)) {
+        errors.push(`Goal request file not found: ${requestPath}`);
+    }
+    else {
+        try {
+            const content = fs.readFileSync(requestPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (!parsed.goalId || parsed.goalId !== goalId) {
+                errors.push(`Request file goalId mismatch: expected "${goalId}", got "${parsed.goalId}"`);
+            }
+            if (!parsed.title) {
+                warnings.push('Request file missing title');
+            }
+            if (!parsed.maxLoops || parsed.maxLoops < 1) {
+                warnings.push('Request file maxLoops is missing or less than 1');
+            }
+        }
+        catch (err) {
+            errors.push(`Request file is invalid JSON: ${err.message}`);
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Validate that a phase has all required completion artifacts.
+ * - PLANNING: waves.json must exist with at least one wave
+ * - EXECUTING: receipts/{goalId}/ must contain at least one file
+ * - REVIEWING: reviews/{goalId}-loop*.md must exist for current loop
+ */
+async function validatePhaseCompletion(goalId, phase, projectDir = '.', loopNum = 1) {
+    const errors = [];
+    const warnings = [];
+    switch (phase.toUpperCase()) {
+        case 'PLANNING': {
+            const wavesPath = path.join(projectDir, '.mafw/waves.json');
+            if (!fs.existsSync(wavesPath)) {
+                errors.push(`Waves file not found: ${wavesPath}`);
+            }
+            else {
+                try {
+                    const content = JSON.parse(fs.readFileSync(wavesPath, 'utf-8'));
+                    const waves = content.waves || [];
+                    if (waves.length === 0) {
+                        errors.push('Waves file contains no waves');
+                    }
+                }
+                catch (err) {
+                    errors.push(`Waves file is invalid JSON: ${err.message}`);
+                }
+            }
+            break;
+        }
+        case 'EXECUTING': {
+            const receiptsDir = path.join(projectDir, '.mafw/receipts', goalId);
+            if (!fs.existsSync(receiptsDir)) {
+                errors.push(`Receipts directory not found: ${receiptsDir}`);
+            }
+            else {
+                const files = fs.readdirSync(receiptsDir).filter(f => f.endsWith('.json'));
+                if (files.length === 0) {
+                    errors.push(`No receipt files found in ${receiptsDir}`);
+                }
+                for (const file of files) {
+                    try {
+                        const content = JSON.parse(fs.readFileSync(path.join(receiptsDir, file), 'utf-8'));
+                        if (!content.taskId && !content.waveNum) {
+                            warnings.push(`Receipt ${file} missing taskId or waveNum`);
+                        }
+                    }
+                    catch {
+                        warnings.push(`Receipt ${file} is not valid JSON`);
+                    }
+                }
+            }
+            break;
+        }
+        case 'REVIEWING': {
+            const reviewsDir = path.join(projectDir, '.mafw/reviews');
+            if (!fs.existsSync(reviewsDir)) {
+                errors.push(`Reviews directory not found: ${reviewsDir}`);
+            }
+            else {
+                const pattern = `${goalId}-loop${loopNum}.md`;
+                const reviewPath = path.join(reviewsDir, pattern);
+                if (!fs.existsSync(reviewPath)) {
+                    errors.push(`Review file not found: ${reviewPath}`);
+                }
+                else {
+                    const content = fs.readFileSync(reviewPath, 'utf-8');
+                    if (content.trim().length === 0) {
+                        warnings.push(`Review file is empty: ${reviewPath}`);
+                    }
+                    if (!content.includes('verdict') && !content.includes('Verdict') && !content.includes('Score') && !content.includes('score')) {
+                        warnings.push(`Review file may be missing verdict or score: ${reviewPath}`);
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            errors.push(`Unknown phase: ${phase}. Valid phases: PLANNING, EXECUTING, REVIEWING`);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/gateway/dist/core/mcp-server.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./utils/logger");
+/**
+ * @deprecated MCP Server is now embedded in Gateway via SSE transport.
+ * This file is kept for ENABLE_LEGACY_MCP fallback only.
+ * See gateway/src/mcp/sse-transport.ts for the active implementation.
+ * Will be removed in next major version.
+ */
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const path = __importStar(require("path"));
+const harmonic_index_1 = require("./memory/harmonic-index");
+const knowledge_graph_manager_1 = require("./graph/knowledge-graph-manager");
+const cost_estimator_1 = require("./cost/cost-estimator");
+const cognitive_router_1 = require("./cost/cognitive-router");
+const tools_1 = require("./mcp/tools");
+const projectDir = process.env.MAFW_PROJECT_DIR || process.cwd();
+const gatewayUrl = process.env.MAFW_GATEWAY_URL || "http://localhost:3004";
+const harmonicIndex = new harmonic_index_1.HarmonicIndexManager(projectDir);
+const knowledgeGraph = new knowledge_graph_manager_1.KnowledgeGraphManager(path.join(projectDir, ".mafw", "data", "knowledge-graph.json"));
+const costEstimator = new cost_estimator_1.CostEstimator();
+const cognitiveRouter = new cognitive_router_1.CognitiveRouter();
+const { definitions, handlers } = (0, tools_1.registerTools)();
+const server = new index_js_1.Server({
+    name: "mafw-mcp-server",
+    version: "4.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: definitions,
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const handler = handlers[toolName];
+    if (!handler) {
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+    const args = request.params.arguments ?? {};
+    return handler(args);
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    logger_1.log.error("MCP server error:", err);
+    process.exit(1);
+});

package/gateway/dist/core/memory/abstraction-distiller.js

@@ -0,0 +1,44 @@
+"use strict";
+// src/memory/abstraction-distiller.ts — Rewritten for v7 proposition extraction
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasKnowledgeSignal = hasKnowledgeSignal;
+exports.extractPropositions = extractPropositions;
+exports.passQualityGate = passQualityGate;
+exports.runDistillation = runDistillation;
+function hasKnowledgeSignal(observation) {
+    const lower = observation.toLowerCase();
+    if (lower.includes('error') && (lower.includes('fix') || lower.includes('root') || lower.includes('because')))
+        return 'pitfall';
+    if (lower.includes('config') || lower.includes('set '))
+        return 'procedure';
+    if (lower.includes(' is ') || lower.includes('always') || lower.includes('never') || lower.includes('requires'))
+        return 'fact';
+    if (lower.includes('decide') || lower.includes('choose') || lower.includes('reason'))
+        return 'decision';
+    return null;
+}
+function extractPropositions(observations) {
+    const propositions = [];
+    for (const obs of observations) {
+        const sentences = obs.split(/[。.!?]/).filter(s => s.trim().length > 10);
+        for (const s of sentences) {
+            const cleaned = s.trim().replace(/用户|agent|然后|最终/gi, '').trim();
+            if (cleaned.length > 0) {
+                propositions.push(cleaned);
+            }
+        }
+    }
+    return [...new Set(propositions)].slice(0, 4);
+}
+function passQualityGate(proposition, granularity) {
+    if (/用户|agent|然后|最终/i.test(proposition))
+        return false;
+    if (proposition.length < 15)
+        return false;
+    if (!granularity)
+        return false;
+    return true;
+}
+async function runDistillation(_indexManager, _baseDir) {
+    return { created: 0, locked: 0, errors: [] };
+}

package/gateway/dist/core/memory/cognitive-graph.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitiveGraphManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const GRAPH_FILE = path.join('memory', '.cognitive_graph.json');
+class CognitiveGraphManager {
+    graph;
+    filePath;
+    constructor(baseDir) {
+        this.filePath = path.join(baseDir, GRAPH_FILE);
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        this.graph = this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf-8');
+                return JSON.parse(raw);
+            }
+        }
+        catch {
+            // corrupt or missing file
+        }
+        return { version: 1, updated_at: new Date().toISOString(), edges: [] };
+    }
+    save() {
+        this.graph.updated_at = new Date().toISOString();
+        const tmpPath = this.filePath + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(this.graph, null, 2), 'utf-8');
+        fs.renameSync(tmpPath, this.filePath);
+    }
+    addConnection(idA, idB) {
+        const [source, target] = idA < idB ? [idA, idB] : [idB, idA];
+        const existing = this.graph.edges.find(e => e.source === source && e.target === target);
+        if (existing) {
+            existing.weight++;
+        }
+        else {
+            this.graph.edges.push({ source, target, weight: 1 });
+        }
+        this.save();
+    }
+    getTopAssociations(id, topK = 2) {
+        const neighbors = this.graph.edges
+            .filter(e => e.source === id || e.target === id)
+            .map(e => (e.source === id ? e.target : e.source))
+            .map(nid => ({
+            id: nid,
+            weight: this.graph.edges
+                .filter(e => (e.source === id && e.target === nid) || (e.source === nid && e.target === id))
+                .reduce((sum, e) => sum + e.weight, 0),
+        }))
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, topK)
+            .map(n => n.id);
+        return neighbors;
+    }
+    prune(threshold = 2) {
+        this.graph.edges = this.graph.edges.filter(e => e.weight >= threshold);
+        this.save();
+    }
+    getGraph() {
+        return JSON.parse(JSON.stringify(this.graph));
+    }
+}
+exports.CognitiveGraphManager = CognitiveGraphManager;

package/gateway/dist/core/memory/energy-system.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergySystem = void 0;
+const EVENT_DELTAS = {
+    useful_feedback: 0.1,
+    useless_feedback: -0.05,
+    retrieved: 0.02,
+    referenced: 0.05,
+    merged: 0.03,
+};
+class EnergySystem {
+    decayRatePerDay;
+    minEnergy = 0.0;
+    maxEnergy = 1.0;
+    cleanupThreshold;
+    criticalThreshold;
+    hookManager;
+    constructor(config) {
+        this.decayRatePerDay = config?.decayRatePerDay ?? 0.005;
+        this.cleanupThreshold = config?.cleanupThreshold ?? 0.3;
+        this.criticalThreshold = config?.criticalThreshold ?? 0.8;
+        this.hookManager = config?.hookManager || null;
+    }
+    calculateEnergy(currentEnergy, event, daysSinceLastUpdate, salience = 1.0, unitId) {
+        const effectiveDecay = this.decayRatePerDay * (1 / Math.max(0.1, salience));
+        let energy = currentEnergy - effectiveDecay * Math.max(0, daysSinceLastUpdate);
+        energy += EVENT_DELTAS[event.type];
+        const clamped = Math.max(this.minEnergy, Math.min(this.maxEnergy, energy));
+        const threshold = currentEnergy * 0.3;
+        if (clamped < currentEnergy - threshold) {
+            this.hookManager?.execute('memory.decay', {
+                oldEnergy: currentEnergy,
+                newEnergy: clamped,
+                reason: `decay: ${effectiveDecay * Math.max(0, daysSinceLastUpdate)} over ${daysSinceLastUpdate} days, event: ${event.type}`,
+                unitId: unitId || 'unknown'
+            });
+        }
+        return clamped;
+    }
+    /**
+     * Pure time-based decay with no event bonus — used by the memory:decay
+     * automation so memories fade solely by elapsed time.
+     */
+    decay(currentEnergy, daysSinceLastUpdate, salience = 1.0) {
+        const effectiveDecay = this.decayRatePerDay * (1 / Math.max(0.1, salience));
+        return Math.max(this.minEnergy, Math.min(this.maxEnergy, currentEnergy - effectiveDecay * Math.max(0, daysSinceLastUpdate)));
+    }
+    shouldCleanup(energy) {
+        return energy < this.cleanupThreshold;
+    }
+    isCritical(energy) {
+        return energy > this.criticalThreshold;
+    }
+    calculateDistribution(memories) {
+        const dist = { critical: 0, high: 0, medium: 0, low: 0, total: memories.length };
+        for (const m of memories) {
+            if (m.energy > 0.8)
+                dist.critical++;
+            else if (m.energy >= 0.6)
+                dist.high++;
+            else if (m.energy >= 0.3)
+                dist.medium++;
+            else
+                dist.low++;
+        }
+        return dist;
+    }
+}
+exports.EnergySystem = EnergySystem;

package/gateway/dist/core/memory/extractor.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryExtractor = void 0;
+const fs = __importStar(require("fs"));
+/**
+ * Memory Extractor — L2 → L3 Δ 提取器
+ *
+ * 职责：从 Review 失败后的 L2 YAML Lesson 中自动提取参数化记忆（Δ）。
+ *
+ * 提取规则：
+ *   1. 只输出 enforcement: hard 的布尔约束（可验证）
+ *   2. 禁止软性建议（如"建议"、"可以考虑"）
+ *   3. 必须标注 origin_loop 和 origin_task
+ *   4. 最多生成 0~2 个 Δ
+ *
+ * 提取类型：
+ *   - Constraint Δ: 从 violation.rule 提取（硬约束）
+ *   - Prompt Δ: 从 lesson 中的检查清单提取（软提示）
+ *   - Pattern Δ: 从 Wave 分解模式提取（仅在特定 domain 出现）
+ */
+class MemoryExtractor {
+    /**
+     * 从单个 Lesson 提取 Δ
+     */
+    extract(lesson) {
+        const deltas = [];
+        // 1. Constraint Δ 提取：若存在 violation，提取为硬约束
+        if (lesson.violation && lesson.violation.rule) {
+            const constraintId = this.sanitizeId(`constraint-${lesson.domain}-${lesson.loop}`);
+            const constraint = {
+                id: constraintId,
+                type: 'constraint',
+                scope: ['plan', 'execute'],
+                enforcement: 'hard',
+                trigger_condition: {
+                    domain: [lesson.domain],
+                    task_type: ['coding', 'test'],
+                    loop_stage: ['planning', 'executing']
+                },
+                rule: lesson.violation.rule,
+                origin: {
+                    goal: lesson.domain, // 简化
+                    loop: lesson.loop,
+                    task: lesson.task
+                },
+                created_at: new Date().toISOString(),
+                energy_score: 0.65,
+                verified: false,
+                priority: 9
+            };
+            deltas.push(constraint);
+        }
+        // 2. Prompt Δ 提取：从 lesson 文本提取检查清单
+        if (lesson.lesson && lesson.lesson.length > 10) {
+            const promptId = this.sanitizeId(`prompt-${lesson.domain}-${lesson.loop}`);
+            const prompt = {
+                id: promptId,
+                type: 'prompt',
+                scope: ['plan'],
+                enforcement: 'soft',
+                trigger_condition: {
+                    domain: [lesson.domain],
+                    keywords: MemoryExtractor.extractKeywords(lesson.lesson)
+                },
+                prompt_delta: `## [PARAMETRIC] ${lesson.domain} 强制检查\n${lesson.lesson}`,
+                origin: {
+                    goal: lesson.domain,
+                    loop: lesson.loop,
+                    task: lesson.task
+                },
+                created_at: new Date().toISOString(),
+                energy_score: 0.5,
+                verified: false,
+                priority: 7,
+                max_injections: 5,
+                injection_count: 0
+            };
+            deltas.push(prompt);
+        }
+        // 3. Pattern Δ 提取：只在特定 domain 触发（如 auth 模块的 Wave 分解模式）
+        if (['auth', 'api', 'user-system'].includes(lesson.domain)) {
+            const patternId = this.sanitizeId(`pattern-${lesson.domain}-wave`);
+            const pattern = {
+                id: patternId,
+                type: 'pattern',
+                scope: ['plan'],
+                enforcement: 'pattern',
+                trigger_condition: {
+                    domain: [lesson.domain],
+                    goal_keywords: ['login', 'register', 'auth', 'permission']
+                },
+                pattern_template: `## Wave 分解模式: ${lesson.domain} 模块\n适用场景: 新${lesson.domain}模块\n强制 Wave 划分: 契约层 → 核心层 → 集成层`,
+                usage_stats: { injected_count: 0, success_count: 0 },
+                origin: {
+                    goal: lesson.domain,
+                    loop: lesson.loop,
+                    task: lesson.task
+                },
+                created_at: new Date().toISOString(),
+                energy_score: 0.67,
+                verified: false,
+                priority: 6
+            };
+            deltas.push(pattern);
+        }
+        return deltas.slice(0, 2); // 最多 2 个
+    }
+    /**
+     * 从 Goal 的 lessons 文件批量提取
+     */
+    extractFromFile(lessonsPath) {
+        if (!fs.existsSync(lessonsPath))
+            return [];
+        const content = fs.readFileSync(lessonsPath, 'utf-8');
+        // 简化：假设 YAML 块已存在于 markdown 中
+        // 实际应使用 YAML front-matter 解析器
+        return [];
+    }
+    sanitizeId(raw) {
+        return raw.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    }
+    static extractKeywords(text) {
+        const words = text
+            .toLowerCase()
+            .replace(/[^\u4e00-\u9fff\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length >= 3);
+        return Array.from(new Set(words)).slice(0, 5);
+    }
+}
+exports.MemoryExtractor = MemoryExtractor;