@jack200714/mafw 4.5.1

package/gateway/dist/core/engine/phase-orchestrator.js

@@ -0,0 +1,153 @@
+"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.transitionPhase = transitionPhase;
+exports.recordSession = recordSession;
+exports.recordSessionInDb = recordSessionInDb;
+exports.updateWaveProgress = updateWaveProgress;
+exports.startNextLoop = startNextLoop;
+exports.getCurrentPhase = getCurrentPhase;
+exports.canExecuteInPhase = canExecuteInPhase;
+exports.markSessionDestroyed = markSessionDestroyed;
+exports.shouldStartNextLoop = shouldStartNextLoop;
+exports.handleLoopEvent = handleLoopEvent;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const state_1 = require("../utils/state");
+const logger_1 = require("../utils/logger");
+async function transitionPhase(goalId, transition, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    const patch = {
+        phase: transition.to,
+        lastPhase: state.phase,
+        updatedAt: new Date().toISOString()
+    };
+    if (transition.nextAction) {
+        patch.nextAction = transition.nextAction;
+    }
+    if (transition.artifacts) {
+        patch.artifacts = { ...state.artifacts, ...transition.artifacts };
+    }
+    if (transition.totalWaves !== undefined) {
+        patch.totalWaves = transition.totalWaves;
+    }
+    if (transition.metrics) {
+        patch.metrics = transition.metrics;
+    }
+    if (transition.error !== undefined) {
+        patch.error = transition.error;
+    }
+    return (0, state_1.updateState)(goalId, patch, projectDir);
+}
+async function recordSession(goalId, phase, sessionId, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    const sessions = { ...state.sessions };
+    sessions[phase] = {
+        id: sessionId,
+        createdAt: new Date().toISOString(),
+        active: true
+    };
+    return (0, state_1.updateState)(goalId, { sessions }, projectDir);
+}
+/**
+ * Record session in gateway.db goal_sessions table.
+ * Called by index.ts orchestrator bridge after recordSession writes state file.
+ * Separated to keep phase-orchestrator free of GatewayDatabase import.
+ */
+function recordSessionInDb(db, info) {
+    try {
+        db.addGoalSession({
+            goal_id: info.goalId,
+            session_id: info.sessionId,
+            phase: info.phase,
+            loop: info.loop,
+        });
+    }
+    catch (err) {
+        logger_1.log.warn(`[Orchestrator] recordSessionInDb failed (non-fatal): ${err.message}`);
+    }
+}
+async function updateWaveProgress(goalId, currentWave, totalWaves, projectDir = '.') {
+    return (0, state_1.updateState)(goalId, { currentWave, totalWaves }, projectDir);
+}
+async function startNextLoop(goalId, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    return (0, state_1.updateState)(goalId, {
+        loop: state.loop + 1,
+        phase: 'PLANNING',
+        lastPhase: state.phase,
+        currentWave: 0,
+        totalWaves: null,
+        sessions: {},
+        nextAction: 'WAIT_PHASE_COMPLETE',
+        artifacts: {},
+        error: undefined
+    }, projectDir);
+}
+async function getCurrentPhase(goalId, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    return state.phase;
+}
+async function canExecuteInPhase(goalId, requiredPhase, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    return state.phase === requiredPhase;
+}
+async function markSessionDestroyed(goalId, phase, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    const sessions = { ...state.sessions };
+    if (sessions[phase]) {
+        sessions[phase] = {
+            ...sessions[phase],
+            destroyedAt: new Date().toISOString(),
+            active: false
+        };
+    }
+    return (0, state_1.updateState)(goalId, { sessions }, projectDir);
+}
+async function shouldStartNextLoop(goalId, projectDir = '.') {
+    const state = await (0, state_1.loadState)(goalId, projectDir);
+    const reqPath = path.join(projectDir, '.mafw/requests', `${goalId}.json`);
+    if (!fs.existsSync(reqPath)) {
+        return { should: true, reason: 'no request file, allowing' };
+    }
+    const req = JSON.parse(fs.readFileSync(reqPath, 'utf-8'));
+    if (state.loop >= req.maxLoops) {
+        return { should: false, reason: `maxLoops reached (${state.loop}/${req.maxLoops})` };
+    }
+    return { should: true, reason: 'next loop available' };
+}
+async function handleLoopEvent(goalId, trigger, data, loopNum, projectDir = '.') {
+    return true;
+}

package/gateway/dist/core/engine/report-generator.js

