@jack200714/mafw 4.5.1

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

@@ -0,0 +1,284 @@
+"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.ParametricStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const energy_system_1 = require("./energy-system");
+const DEFAULT_CONFIG = {
+    baseDir: '.mafw/parametric',
+    bannedDir: '.mafw/parametric/banned',
+    manifestFile: '.mafw/parametric/base-skill-manifest.yaml'
+};
+/**
+ * Parametric Memory Store
+ *
+ * L3 参数化记忆的 CRUD + 索引中心。
+ * 负责 Constraint/Prompt/Pattern 三类 Δ 的持久化、检索、去重、熔断。
+ *
+ * 目录结构:
+ *   parametric/
+ *   ├── prompt-deltas/
+ *   ├── constraint-deltas/
+ *   ├── pattern-deltas/
+ *   ├── banned/
+ *   └── base-skill-manifest.yaml
+ */
+class ParametricStore {
+    config;
+    energySystem;
+    constructor(config = {}, energyConfig) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.energySystem = new energy_system_1.EnergySystem(energyConfig);
+        this.ensureDirs();
+    }
+    ensureDirs() {
+        [this.config.baseDir, this.config.bannedDir].forEach(d => {
+            if (!fs.existsSync(d))
+                fs.mkdirSync(d, { recursive: true });
+        });
+        ['prompt-deltas', 'constraint-deltas', 'pattern-deltas'].forEach(sub => {
+            const p = path.join(this.config.baseDir, sub);
+            if (!fs.existsSync(p))
+                fs.mkdirSync(p, { recursive: true });
+        });
+    }
+    deltaDir(type) {
+        return path.join(this.config.baseDir, `${type}-deltas`);
+    }
+    deltaPath(id, type) {
+        return path.join(this.deltaDir(type), `${id}.yaml`);
+    }
+    /**
+     * 保存一个 Δ。如果已存在且内容相同，跳过写入。
+     * 能量按增量衰减结算：自 last_energy_at（缺失回退 created_at）起算流逝天数，
+     * 结算后盖章 last_energy_at —— 重复保存不会重复扣全龄衰减。
+     */
+    save(delta) {
+        const p = this.deltaPath(delta.id, delta.type);
+        const data = yaml.dump(delta, { lineWidth: -1 });
+        if (fs.existsSync(p)) {
+            const existing = fs.readFileSync(p, 'utf-8');
+            if (existing === data)
+                return; // 无变化，跳过
+        }
+        const now = Date.now();
+        const base = new Date(delta.last_energy_at || delta.created_at || 0).getTime();
+        const daysSinceEnergy = base > 0 ? Math.max(0, (now - base) / 86_400_000) : 0;
+        delta.energy_score = this.energySystem.calculateEnergy(delta.energy_score, { type: 'retrieved' }, daysSinceEnergy, 1.0, delta.id);
+        delta.last_energy_at = new Date(now).toISOString();
+        fs.writeFileSync(p, yaml.dump(delta, { lineWidth: -1 }), 'utf-8');
+    }
+    /**
+     * 更新 Δ 的能量值（基于事件和时间的增量衰减/奖励），结算后盖章 last_energy_at。
+     */
+    updateEnergy(id, type, event) {
+        const delta = this.load(id, type);
+        if (!delta)
+            return;
+        const now = Date.now();
+        const base = new Date(delta.last_energy_at || delta.created_at || 0).getTime();
+        const daysSinceEnergy = base > 0 ? Math.max(0, (now - base) / 86_400_000) : 0;
+        delta.energy_score = this.energySystem.calculateEnergy(delta.energy_score, event, daysSinceEnergy, 1.0, delta.id);
+        delta.last_energy_at = new Date(now).toISOString();
+        fs.writeFileSync(this.deltaPath(id, type), yaml.dump(delta, { lineWidth: -1 }), 'utf-8');
+    }
+    /**
+     * 读取单个 Δ
+     */
+    load(id, type) {
+        const p = this.deltaPath(id, type);
+        if (!fs.existsSync(p))
+            return null;
+        return yaml.load(fs.readFileSync(p, 'utf-8'));
+    }
+    /**
+     * 加载所有未熔断的 Δ
+     */
+    loadAll() {
+        const deltas = [];
+        const types = ['constraint', 'prompt', 'pattern'];
+        for (const t of types) {
+            const dir = this.deltaDir(t);
+            if (!fs.existsSync(dir))
+                continue;
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.yaml'));
+            for (const f of files) {
+                const d = yaml.load(fs.readFileSync(path.join(dir, f), 'utf-8'));
+                deltas.push(d);
+            }
+        }
+        return deltas;
+    }
+    /**
+     * 根据 trigger_condition 匹配候选 Δ
+     */
+    match(context) {
+        return this.loadAll().filter(d => {
+            const tc = d.trigger_condition;
+            if (tc.min_loop_count !== undefined && (context.loopCount ?? 0) < tc.min_loop_count)
+                return false;
+            if (tc.domain && context.domain && !tc.domain.includes(context.domain))
+                return false;
+            if (tc.task_type && context.taskType && !tc.task_type.includes(context.taskType))
+                return false;
+            if (tc.loop_stage && context.loopStage && !tc.loop_stage.includes(context.loopStage))
+                return false;
+            if (tc.keywords && context.goalKeywords) {
+                const hasKeyword = tc.keywords.some(kw => context.goalKeywords.some(gk => gk.toLowerCase().includes(kw.toLowerCase())));
+                if (!hasKeyword)
+                    return false;
+            }
+            if (tc.affected_file_pattern && context.affectedFiles) {
+                const hasPattern = tc.affected_file_pattern.some(pat => context.affectedFiles.some(f => this.matchPattern(f, pat)));
+                if (!hasPattern)
+                    return false;
+            }
+            return true;
+        });
+    }
+    matchPattern(file, pattern) {
+        // 简单 glob: *.test.ts -> 正则
+        const regex = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${regex}$`).test(file);
+    }
+    /**
+     * 检测单个 Δ 是否震荡（连续 N 次参与 Loop 未通过验证）
+     */
+    detectOscillation(deltaId, history) {
+        const last3 = history.slice(-3);
+        const sameReason = last3.length === 3 && last3.every(l => l.result === 'review_fail');
+        if (!sameReason)
+            return { isOscillating: false };
+        return {
+            isOscillating: true,
+            deltaId,
+            reason: 'OSCILLATION: 连续 3 次参与 Loop 均未通过验证',
+            suggestion: '该约束可能过于刚性或条件错误，建议手动审查'
+        };
+    }
+    /**
+     * 熔断（将 Δ 移入 banned/）
+     */
+    ban(deltaId, meta) {
+        const types = ['constraint', 'prompt', 'pattern'];
+        for (const t of types) {
+            const src = this.deltaPath(deltaId, t);
+            if (fs.existsSync(src)) {
+                const dest = path.join(this.config.bannedDir, `${deltaId}.yaml`);
+                const data = yaml.load(fs.readFileSync(src, 'utf-8'));
+                data._banned = true;
+                data._ban_reason = meta.reason;
+                data._ban_suggestion = meta.suggestion;
+                data._banned_at = new Date().toISOString();
+                fs.writeFileSync(dest, yaml.dump(data), 'utf-8');
+                fs.unlinkSync(src);
+                return;
+            }
+        }
+    }
+    /**
+     * 去重 + 冲突检测 + 震荡 Δ 自动熔断
+     */
+    merge(deltas, history) {
+        const merged = [];
+        const conflicts = [];
+        const banned = [];
+        const seen = new Map();
+        for (const d of deltas) {
+            // 1. 去重：相同 ID 保留 energy_score 更高的
+            if (seen.has(d.id)) {
+                const existing = seen.get(d.id);
+                if (d.energy_score > existing.energy_score) {
+                    seen.set(d.id, d);
+                }
+                continue;
+            }
+            // 2. 震荡检测
+            const osc = this.detectOscillation(d.id, history);
+            if (osc.isOscillating) {
+                this.ban(d.id, { reason: osc.reason, suggestion: osc.suggestion });
+                banned.push(d.id);
+                conflicts.push({
+                    deltaId: d.id,
+                    reason: 'oscillation',
+                    suggestion: osc.suggestion
+                });
+                continue;
+            }
+            seen.set(d.id, d);
+        }
+        merged.push(...seen.values());
+        return { merged, conflicts, banned };
+    }
+    /**
+     * 读取固化清单
+     */
+    loadManifest() {
+        if (!fs.existsSync(this.config.manifestFile)) {
+            return { manifest_version: 1, merged_deltas: [] };
+        }
+        return yaml.load(fs.readFileSync(this.config.manifestFile, 'utf-8'));
+    }
+    /**
+     * 更新固化清单（Archive 阶段由 DeltaValidator 调用）
+     */
+    updateManifest(manifest) {
+        fs.writeFileSync(this.config.manifestFile, yaml.dump(manifest), 'utf-8');
+    }
+    /**
+     * 清理能量低于阈值的 Δ（归档到 banned/）
+     * 返回被归档的 delta ID 列表
+     */
+    cleanup() {
+        const archived = [];
+        const deltas = this.loadAll();
+        for (const d of deltas) {
+            if (this.energySystem.shouldCleanup(d.energy_score)) {
+                this.ban(d.id, {
+                    reason: `energy below cleanup threshold (${d.energy_score})`,
+                    suggestion: 'archived due to low energy score'
+                });
+                archived.push(d.id);
+            }
+        }
+        return archived;
+    }
+}
+exports.ParametricStore = ParametricStore;

package/gateway/dist/core/memory/t1-store.js

@@ -0,0 +1,183 @@
+"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.T1Store = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class T1Store {
+    baseDir;
+    counts = new Map();
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.loadCounts();
+    }
+    append(observation, goalId) {
+        const gid = goalId || observation.goalId || 'default';
+        const dir = path.join(this.baseDir, 'memory', 'tier1', gid);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const filePath = this.resolveSpiralPath(dir);
+        const line = JSON.stringify(observation) + '\n';
+        fs.appendFileSync(filePath, line, 'utf-8');
+        this.counts.set(gid, (this.counts.get(gid) || 0) + 1);
+    }
+    appendBatch(observations, goalId) {
+        for (const obs of observations) {
+            this.append(obs, goalId);
+        }
+    }
+    getCount(goalId) {
+        return this.counts.get(goalId || 'default') || 0;
+    }
+    readAll(goalId) {
+        return this.readFiltered({}, goalId);
+    }
+    readBySession(sessionID, goalId) {
+        return this.readFiltered({ sessionID }, goalId);
+    }
+    hasSession(sessionID, goalId) {
+        return this.readBySession(sessionID, goalId).length > 0;
+    }
+    clearSession(sessionID, goalId) {
+        const gid = goalId || 'default';
+        const dir = path.join(this.baseDir, 'memory', 'tier1', gid);
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir)
+            .filter(f => f.startsWith('spiral-') && f.endsWith('.jsonl'))
+            .sort();
+        for (const entry of entries) {
+            const filePath = path.join(dir, entry);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n').filter(Boolean);
+            const remaining = lines.filter(line => {
+                try {
+                    const obs = JSON.parse(line);
+                    return obs.sessionID !== sessionID;
+                }
+                catch {
+                    return true;
+                }
+            });
+            if (remaining.length === 0) {
+                fs.unlinkSync(filePath);
+            }
+            else {
+                fs.writeFileSync(filePath, remaining.join('\n') + '\n', 'utf-8');
+            }
+        }
+        this.loadCounts();
+    }
+    clear(goalId) {
+        const gid = goalId || 'default';
+        const dir = path.join(this.baseDir, 'memory', 'tier1', gid);
+        if (fs.existsSync(dir)) {
+            const entries = fs.readdirSync(dir)
+                .filter(f => f.startsWith('spiral-') && f.endsWith('.jsonl'));
+            for (const entry of entries) {
+                fs.unlinkSync(path.join(dir, entry));
+            }
+        }
+        this.counts.set(gid, 0);
+    }
+    readFiltered(filter, goalId) {
+        const gid = goalId || 'default';
+        const dir = path.join(this.baseDir, 'memory', 'tier1', gid);
+        if (!fs.existsSync(dir))
+            return [];
+        const entries = fs.readdirSync(dir)
+            .filter(f => f.startsWith('spiral-') && f.endsWith('.jsonl'))
+            .sort();
+        const result = [];
+        for (const entry of entries) {
+            const content = fs.readFileSync(path.join(dir, entry), 'utf-8');
+            for (const line of content.split('\n').filter(Boolean)) {
+                try {
+                    const obs = JSON.parse(line);
+                    const matches = Object.entries(filter).every(([k, v]) => obs[k] === v);
+                    if (matches)
+                        result.push(obs);
+                }
+                catch {
+                    // skip malformed lines
+                }
+            }
+        }
+        return result;
+    }
+    resolveSpiralPath(dir) {
+        const entries = fs.readdirSync(dir)
+            .filter(f => f.startsWith('spiral-') && f.endsWith('.jsonl'))
+            .sort();
+        if (entries.length > 0) {
+            const lastPath = path.join(dir, entries[entries.length - 1]);
+            const lineCount = this.countLines(lastPath);
+            if (lineCount < 1000) {
+                return lastPath;
+            }
+        }
+        const nextNum = entries.length + 1;
+        return path.join(dir, `spiral-${nextNum}.jsonl`);
+    }
+    countLines(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return content.split('\n').filter(Boolean).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    loadCounts() {
+        const tier1Dir = path.join(this.baseDir, 'memory', 'tier1');
+        if (!fs.existsSync(tier1Dir))
+            return;
+        const goalDirs = fs.readdirSync(tier1Dir);
+        for (const goalId of goalDirs) {
+            const goalPath = path.join(tier1Dir, goalId);
+            if (!fs.statSync(goalPath).isDirectory())
+                continue;
+            const entries = fs.readdirSync(goalPath)
+                .filter(f => f.startsWith('spiral-') && f.endsWith('.jsonl'));
+            let total = 0;
+            for (const entry of entries) {
+                total += this.countLines(path.join(goalPath, entry));
+            }
+            this.counts.set(goalId, total);
+        }
+    }
+}
+exports.T1Store = T1Store;

package/gateway/dist/core/memory/t1-to-t2-compressor.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.T1ToT2Compressor = void 0;
+const harmonic_types_1 = require("./harmonic-types");
+const harmonic_file_store_1 = require("../../memory/harmonic-file-store");
+const salience_perceptor_1 = require("./salience-perceptor");
+class T1ToT2Compressor {
+    t1Store;
+    pipeline;
+    index;
+    baseDir;
+    constructor(t1Store, pipeline, index, baseDir) {
+        this.t1Store = t1Store;
+        this.pipeline = pipeline;
+        this.index = index;
+        this.baseDir = baseDir;
+    }
+    /**
+     * Compress all observations for a completed session into T2 units.
+     * Groups observations by turn (user_input + tool_results + assistant_reply).
+     */
+    async compressSession(sessionID, goalId) {
+        const gid = goalId || 'default';
+        const observations = this.t1Store.readBySession(sessionID, gid);
+        if (observations.length === 0) {
+            return { readFromT1: 0, compressed: 0, persisted: 0, skippedDuplicates: 0, goalId: gid, sessionID };
+        }
+        // Group observations by turnID, preserving order
+        const turns = new Map();
+        for (const obs of observations) {
+            const tid = obs.turnID || 0;
+            if (!turns.has(tid))
+                turns.set(tid, []);
+            turns.get(tid).push(obs);
+        }
+        // Sort turns
+        const sortedTurnIds = Array.from(turns.keys()).sort((a, b) => a - b);
+        let totalPersisted = 0;
+        let totalSkipped = 0;
+        let totalRead = observations.length;
+        for (const tid of sortedTurnIds) {
+            const turnObs = turns.get(tid);
+            const { compressed, stats } = await this.pipeline.process(turnObs);
+            for (const item of compressed) {
+                const unit = this.toHarmonicUnit(item, gid, sessionID);
+                if (this.isAlreadyIndexed(unit.id)) {
+                    totalSkipped++;
+                    continue;
+                }
+                await this.appendToMemories(unit);
+                totalPersisted++;
+            }
+        }
+        this.t1Store.clearSession(sessionID, gid);
+        return {
+            readFromT1: totalRead,
+            compressed: totalPersisted + totalSkipped,
+            persisted: totalPersisted,
+            skippedDuplicates: totalSkipped,
+            goalId: gid,
+            sessionID,
+        };
+    }
+    /** Compress all observations for a goal (legacy, ungrouped) */
+    async run(goalId) {
+        const gid = goalId || 'default';
+        const observations = this.t1Store.readAll(gid);
+        if (observations.length === 0) {
+            return { readFromT1: 0, compressed: 0, persisted: 0, skippedDuplicates: 0, goalId: gid };
+        }
+        const { compressed, stats } = await this.pipeline.process(observations);
+        let persisted = 0;
+        let skipped = 0;
+        for (const item of compressed) {
+            const unit = this.toHarmonicUnit(item, gid);
+            if (this.isAlreadyIndexed(unit.id)) {
+                skipped++;
+                continue;
+            }
+            await this.appendToMemories(unit);
+            persisted++;
+        }
+        this.t1Store.clear(gid);
+        return { readFromT1: observations.length, compressed: stats.compressed || compressed.length, persisted, skippedDuplicates: skipped, goalId: gid };
+    }
+    toHarmonicUnit(item, goalId, sessionID) {
+        const memoryValue = item.facts
+            ? (Array.isArray(item.facts) ? item.facts.join('\n') : String(item.facts))
+            : item.fact || '';
+        const anchors = item.concepts
+            ? (Array.isArray(item.concepts) ? item.concepts : [item.concepts])
+            : item.concept
+                ? [item.concept]
+                : [];
+        const energy = typeof item.energy === 'number' ? item.energy : 0.5;
+        return {
+            id: (0, harmonic_types_1.generateHarmonicId)(),
+            type: 'episodic',
+            primary_abstraction: memoryValue.slice(0, 50),
+            cue_anchors: anchors.slice(0, 8),
+            memory_value: memoryValue,
+            energy: Math.max(0, Math.min(1, energy)),
+            salience: (0, salience_perceptor_1.calculateSalience)(memoryValue),
+            abstraction_level: 1,
+            goal_id: goalId !== 'default' ? goalId : undefined,
+            source_session_id: sessionID,
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        };
+    }
+    isAlreadyIndexed(id) {
+        return this.index.getIndex().entries.some(e => e.id === id);
+    }
+    async appendToMemories(unit) {
+        const store = new harmonic_file_store_1.HarmonicUnitFileStore(this.baseDir, this.index);
+        await store.write(unit);
+    }
+}
+exports.T1ToT2Compressor = T1ToT2Compressor;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaValidator = void 0;
+/**
+ * Delta Validator — L3 验证与固化器
+ *
+ * 职责：
+ *   1. Archive 阶段验证 Δ 的有效性（energy_score 调整）
+ *   2. 将 verified Δ 合并到 AGENTS.md.runtime
+ *   3. 更新 base-skill-manifest.yaml
+ *
+ * 验证规则：
+ *   - 若 Δ 参与了成功的 Loop（verdict=pass），energy_score += 0.1
+ *   - 若 Δ 参与了失败的 Loop（verdict=fail），energy_score -= 0.05
+ *   - energy_score < 0.3 的 Δ 标记为 deprecated
+ *   - verified=true 的 Δ 才能写入 AGENTS.md.runtime
+ */
+class DeltaValidator {
+    /**
+     * 验证单个 Δ：根据 Loop 结果调整 energy_score
+     */
+    validate(delta, loopResult) {
+        const validated = { ...delta };
+        if (loopResult === 'pass') {
+            validated.energy_score = Math.min(1.0, validated.energy_score + 0.1);
+        }
+        else {
+            validated.energy_score = Math.max(0.0, validated.energy_score - 0.05);
+        }
+        // 达到阈值则标记 verified
+        if (validated.energy_score >= 0.8) {
+            validated.verified = true;
+        }
+        // 过低则废弃
+        if (validated.energy_score < 0.3) {
+            validated.verified = false;
+        }
+        return validated;
+    }
+    /**
+     * 批量验证所有参与本次 Loop 的 Δ
+     */
+    validateBatch(deltas, loopResult) {
+        return deltas.map(d => this.validate(d, loopResult));
+    }
+    /**
+     * 生成 AGENTS.md.runtime 追加内容
+     */
+    renderRuntimeDelta(delta) {
+        if (!delta.verified)
+            return '';
+        const lines = [
+            `## [固化约束] ${delta.id}`,
+            `- 来源: ${delta.origin.goal} Loop ${delta.origin.loop} Task ${delta.origin.task}`,
+            `- 能量分: ${delta.energy_score.toFixed(2)}`,
+            `- 类型: ${delta.type}`,
+            ''
+        ];
+        if (delta.type === 'constraint') {
+            lines.push(`- 规则: ${delta.rule}`);
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+}
+exports.DeltaValidator = DeltaValidator;