@jack200714/mafw 4.5.1

package/gateway/dist/core/engine/degradation.js

@@ -0,0 +1,159 @@
+"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.DegradationStrategy = void 0;
+const logger_1 = require("../utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const report_generator_1 = require("./report-generator");
+/**
+ * Degradation Strategy — 五级降级策略
+ *
+ * L1: 警告 — Loop 3/5 提示用户，不停止
+ * L2: 降级 — Loop 5/5 自动降级完成部分工作
+ * L3: 熔断 — 连续 3 轮相同 Lesson 强制退出
+ * L4: 紧急 — 心跳超时，从 Checkpoint 恢复
+ * L5: 灾难 — 外部依赖失败，优雅失败
+ */
+class DegradationStrategy {
+    projectDir;
+    reportGenerator;
+    constructor(projectDir = '.') {
+        this.projectDir = projectDir;
+        this.reportGenerator = new report_generator_1.ReportGenerator(projectDir);
+    }
+    /**
+     * 判断是否需要 L1 警告
+     */
+    shouldWarn(loopCount, maxLoops) {
+        return loopCount >= Math.ceil(maxLoops * 0.6); // 3/5
+    }
+    /**
+     * L1 警告处理：提示用户选择
+     */
+    async handleL1(goalId, loopCount, reviewResult) {
+        const warning = [
+            `[MAFW 警告] Goal "${goalId}" 已迭代 ${loopCount} 次仍未完成`,
+            `当前问题: ${reviewResult.reason || 'unknown'}`,
+            '建议:',
+            '1. 放宽指标',
+            '2. 检查环境配置',
+            '3. 手动介入审查',
+            '',
+            '选项: [1]继续 [2]放宽 [3]暂停 [4]接受降级'
+        ].join('\n');
+        logger_1.log.info(warning);
+        // 简化：自动选择继续（实际应读取用户输入或 control 文件）
+        const controlFile = path.join(this.projectDir, '.mafw/control');
+        if (fs.existsSync(controlFile)) {
+            const control = fs.readFileSync(controlFile, 'utf-8').trim();
+            if (control.startsWith('DEGRADE:'))
+                return 'accept_partial';
+            if (control === 'PAUSE')
+                return 'pause';
+            if (control === 'ABORT')
+                return 'abort';
+        }
+        return 'continue';
+    }
+    /**
+     * L2 降级：自动执行
+     */
+    async autoDegrade(goalId, executeResult) {
+        const coverage = executeResult.metrics?.coverage || 0;
+        let strategy;
+        let message;
+        if (coverage >= 60) {
+            strategy = 'partial';
+            message = `放宽指标至 ${coverage}%，标记为"部分完成"`;
+            await this.degradeToPartial(goalId, executeResult);
+        }
+        else if (coverage >= 40) {
+            strategy = 'core_only';
+            message = '只保留核心功能，移除边缘功能';
+        }
+        else {
+            strategy = 'rollback';
+            message = '回滚到上一个稳定 Loop';
+        }
+        logger_1.log.info(`[Degradation] L2 策略: ${strategy} — ${message}`);
+        await this.reportGenerator.generateDegraded(goalId, {
+            loopCount: executeResult.loopCount,
+            reason: `L2 降级: ${message}`,
+            metrics: executeResult.metrics
+        });
+    }
+    /**
+     * L2 降级：接受部分完成
+     */
+    async degradeToPartial(goalId, executeResult) {
+        logger_1.log.info(`[Degradation] ${goalId}: 接受部分完成，生成降级报告`);
+        await this.reportGenerator.generateDegraded(goalId, {
+            loopCount: executeResult.loopCount,
+            reason: '用户接受部分完成',
+            metrics: executeResult.metrics
+        });
+    }
+    /**
+     * L3 熔断检测：连续 3 轮相同原因
+     */
+    async checkL3Oscillation(goalId, lessons) {
+        const last3 = lessons.slice(-3);
+        if (last3.length < 3)
+            return false;
+        const sameReason = last3.every(l => l.reason === last3[0].reason);
+        if (sameReason) {
+            logger_1.log.info(`[Degradation] L3 熔断: 连续 3 次相同原因 — ${last3[0].reason}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * L4 紧急：从 Checkpoint 恢复
+     */
+    async recoverFromCheckpoint(goalId, checkpointPath) {
+        logger_1.log.info(`[Degradation] L4 恢复: 从 ${checkpointPath} 恢复状态`);
+        // 恢复 L1 Session + L3 Parametric 状态
+    }
+    /**
+     * L5 灾难：导出记忆到外部 Git 分支
+     */
+    async exportForDisaster(goalId) {
+        const exportBranch = `disaster-export/${goalId}`;
+        logger_1.log.info(`[Degradation] L5 导出: parametric/ + lessons/ → ${exportBranch}`);
+        return exportBranch;
+    }
+}
+exports.DegradationStrategy = DegradationStrategy;

package/gateway/dist/core/engine/goal-worktree-manager.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoalWorktreeManager = void 0;
+const logger_1 = require("../utils/logger");
+const simple_git_1 = __importDefault(require("simple-git"));
+class GoalWorktreeManager {
+    projectDir;
+    git;
+    constructor(projectDir = '.') {
+        this.projectDir = projectDir;
+        this.git = (0, simple_git_1.default)(projectDir);
+    }
+    /**
+     * 准备 Goal 的 Worktree
+     */
+    async prepare(config) {
+        const { projectDir, goalId, parallel } = config;
+        if (!parallel) {
+            // 闈炲苟琛屾ā寮忥細鍦ㄥ綋鍓嶇洰褰曞垏鎹㈠垎鏀?
+            const branch = `goal/${goalId}`;
+            const branches = await this.git.branchLocal();
+            if (!branches.all.includes(branch)) {
+                await this.git.checkoutLocalBranch(branch);
+            }
+            await this.git.checkout(branch);
+            return { worktreeDir: projectDir, branch, isIsolated: false };
+        }
+        // 并行模式：创建独立 worktree
+        const worktreeDir = `${projectDir}-goal-${goalId}`;
+        const branch = `goal/${goalId}`;
+        const branches = await this.git.branchLocal();
+        if (!branches.all.includes(branch)) {
+            await this.git.checkoutLocalBranch(branch);
+        }
+        // 创建 worktree
+        try {
+            await this.git.raw(['worktree', 'add', worktreeDir, branch]);
+            logger_1.log.info(`[GoalWorktree] Created worktree ${worktreeDir} for branch ${branch}`);
+        }
+        catch (err) {
+            // 如果 worktree 已存在，直接返回
+            logger_1.log.info(`[GoalWorktree] Worktree ${worktreeDir} already exists`);
+        }
+        return { worktreeDir, branch, isIsolated: true };
+    }
+    /**
+     * 褰掓。 Goal锛堝悎骞跺埌 main锛?
+     */
+    async archive(info, strategy = 'merge') {
+        logger_1.log.info(`[GoalWorktree] Archiving goal ${info.branch}`);
+        await this.git.checkout('main');
+        if (strategy === 'merge') {
+            try {
+                await this.git.merge([info.branch, '--no-ff', '-m', `Merge goal ${info.branch}`]);
+                logger_1.log.info(`[GoalWorktree] Merged ${info.branch} into main`);
+            }
+            catch (err) {
+                logger_1.log.error(`[GoalWorktree] Merge conflict in ${info.branch}:`, err.message);
+                await this.git.merge(['--abort']);
+                throw new Error(`Merge conflict: ${info.branch}`);
+            }
+        }
+        else {
+            // Squash merge
+            await this.git.merge([info.branch, '--squash', '-m', `Squash merge goal ${info.branch}`]);
+            await this.git.commit(`Squash merge goal ${info.branch}`);
+            logger_1.log.info(`[GoalWorktree] Squash merged ${info.branch} into main`);
+        }
+        // 清理独立 worktree
+        if (info.isIsolated) {
+            try {
+                await this.git.raw(['worktree', 'remove', info.worktreeDir]);
+                await this.git.deleteBranch(info.branch);
+                logger_1.log.info(`[GoalWorktree] Removed worktree ${info.worktreeDir} and branch ${info.branch}`);
+            }
+            catch (err) {
+                logger_1.log.warn(`[GoalWorktree] Cleanup warning: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * 获取当前 Goal 分支信息
+     */
+    async getCurrentInfo(goalId) {
+        const branch = `goal/${goalId}`;
+        const currentBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+        return {
+            worktreeDir: this.projectDir,
+            branch: currentBranch.trim(),
+            isIsolated: false
+        };
+    }
+    /**
+     * 检查分支是否存在
+     */
+    async branchExists(branch) {
+        const branches = await this.git.branchLocal();
+        return branches.all.includes(branch);
+    }
+    /**
+     * 鍒楀嚭鎵€鏈?git worktree
+     */
+    async listWorktrees() {
+        const output = await this.git.raw(['worktree', 'list']);
+        const lines = output.trim().split('\n').filter(Boolean);
+        return lines.map(line => {
+            const parts = line.split(/\s+/);
+            return {
+                path: parts[0],
+                branch: (parts[1] || '').replace(/\[|\]/g, ''),
+                head: parts[2] || '',
+            };
+        });
+    }
+    /**
+     * 清理已删除的 worktree 记录
+     */
+    async prune() {
+        try {
+            await this.git.raw(['worktree', 'prune']);
+            logger_1.log.info('[GoalWorktree] Pruned stale worktree records');
+        }
+        catch (err) {
+            logger_1.log.warn(`[GoalWorktree] Prune warning: ${err.message}`);
+        }
+    }
+}
+exports.GoalWorktreeManager = GoalWorktreeManager;

package/gateway/dist/core/engine/lesson-manager.js

@@ -0,0 +1,222 @@
+"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.LessonManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const lesson_compactor_1 = require("../compression/lesson-compactor");
+const compression_verifier_1 = require("../compression/compression-verifier");
+const memory_index_1 = require("../compression/memory-index");
+/**
+ * Lesson Manager — L2 经验档案管理器
+ *
+ * 职责：
+ *   1. 写入自然语言 Lesson（Review 失败时）
+ *   2. 写入前调用 L2 LessonCompactor 压缩为 YAML
+ *   3. 写入后异步更新 L2 MemoryIndex
+ *   4. 提供加载接口（loadAll / loadRelevant）
+ *
+ * 文件结构：
+ *   .mafw/lessons/{goal_id}.md
+ */
+class LessonManager {
+    lessonsDir;
+    compactor;
+    verifier;
+    index;
+    constructor(projectDir = '.') {
+        this.lessonsDir = path.join(projectDir, '.mafw/lessons');
+        if (!fs.existsSync(this.lessonsDir))
+            fs.mkdirSync(this.lessonsDir, { recursive: true });
+        this.compactor = new lesson_compactor_1.LessonCompactor();
+        this.verifier = new compression_verifier_1.CompressionVerifier();
+        this.index = new memory_index_1.MemoryIndexManager(path.join(projectDir, '.mafw/memory-index.json'));
+    }
+    /**
+     * 写入一个自然语言 Lesson。
+     * 返回 lesson 在文件中的 anchor（如 "L12"）。
+     */
+    async writeLesson(goalId, loop, data) {
+        const file = path.join(this.lessonsDir, `${goalId}.md`);
+        const raw = {
+            loop,
+            trigger: data.trigger,
+            result: data.result,
+            domain: data.executeResult.domain || 'general',
+            task: data.executeResult.currentTask || 'unknown',
+            violation: {
+                rule: data.reason,
+                type: 'boundary_cross',
+                severity: 'high'
+            },
+            root_cause: data.reason,
+            lesson: `Lesson from Loop ${loop}: ${data.reason}`,
+            energy: 'high',
+            files: data.executeResult.filesChanged || [],
+            created_at: new Date().toISOString()
+        };
+        const block = this.renderRawBlock(raw);
+        const isNew = !fs.existsSync(file);
+        fs.appendFileSync(file, block, 'utf-8');
+        // 更新索引
+        const anchor = this.getAnchor(file, block);
+        this.index.add({
+            id: `${goalId}-loop-${loop}`,
+            file,
+            anchor,
+            tags: memory_index_1.MemoryIndexManager.extractTags(raw.lesson + ' ' + raw.domain),
+            energy: 0.8,
+            type: 'constraint_source',
+            loop,
+            goal: goalId
+        });
+        this.index.save();
+        return anchor;
+    }
+    /**
+     * 压缩最后写入的 Lesson（Stop Hook 调用）
+     */
+    compactLastLesson(goalId) {
+        const file = path.join(this.lessonsDir, `${goalId}.md`);
+        if (!fs.existsSync(file))
+            return;
+        const content = fs.readFileSync(file, 'utf-8');
+        const blocks = content.split(/###\s+Loop\s+/).filter(Boolean);
+        if (blocks.length === 0)
+            return;
+        const lastBlock = blocks[blocks.length - 1];
+        // 解析为 RawLesson（简化解析）
+        const raw = this.parseRawBlock('Loop ' + lastBlock);
+        if (!raw)
+            return;
+        const result = this.compactor.compact(raw);
+        if (result.success) {
+            // 验证通过，替换为压缩版本
+            const newContent = content.replace(/###\s+Loop\s+\d+\s+[\s\S]*$/, this.renderCompactedBlock(result.compacted));
+            fs.writeFileSync(file, newContent, 'utf-8');
+        }
+    }
+    /**
+     * 加载所有 lessons（不推荐，用于重建索引）
+     */
+    loadAll(goalId) {
+        const file = path.join(this.lessonsDir, `${goalId}.md`);
+        if (!fs.existsSync(file))
+            return [];
+        const content = fs.readFileSync(file, 'utf-8');
+        return this.parseAllBlocks(content);
+    }
+    /**
+     * 加载相关 lessons（由 RalphLoop 调用，最多 3 条）
+     */
+    loadRelevant(goalId, keywords, maxResults = 3) {
+        const all = this.loadAll(goalId);
+        // 简单关键词过滤
+        const scored = all.map(l => {
+            const score = keywords.filter(kw => l.lesson.toLowerCase().includes(kw.toLowerCase()) ||
+                l.domain.toLowerCase().includes(kw.toLowerCase())).length;
+            return { lesson: l, score };
+        }).sort((a, b) => b.score - a.score);
+        return scored.slice(0, maxResults).map(s => s.lesson);
+    }
+    // ── 渲染/解析辅助 ──
+    renderRawBlock(raw) {
+        const lines = [
+            `### Loop ${raw.loop} (${raw.created_at})`,
+            `loop: ${raw.loop}`,
+            `trigger: ${raw.trigger}`,
+            `result: ${raw.result}`,
+            `domain: ${raw.domain}`,
+            `task: "${raw.task}"`,
+            raw.violation ? `violation:\n  rule: "${raw.violation.rule}"\n  type: ${raw.violation.type}\n  severity: ${raw.violation.severity}` : '',
+            raw.root_cause ? `root_cause: ${raw.root_cause}` : '',
+            `lesson: "${raw.lesson}"`,
+            `energy: ${raw.energy}`,
+            `files: [${raw.files.map(f => `"${f}"`).join(', ')}]`,
+            ''
+        ];
+        return lines.join('\n');
+    }
+    renderCompactedBlock(compacted) {
+        const lines = [
+            `### Loop ${compacted.loop} (${compacted.created_at})`,
+            `loop: ${compacted.loop}`,
+            `trigger: ${compacted.trigger}`,
+            `result: ${compacted.result}`,
+            `domain: ${compacted.domain}`,
+            `task: "${compacted.task}"`,
+            compacted.violation ? `violation:\n  rule: "${compacted.violation.rule}"\n  type: ${compacted.violation.type}\n  severity: ${compacted.violation.severity}` : '',
+            compacted.root_cause ? `root_cause: ${compacted.root_cause}` : '',
+            `lesson: "${compacted.lesson}"`,
+            `energy: ${compacted.energy}`,
+            `files: [${compacted.files.map(f => `"${f}"`).join(', ')}]`,
+            `# _compacted: true, saved ${compacted._originalTokens - compacted._compactedTokens} tokens`,
+            ''
+        ];
+        return lines.join('\n');
+    }
+    parseRawBlock(block) {
+        try {
+            const loop = parseInt(block.match(/loop:\s*(\d+)/)?.[1] || '0');
+            const trigger = block.match(/trigger:\s*(.+)/)?.[1] || '';
+            const result = block.match(/result:\s*(.+)/)?.[1] || '';
+            const domain = block.match(/domain:\s*(.+)/)?.[1] || '';
+            const task = block.match(/task:\s*"?(.+?)"?\s*$/)?.[1] || '';
+            const lesson = block.match(/lesson:\s*"?(.+?)"?\s*$/)?.[1] || '';
+            const energy = (block.match(/energy:\s*(.+)/)?.[1] || 'medium');
+            const files = (block.match(/files:\s*\[(.+?)\]/)?.[1] || '').split(',').map(f => f.trim().replace(/"/g, '')).filter(Boolean);
+            return { loop, trigger, result, domain, task, lesson, energy, files, created_at: new Date().toISOString() };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseAllBlocks(content) {
+        const blocks = content.split(/###\s+Loop\s+/).filter(Boolean);
+        return blocks.map(b => {
+            const raw = this.parseRawBlock('Loop ' + b);
+            if (!raw)
+                return null;
+            return { ...raw, _compacted: /_compacted/.test(b), _originalTokens: 0, _compactedTokens: 0 };
+        }).filter(Boolean);
+    }
+    getAnchor(file, block) {
+        const content = fs.readFileSync(file, 'utf-8');
+        const idx = content.indexOf(block.split('\n')[0]);
+        const lines = content.substring(0, idx).split('\n').length;
+        return `L${lines}`;
+    }
+}
+exports.LessonManager = LessonManager;

package/gateway/dist/core/engine/optimistic-sync.js

@@ -0,0 +1,100 @@
+"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.OptimisticStateSync = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class OptimisticStateSync {
+    projectDir;
+    contexts;
+    maxEvents;
+    constructor(projectDir, maxEvents = 20) {
+        this.projectDir = projectDir;
+        this.contexts = new Map();
+        this.maxEvents = maxEvents;
+    }
+    statePath(goalId) {
+        return path.join(this.projectDir, '.mafw', 'state', `${goalId}.json`);
+    }
+    async updateState(goalId, patch, expectedVersion, agent) {
+        const filePath = this.statePath(goalId);
+        let current;
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            current = JSON.parse(raw);
+        }
+        catch {
+            return false;
+        }
+        if (current.version !== expectedVersion) {
+            return false;
+        }
+        const newVersion = expectedVersion + 1;
+        const newState = { ...current, ...patch, version: newVersion };
+        const tmpPath = filePath + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(newState, null, 2));
+        fs.renameSync(tmpPath, filePath);
+        let ctx = this.contexts.get(goalId) || { version: 0, events: [] };
+        ctx.version = newVersion;
+        if (agent) {
+            ctx.events.push({
+                seq: ctx.events.length + 1,
+                agent,
+                operation: patch.phase ? `phase.${patch.phase}` : 'state.update',
+                timestamp: new Date().toISOString()
+            });
+            if (ctx.events.length > this.maxEvents) {
+                ctx.events = ctx.events.slice(-this.maxEvents);
+            }
+        }
+        this.contexts.set(goalId, ctx);
+        return true;
+    }
+    getCausalContext(goalId) {
+        return this.contexts.get(goalId) || { version: 0, events: [] };
+    }
+    async readCurrentVersion(goalId) {
+        const filePath = this.statePath(goalId);
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const state = JSON.parse(raw);
+            return state.version ?? -1;
+        }
+        catch {
+            return -1;
+        }
+    }
+}
+exports.OptimisticStateSync = OptimisticStateSync;