@@ -0,0 +1,131 @@
+"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.ReportGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Report Generator — 执行报告生成器
+ *
+ * 职责：
+ *   1. Goal 成功完成时生成成功报告
+ *   2. 降级完成时生成降级报告
+ *   3. Archive 阶段调用 L3 Validator
+ *
+ * 输出：.mafw/reports/{goal_id}.md
+ */
+class ReportGenerator {
+    reportsDir;
+    constructor(projectDir = '.') {
+        this.reportsDir = path.join(projectDir, '.mafw/reports');
+        if (!fs.existsSync(this.reportsDir))
+            fs.mkdirSync(this.reportsDir, { recursive: true });
+    }
+    /**
+     * 生成成功报告
+     */
+    async generate(goalId, data) {
+        const reportPath = path.join(this.reportsDir, `${goalId}.md`);
+        const lines = [
+            `# MAFW 执行报告 — ${goalId}`,
+            '',
+            `> Goal ID: ${goalId}`,
+            `> 完成时间: ${new Date().toISOString()}`,
+            `> Loop 迭代: ${data.loopCount} 次`,
+            '',
+            '## 1. 执行摘要',
+            '',
+            '实现目标已完成。',
+            '',
+            '- **初始目标**: ' + goalId,
+            '- **最终状态**: ✅ 全部指标达成',
+            `- **Loop 迭代**: ${data.loopCount} 次`,
+            '',
+            '## 2. Wave 执行摘要',
+            '',
+            '| Wave | 名称 | Task 数 | 状态 |',
+            '|------|------|---------|------|',
+            ...(data.executeResult.waves || []).map((w, i) => `| ${i + 1} | ${w.waveId} | ${w.tasks?.length || 0} | ✅ |`),
+            '',
+            '## 3. 指标达成情况',
+            '',
+            '| 指标 | 目标 | 实际 | 状态 |',
+            '|------|------|------|------|',
+            '| Review verdict | pass | pass | ✅ |',
+            '',
+            '## 4. L3 Parametric Memory 固化清单',
+            '',
+            '> 详见 parametric/base-skill-manifest.yaml',
+            '',
+            '---',
+            '*Report generated by MAFW Loop Agent v2.0*',
+            ''
+        ];
+        fs.writeFileSync(reportPath, lines.join('\n'), 'utf-8');
+        return reportPath;
+    }
+    /**
+     * 生成降级报告
+     */
+    async generateDegraded(goalId, data) {
+        const reportPath = path.join(this.reportsDir, `${goalId}-degraded.md`);
+        const lines = [
+            `# MAFW 降级报告 — ${goalId}`,
+            '',
+            `> Goal ID: ${goalId}`,
+            `> 状态: 部分完成（降级）`,
+            `> 原因: ${data.reason}`,
+            '',
+            '## 执行摘要',
+            '',
+            `- **计划目标**: ${goalId}`,
+            `- **实际状态**: ${data.reason}`,
+            `- **降级策略**: 自动降级`,
+            `- **总 Loop**: ${data.loopCount}`,
+            '',
+            '## 建议后续操作',
+            '',
+            '1. 查看降级报告了解具体问题',
+            '2. 修复后运行 `/skill mafw-loop` 继续迭代',
+            '',
+            '---',
+            '*Degraded report generated by MAFW Loop Agent v2.0*',
+            ''
+        ];
+        fs.writeFileSync(reportPath, lines.join('\n'), 'utf-8');
+        return reportPath;
+    }
+}
+exports.ReportGenerator = ReportGenerator;

package/gateway/dist/core/engine/state-lock.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateLockManager = void 0;
+class StateLockManager {
+    locks = new Map();
+    defaultTimeout;
+    sweepInterval;
+    constructor(config) {
+        this.defaultTimeout = config?.defaultTimeout ?? 300000;
+        if (config?.sweepIntervalMs) {
+            this.startSweep(config.sweepIntervalMs);
+        }
+    }
+    lockKey(goalId, loopNum, waveNum) {
+        return `${goalId}:${loopNum}:${waveNum}`;
+    }
+    async acquireLock(goalId, loopNum, waveNum, agentId, timeout) {
+        const key = this.lockKey(goalId, loopNum, waveNum);
+        const existing = this.locks.get(key);
+        const now = new Date();
+        if (existing && new Date(existing.expiresAt) > now) {
+            return false;
+        }
+        if (existing && new Date(existing.expiresAt) <= now) {
+            this.locks.delete(key);
+        }
+        const t = timeout ?? this.defaultTimeout;
+        this.locks.set(key, {
+            goalId,
+            loopNum,
+            waveNum,
+            agentId,
+            acquiredAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + t).toISOString()
+        });
+        return true;
+    }
+    async releaseLock(goalId, loopNum, waveNum) {
+        this.locks.delete(this.lockKey(goalId, loopNum, waveNum));
+    }
+    async heartbeat(goalId, loopNum, waveNum) {
+        const key = this.lockKey(goalId, loopNum, waveNum);
+        const lock = this.locks.get(key);
+        if (lock) {
+            lock.expiresAt = new Date(Date.now() + this.defaultTimeout).toISOString();
+        }
+    }
+    getLock(goalId, loopNum, waveNum) {
+        const key = this.lockKey(goalId, loopNum, waveNum);
+        const lock = this.locks.get(key);
+        if (lock && new Date(lock.expiresAt) > new Date()) {
+            return lock;
+        }
+        if (lock) {
+            this.locks.delete(key);
+        }
+        return null;
+    }
+    isLocked(goalId, loopNum, waveNum) {
+        return this.getLock(goalId, loopNum, waveNum) !== null;
+    }
+    async releaseAllForGoal(goalId) {
+        for (const [key, lock] of this.locks) {
+            if (lock.goalId === goalId) {
+                this.locks.delete(key);
+            }
+        }
+    }
+    startSweep(intervalMs) {
+        this.stop();
+        this.sweepInterval = setInterval(() => {
+            const now = new Date();
+            for (const [key, lock] of this.locks) {
+                if (new Date(lock.expiresAt) <= now) {
+                    this.locks.delete(key);
+                }
+            }
+        }, intervalMs ?? 60000);
+    }
+    stop() {
+        if (this.sweepInterval) {
+            clearInterval(this.sweepInterval);
+            this.sweepInterval = undefined;
+        }
+    }
+    getActiveLocks() {
+        const now = new Date();
+        return Array.from(this.locks.values()).filter(lock => new Date(lock.expiresAt) > now);
+    }
+}
+exports.StateLockManager = StateLockManager;

package/gateway/dist/core/engine/task-branch-manager.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskBranchManager = void 0;
+const logger_1 = require("../utils/logger");
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Task Branch Manager — Task 级 Git 分支隔离
+ *
+ * 鑱岃矗锛?
+ *   1. 为每个 Task 创建独立 Git 分支（change/{taskId}）
+ *   2. 基于 Goal 分支创建 Task 分支
+ *   3. Task 完成后合并回 Goal 分支
+ *   4. 删除 Task 分支
+ *
+ * 设计原则：
+ *   - Task 鍒嗘敮浠?Goal 鍒嗘敮鍒囧嚭
+ *   - 多个 Task 可以在各自的 change/{taskId} 分支上并行开发
+ *   - Task 瀹屾垚鍚庡悎骞跺洖 Goal 鍒嗘敮锛岀劧鍚庡垹闄?Task 鍒嗘敮
+ */
+class TaskBranchManager {
+    baseBranches = new Map();
+    /**
+     * 创建 Task 分支
+     */
+    async createTaskBranch(worktreeDir, taskId, baseBranch) {
+        const git = (0, simple_git_1.default)(worktreeDir);
+        const branch = `change/${taskId}`;
+        // 先切换到 base branch
+        await git.checkout(baseBranch);
+        // 鍒涘缓骞跺垏鎹?Task 鍒嗘敮
+        const branches = await git.branchLocal();
+        if (!branches.all.includes(branch)) {
+            await git.checkoutLocalBranch(branch);
+        }
+        else {
+            await git.checkout(branch);
+        }
+        this.baseBranches.set(`${worktreeDir}::${taskId}`, baseBranch);
+        return branch;
+    }
+    /**
+     * 鍚堝苟 Task 鍒嗘敮鍥?Goal 鍒嗘敮
+     */
+    async mergeTaskBranch(worktreeDir, taskId) {
+        const git = (0, simple_git_1.default)(worktreeDir);
+        const branch = `change/${taskId}`;
+        const goalBranch = this.baseBranches.get(`${worktreeDir}::${taskId}`) || await this.getCurrentBranch(worktreeDir);
+        // 鍒囨崲鍥?Goal 鍒嗘敮
+        await git.checkout(goalBranch);
+        // 合并 Task 分支
+        try {
+            await git.merge([branch, '--no-ff', '-m', `Merge task ${taskId}`]);
+            logger_1.log.info(`[TaskBranch] Merged ${branch} into ${goalBranch}`);
+        }
+        catch (err) {
+            logger_1.log.error(`[TaskBranch] Merge conflict in ${branch}:`, err.message);
+            await git.merge(['--abort']);
+            throw new Error(`Task merge conflict: ${taskId}`);
+        }
+        // 删除 Task 分支
+        await git.raw(['branch', '-D', branch]);
+        logger_1.log.info(`[TaskBranch] Deleted branch ${branch}`);
+    }
+    /**
+     * 获取当前分支
+     */
+    async getCurrentBranch(worktreeDir) {
+        const git = (0, simple_git_1.default)(worktreeDir);
+        const result = await git.revparse(['--abbrev-ref', 'HEAD']);
+        return result.trim();
+    }
+    /**
+     * 批量合并 Task 分支（Wave 完成后）
+     */
+    async mergeTaskBranches(worktreeDir, taskIds) {
+        for (const taskId of taskIds) {
+            try {
+                await this.mergeTaskBranch(worktreeDir, taskId);
+            }
+            catch (err) {
+                logger_1.log.error(`[TaskBranch] Failed to merge task ${taskId}: ${err.message}`);
+                // 继续合并其他 task，不中断
+            }
+        }
+    }
+    /**
+     * 娓呯悊鎵€鏈?Task 鍒嗘敮
+     */
+    async cleanupAllTaskBranches(worktreeDir) {
+        const git = (0, simple_git_1.default)(worktreeDir);
+        const branches = await git.branchLocal();
+        const taskBranches = branches.all.filter((b) => b.startsWith('change/'));
+        for (const branch of taskBranches) {
+            await git.raw(['branch', '-D', branch]);
+            logger_1.log.info(`[TaskBranch] Cleaned up ${branch}`);
+        }
+    }
+}
+exports.TaskBranchManager = TaskBranchManager;

package/gateway/dist/core/engine/wave-dependency.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveDependencyManager = void 0;
+class WaveDependencyManager {
+    dependencies = new Map();
+    key(goalId, loopNum) {
+        return `${goalId}:${loopNum}`;
+    }
+    setDependencies(goalId, loopNum, deps) {
+        this.dependencies.set(this.key(goalId, loopNum), deps);
+    }
+    canStartWave(goalId, loopNum, waveNum) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        if (!deps)
+            return false;
+        const wave = deps.find(d => d.waveNum === waveNum);
+        if (!wave)
+            return false;
+        if (wave.dependsOn.length === 0)
+            return true;
+        return wave.dependsOn.every(depNum => {
+            const dep = deps.find(d => d.waveNum === depNum);
+            return dep && dep.status === 'completed';
+        });
+    }
+    updateWaveStatus(goalId, loopNum, waveNum, status) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        if (!deps)
+            return;
+        const wave = deps.find(d => d.waveNum === waveNum);
+        if (wave) {
+            wave.status = status;
+        }
+    }
+    getReadyWaves(goalId, loopNum) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        if (!deps)
+            return [];
+        return deps
+            .filter(w => w.status === 'pending' && this.canStartWave(goalId, loopNum, w.waveNum))
+            .map(w => w.waveNum);
+    }
+    getBlockedWaves(goalId, loopNum) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        if (!deps)
+            return [];
+        return deps
+            .filter(w => w.status === 'pending' && !this.canStartWave(goalId, loopNum, w.waveNum))
+            .map(w => w.waveNum);
+    }
+    getAllStatus(goalId, loopNum) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        return deps ? [...deps] : [];
+    }
+    getCompletedWaves(goalId, loopNum) {
+        const deps = this.dependencies.get(this.key(goalId, loopNum));
+        if (!deps)
+            return [];
+        return deps
+            .filter(w => w.status === 'completed')
+            .map(w => w.waveNum);
+    }
+    clear(goalId, loopNum) {
+        this.dependencies.delete(this.key(goalId, loopNum));
+    }
+}
+exports.WaveDependencyManager = WaveDependencyManager;

package/gateway/dist/core/engine/wave-executor.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveExecutor = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Wave Executor — Wave 调度 + Task 并行执行器 (v2.1)
+ *
+ * 按 Goal 隔离：所有 Wave/Task 在同一个 Goal 分支上执行。
+ * 不再为每个 Task 创建独立分支。
+ *
+ * 鑱岃矗锛?
+ *   1. 串行执行 Wave（Wave 间有依赖）
+ *   2. 每个 Wave 内并行执行 Task（共享同一个 Goal 分支）
+ *   3. 宸ュ叿杈撳嚭 > 1000 tokens 鏃舵埅鏂?
+ */
+class WaveExecutor {
+    projectDir;
+    constructor(projectDir = '.') {
+        this.projectDir = projectDir;
+    }
+    async run(waves, goalId, loopCount) {
+        const results = [];
+        const digests = [];
+        for (let i = 0; i < waves.length; i++) {
+            const wave = waves[i];
+            logger_1.log.info(`  [WaveExecutor] Wave ${i + 1}/${waves.length}: ${wave.name}`);
+            // Wave 内 Task 并行（在同个 Goal 分支上）
+            const waveResult = await this.executeWave(wave, goalId, loopCount);
+            results.push(waveResult);
+            // 生成 Wave 摘要
+            const digest = this.createDigest(wave, waveResult, i + 1);
+            digests.push(digest);
+            // 工具输出截断
+            this.truncateToolOutputs(waveResult);
+        }
+        return {
+            waves: results,
+            digests,
+            loopCount,
+            domain: waves[0]?.domain || 'general',
+            currentTask: waves[waves.length - 1]?.tasks?.[waves[waves.length - 1].tasks.length - 1]?.id || 'unknown',
+            filesChanged: this.collectFilesChanged(results)
+        };
+    }
+    async executeWave(wave, goalId, loopCount) {
+        const tasks = wave.tasks || [];
+        // 鎵€鏈?Task 鍦ㄥ悓涓?Goal 鍒嗘敮涓婂苟琛屾墽琛?
+        const taskResults = await Promise.all(tasks.map((task) => this.executeTask(task, goalId, loopCount)));
+        return { waveId: wave.id, tasks: taskResults, status: 'completed' };
+    }
+    async executeTask(task, goalId, loopCount) {
+        logger_1.log.info(`    [Task] ${task.id} (goal ${goalId}): ${task.description}`);
+        // 模拟执行
+        const result = {
+            taskId: task.id,
+            status: 'completed',
+            filesChanged: task.affected_files || [],
+            metrics: {
+                coverage: Math.floor(Math.random() * 40) + 60,
+                lint_errors: 0
+            },
+            output: ''
+        };
+        return result;
+    }
+    /**
+     * L1 瀹炴椂锛氬伐鍏疯緭鍑烘埅鏂?
+     */
+    truncateToolOutputs(waveResult) {
+        for (const task of waveResult.tasks || []) {
+            if (task.output && task.output.length > 1000) {
+                const lines = task.output.split('\n');
+                const lastLines = lines.slice(-10);
+                task.output = `[TRUNCATED: ${lines.length} lines 鈫?last 10]\n${lastLines.join('\n')}`;
+                task._truncated = true;
+            }
+        }
+    }
+    createDigest(wave, waveResult, waveNum) {
+        return {
+            id: `wave-${waveNum}`,
+            status: waveResult.tasks.every((t) => t.status === 'completed') ? 'PASS' : 'FAIL',
+            tokens_saved: 0,
+            domain: wave.domain || 'general',
+            completed_tasks: waveResult.tasks.map((t) => t.taskId),
+            key_decisions: wave.key_decisions || [],
+            metrics: {
+                coverage: waveResult.tasks.reduce((sum, t) => sum + (t.metrics?.coverage || 0), 0) / (waveResult.tasks.length || 1),
+                lint_errors: waveResult.tasks.reduce((sum, t) => sum + (t.metrics?.lint_errors || 0), 0)
+            },
+            blockers: waveResult.tasks.filter((t) => t.status !== 'completed').map((t) => t.taskId),
+            files_changed: this.collectFilesChanged([waveResult])
+        };
+    }
+    collectFilesChanged(results) {
+        const files = new Set();
+        for (const r of results) {
+            for (const task of r.tasks || []) {
+                for (const f of task.filesChanged || [])
+                    files.add(f);
+            }
+        }
+        return Array.from(files);
+    }
+    /**
+     * Goal 完成后合并到 main
+     */
+    async mergeToMain(goalId) {
+        logger_1.log.info(`[WaveExecutor] Goal ${goalId} completed, merging to main`);
+    }
+}
+exports.WaveExecutor = WaveExecutor;