openmatrix 0.1.54 → 0.1.56

package/dist/agents/agent-runner.d.ts

@@ -67,6 +67,12 @@ export declare class AgentRunner {
      * 构建完整的执行提示词
      */
     buildExecutionPrompt(task: Task): string;
+    /**
+     * 构建累积上下文 - 从已完成任务中提取共享信息
+     *
+     * 读取所有已完成任务的 context.md，为当前 Agent 提供前序 Agent 的决策和知识
+     */
+    private buildAccumulatedContext;
     /**
      * 构建阶段上下文
      */

package/dist/agents/agent-runner.js

@@ -1,6 +1,41 @@
 "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.AgentRunner = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 /**
  * AgentRunner - 使用 Subagent 执行任务
  *
@@ -101,6 +136,7 @@ class AgentRunner {
     buildExecutionPrompt(task) {
         const agentPrompt = this.buildAgentPrompt(task);
         const phaseContext = this.buildPhaseContext(task);
+        const accumulatedContext = this.buildAccumulatedContext(task);
         return `# 任务执行
 
 ## 任务信息
@@ -118,6 +154,8 @@ ${task.dependencies.length > 0
             ? task.dependencies.map(d => `- ${d}`).join('\n')
             : '无依赖'}
 
+${accumulatedContext}
+
 ---
 
 ${agentPrompt.context}
@@ -130,8 +168,47 @@ ${agentPrompt.instructions}
 
 1. 完成任务后，更新任务状态文件: \`.openmatrix/tasks/${task.id}/task.json\`
 2. 将执行结果写入: \`.openmatrix/tasks/${task.id}/artifacts/result.md\`
-3. 如需审批，创建审批请求: \`.openmatrix/approvals/\` 目录
+3. 将上下文摘要写入: \`.openmatrix/tasks/${task.id}/context.md\` (供后续 Agent 读取)
+4. 如需审批，创建审批请求: \`.openmatrix/approvals/\` 目录
+`;
+    }
+    /**
+     * 构建累积上下文 - 从已完成任务中提取共享信息
+     *
+     * 读取所有已完成任务的 context.md，为当前 Agent 提供前序 Agent 的决策和知识
+     */
+    buildAccumulatedContext(currentTask) {
+        const omPath = path.join(process.cwd(), '.openmatrix');
+        const tasksDir = path.join(omPath, 'tasks');
+        try {
+            if (!fs.existsSync(tasksDir))
+                return '';
+            const contextParts = [];
+            // 读取所有已完成任务的 context.md
+            const taskDirs = fs.readdirSync(tasksDir).filter(name => name.startsWith('TASK-'));
+            for (const taskId of taskDirs) {
+                const contextFile = path.join(tasksDir, taskId, 'context.md');
+                if (fs.existsSync(contextFile)) {
+                    const content = fs.readFileSync(contextFile, 'utf-8').trim();
+                    if (content) {
+                        contextParts.push(`### ${taskId}\n${content}`);
+                    }
+                }
+            }
+            if (contextParts.length === 0)
+                return '';
+            return `
+## 前序 Agent 共享上下文 (Agent Memory)
+
+以下是之前执行的 Agent 留下的上下文信息，包含它们的决策、发现和注意事项。
+你应该基于这些信息来工作，避免重复犯错或与已有决策冲突。
+
+${contextParts.join('\n\n')}
 `;
+        }
+        catch {
+            return '';
+        }
     }
     /**
      * 构建阶段上下文

package/dist/cli/commands/complete.js

@@ -37,64 +37,71 @@ exports.completeCommand = void 0;
 // src/cli/commands/complete.ts
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
-const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
-const executor_js_1 = require("../../orchestrator/executor.js");
 const path = __importStar(require("path"));
 exports.completeCommand = new commander_1.Command('complete')
-    .description('标记任务完成或失败')
-    .argument('<taskId>', '任务 ID')
-    .option('--success', '标记为成功')
+    .description('标记任务完成并更新全局统计')
+    .argument('<taskId>', '任务ID (如 TASK-001)')
+    .option('--success', '标记为成功完成 (默认)', true)
     .option('--failed', '标记为失败')
-    .option('--error <message>', '错误信息')
-    .option('--output <text>', '执行输出')
-    .option('--json', 'JSON 输出')
+    .option('--output <text>', '执行结果摘要')
+    .option('--error <text>', '错误信息 (失败时)')
     .action(async (taskId, options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
     const stateManager = new state_manager_js_1.StateManager(omPath);
     await stateManager.initialize();
-    const state = await stateManager.getState();
-    // 构建执行器
-    const approvalManager = new approval_manager_js_1.ApprovalManager(stateManager);
-    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
-        maxConcurrent: state.config.maxConcurrentAgents,
-        taskTimeout: state.config.timeout * 1000
-    });
-    const success = options.success || !options.failed;
-    // 标记任务完成
-    await executor.completeTask(taskId, {
-        success,
-        output: options.output,
-        error: options.error
-    });
-    if (options.json) {
-        // 获取下一批可执行任务
-        const nextResult = await executor.step();
-        const updatedTask = await stateManager.getTask(taskId);
-        console.log(JSON.stringify({
-            status: success ? 'completed' : 'failed',
-            taskId,
-            taskStatus: updatedTask?.status,
-            nextBatch: {
-                status: nextResult.status,
-                subagentTasks: nextResult.subagentTasks.map(t => ({
-                    subagent_type: t.subagent_type,
-                    description: t.description,
-                    prompt: t.prompt,
-                    isolation: t.isolation,
-                    taskId: t.taskId,
-                    agentType: t.agentType,
-                    timeout: t.timeout
-                })),
-                statistics: nextResult.statistics
+    // 1. 读取任务
+    const task = await stateManager.getTask(taskId);
+    if (!task) {
+        console.log(JSON.stringify({ error: `任务 ${taskId} 不存在` }));
+        process.exit(1);
+    }
+    const isSuccess = !options.failed;
+    const now = new Date().toISOString();
+    if (isSuccess) {
+        // 2a. 标记任务完成 - 更新所有阶段
+        await stateManager.updateTask(taskId, {
+            status: 'completed',
+            phases: {
+                develop: { status: 'completed', duration: 0, completedAt: now },
+                verify: { status: 'completed', duration: 0, completedAt: now },
+                accept: { status: 'completed', duration: 0, completedAt: now }
             }
-        }));
+        });
     }
     else {
-        const emoji = success ? '✅' : '❌';
-        console.log(`${emoji} 任务 ${taskId} ${success ? '完成' : '失败'}`);
-        if (!success && options.error) {
-            console.log(`   错误: ${options.error}`);
-        }
+        // 2b. 标记任务失败
+        await stateManager.updateTask(taskId, {
+            status: 'failed',
+            error: options.error || 'Task failed'
+        });
     }
+    // 3. 重新计算全局统计（从实际任务文件统计，避免累积误差）
+    const allTasks = await stateManager.listTasks();
+    const stats = {
+        totalTasks: allTasks.length,
+        completed: allTasks.filter(t => t.status === 'completed').length,
+        inProgress: allTasks.filter(t => t.status === 'in_progress').length,
+        failed: allTasks.filter(t => t.status === 'failed').length,
+        pending: allTasks.filter(t => t.status === 'pending' || t.status === 'scheduled').length
+    };
+    // 4. 更新全局状态
+    const allDone = stats.completed + stats.failed === stats.totalTasks;
+    await stateManager.updateState({
+        statistics: stats,
+        status: allDone ? 'completed' : 'running',
+        currentPhase: allDone ? 'completed' : 'execution',
+        ...(allDone ? { completedAt: now } : {})
+    });
+    // 5. 输出结果
+    const result = {
+        taskId,
+        status: isSuccess ? 'completed' : 'failed',
+        statistics: stats,
+        allDone,
+        message: isSuccess
+            ? `${taskId} 完成 (${stats.completed}/${stats.totalTasks})`
+            : `${taskId} 失败: ${options.error || 'Unknown error'}`
+    };
+    console.log(JSON.stringify(result, null, 2));
 });

package/dist/cli/commands/step.js

@@ -35,68 +35,82 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepCommand = void 0;
 // src/cli/commands/step.ts
+// 循环状态持久化 - 防止上下文压缩导致循环丢失
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
-const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
-const executor_js_1 = require("../../orchestrator/executor.js");
 const path = __importStar(require("path"));
 exports.stepCommand = new commander_1.Command('step')
-    .description('获取下一批可执行任务')
-    .option('--json', 'JSON 输出')
+    .description('获取下一个待执行任务（持久化循环状态）')
+    .option('--json', '输出 JSON 格式')
     .action(async (options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
     const stateManager = new state_manager_js_1.StateManager(omPath);
     await stateManager.initialize();
     const state = await stateManager.getState();
-    if (state.status !== 'running') {
-        if (options.json) {
-            console.log(JSON.stringify({
-                status: 'error',
-                message: '没有正在执行的任务',
-                currentState: state.status
-            }));
-        }
-        else {
-            console.log('⚠️  没有正在执行的任务');
-            console.log(`   当前状态: ${state.status}`);
-        }
+    // 检查是否已完成
+    if (state.status === 'completed') {
+        console.log(JSON.stringify({ status: 'done', message: '所有任务已完成' }));
         return;
     }
-    const approvalManager = new approval_manager_js_1.ApprovalManager(stateManager);
-    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
-        maxConcurrent: state.config.maxConcurrentAgents,
-        taskTimeout: state.config.timeout * 1000
-    });
-    const phaseExecutor = executor.getPhaseExecutor();
-    if (phaseExecutor) {
-        phaseExecutor.setRunId(state.runId);
-    }
-    const result = await executor.step();
-    if (options.json) {
+    // 获取所有任务
+    const allTasks = await stateManager.listTasks();
+    const nextTask = allTasks.find(t => t.status === 'pending' ||
+        t.status === 'scheduled' ||
+        t.status === 'in_progress');
+    if (!nextTask) {
+        // 所有任务都完成了或被阻塞
+        const completed = allTasks.filter(t => t.status === 'completed').length;
+        const total = allTasks.length;
+        // 自动更新统计
+        const stats = {
+            totalTasks: total,
+            completed: completed,
+            inProgress: allTasks.filter(t => t.status === 'in_progress').length,
+            failed: allTasks.filter(t => t.status === 'failed').length,
+            pending: allTasks.filter(t => t.status === 'pending').length
+        };
+        const allDone = completed + stats.failed === total;
+        await stateManager.updateState({
+            statistics: stats,
+            status: allDone ? 'completed' : 'running',
+            currentPhase: allDone ? 'completed' : 'execution'
+        });
         console.log(JSON.stringify({
-            status: result.status,
-            message: result.message,
-            statistics: result.statistics,
-            subagentTasks: result.subagentTasks.map(t => ({
-                subagent_type: t.subagent_type,
-                description: t.description,
-                prompt: t.prompt,
-                isolation: t.isolation,
-                taskId: t.taskId,
-                agentType: t.agentType,
-                timeout: t.timeout
-            }))
+            status: allDone ? 'done' : 'blocked',
+            statistics: stats,
+            message: allDone
+                ? `所有任务已完成 (${completed}/${total})`
+                : `没有可执行任务 (${completed}/${total} 完成, ${stats.failed} 失败, ${stats.pending} 等待)`
         }));
+        return;
     }
-    else {
-        console.log(`状态: ${result.status}`);
-        console.log(`消息: ${result.message}`);
-        if (result.subagentTasks.length > 0) {
-            console.log(`\n📋 待执行任务 (${result.subagentTasks.length}):`);
-            result.subagentTasks.forEach((t, i) => {
-                console.log(`  ${i + 1}. [${t.agentType}] ${t.description.slice(0, 60)}`);
-            });
+    // 输出下一个任务信息
+    const result = {
+        status: 'next',
+        task: {
+            id: nextTask.id,
+            title: nextTask.title,
+            description: nextTask.description,
+            status: nextTask.status,
+            assignedAgent: nextTask.assignedAgent,
+            dependencies: nextTask.dependencies,
+            acceptanceCriteria: nextTask.acceptanceCriteria
+        },
+        statistics: {
+            total: allTasks.length,
+            completed: allTasks.filter(t => t.status === 'completed').length,
+            remaining: allTasks.filter(t => t.status === 'pending' ||
+                t.status === 'scheduled' ||
+                t.status === 'in_progress').length,
+            failed: allTasks.filter(t => t.status === 'failed').length
         }
+    };
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`📌 下一个任务: ${nextTask.id} - ${nextTask.title}`);
+        console.log(`   进度: ${result.statistics.completed}/${result.statistics.total} 完成, ${result.statistics.remaining} 剩余`);
     }
 });

package/dist/cli/index.js

@@ -15,6 +15,8 @@ const check_js_1 = require("./commands/check.js");
 const check_gitignore_js_1 = require("./commands/check-gitignore.js");
 const analyze_js_1 = require("./commands/analyze.js");
 const brainstorm_js_1 = require("./commands/brainstorm.js");
+const complete_js_1 = require("./commands/complete.js");
+const step_js_1 = require("./commands/step.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -29,6 +31,8 @@ program.addCommand(retry_js_1.retryCommand);
 program.addCommand(report_js_1.reportCommand);
 program.addCommand(meeting_js_1.meetingCommand);
 program.addCommand(auto_js_1.autoCommand);
+program.addCommand(complete_js_1.completeCommand);
+program.addCommand(step_js_1.stepCommand);
 program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);

package/dist/types/index.d.ts

@@ -75,7 +75,7 @@ export interface GlobalState {
     version: string;
     runId: string;
     status: RunStatus;
-    currentPhase: 'planning' | 'execution' | 'verification' | 'acceptance';
+    currentPhase: 'planning' | 'execution' | 'verification' | 'acceptance' | 'completed';
     startedAt: string;
     config: AppConfig;
     statistics: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/auto.md

@@ -126,23 +126,21 @@ CLI 返回的 JSON 中 `subagentTasks` 数组包含每个待执行任务:
 ❌ **禁止在还有未完成任务时停止** — 即使 Agent 返回了大段输出，也必须继续下一个
 ❌ **禁止询问"是否继续"** — 直接执行下一个任务
 ❌ **禁止输出"让我知道是否..."后停止** — 继续执行
-❌ **禁止因为上下文压缩而忘记剩余任务** — 每完成一个任务后，重新读取 state.json 确认剩余任务
+❌ **禁止因为上下文压缩而忘记剩余任务** — 通过 CLI 命令从磁盘获取真实状态
 
-**执行循环伪代码:**
-```
-remaining = subagentTasks 中 status !== 'completed' 的任务
-while (remaining.length > 0) {
-  task = remaining[0]
-  result = Agent(task)           // 执行
-  更新任务状态为 completed
-  remaining = 从 state.json 重新读取未完成任务
-}
+**文件持久化循环（防止上下文压缩丢失状态）:**
+```bash
+# 每个 Agent 完成后执行:
+openmatrix complete TASK-XXX --success       # 标记完成 + 更新统计
+openmatrix step --json                       # 获取下一个任务 + 检查是否全部完成
 ```
+`openmatrix step` 从磁盘读取真实状态，不依赖上下文记忆。
 
 **中断恢复:** 如果会话中断，再次执行 `/om:auto` 时:
-1. 读取 `.openmatrix/state.json`
-2. 如果 `status === 'running'`，读取所有任务，找到 status 不是 completed 的任务
-3. 从中断的任务继续执行，不需要重新开始
+1. 执行 `openmatrix step --json`
+2. 如果返回 `status: "next"` → 从返回的任务继续执行
+3. 如果返回 `status: "done"` → 所有任务已完成
+4. 如果返回 `status: "blocked"` → 有阻塞任务需要处理
 </LOOP-ENFORCEMENT>
 
 对 `subagentTasks` 列表中的每个任务，调用 Agent 工具执行:
@@ -157,9 +155,46 @@ Agent({
 ```
 
 每个 Agent 完成后:
-1. 更新任务状态
-2. **立即检查是否还有未完成任务** — 读取 `.openmatrix/state.json` 中的 statistics，如果 completed < totalTasks，继续执行下一个
-3. Git 自动提交（**必须使用 HEREDOC 格式**）:
+1. **保存 Agent 上下文** — 将执行结果摘要写入 `.openmatrix/tasks/TASK-XXX/context.md`，格式如下:
+
+```markdown
+## 任务: TASK-XXX 任务标题
+
+### 关键决策
+- [做出的重要决策]
+
+### 创建/修改的文件
+- `path/to/file1.ts` - 简述用途
+- `path/to/file2.ts` - 简述用途
+
+### 重要发现
+- [发现的问题、模式、注意事项]
+
+### 对后续任务的建议
+- [下一个 Agent 应该注意什么]
+```
+
+2. **标记完成并更新统计（必须执行）:**
+```bash
+openmatrix complete TASK-XXX --success
+```
+3. **获取下一个任务（防止上下文压缩丢失）:**
+```bash
+openmatrix step --json
+```
+如果返回 `status: "next"` → 继续执行返回的 task
+如果返回 `status: "done"` → 所有任务完成，进入最终提交
+如果返回 `status: "blocked"` → 有阻塞任务，处理 Meeting
+4. Git 自动提交（**必须使用 HEREDOC 格式**）:
+
+**Agent 上下文共享机制 (Agent Memory):**
+
+每个 Agent 执行时会自动接收前序 Agent 的上下文信息（通过 `context.md` 文件）。
+这确保 Agent 之间共享知识、避免重复工作、保持决策一致性。
+
+```
+Agent-1 完成 → 写入 context.md → Agent-2 读取 Agent-1 的上下文 → 写入 context.md → ...
+```
 ```bash
 git add -A && git commit -m "$(cat <<'EOF'
 feat: (TASK-XXX) 任务标题

package/skills/start.md

@@ -174,18 +174,15 @@ CLI 返回 JSON 中 `subagentTasks` 数组包含待执行任务。
 ❌ **禁止在还有未完成任务时停止** — 即使 Agent 返回了大段输出，也必须继续下一个
 ❌ **禁止询问"是否继续"** — 直接执行下一个任务
 ❌ **禁止输出"让我知道是否..."后停止** — 继续执行
-❌ **禁止因为上下文压缩而忘记剩余任务** — 每完成一个任务后，重新读取 state.json 确认剩余任务
+❌ **禁止因为上下文压缩而忘记剩余任务** — 通过 `openmatrix step --json` 重新获取状态
 
-**执行循环伪代码:**
-```
-remaining = subagentTasks 中 status !== 'completed' 的任务
-while (remaining.length > 0) {
-  task = remaining[0]
-  result = Agent(task)           // 执行
-  更新任务状态为 completed
-  remaining = 从 state.json 重新读取未完成任务
-}
+**文件持久化循环（防止上下文压缩丢失状态）:**
+```bash
+# 每个 Agent 完成后执行:
+openmatrix complete TASK-XXX --success       # 标记完成 + 更新统计
+openmatrix step --json                       # 获取下一个任务 + 检查是否全部完成
 ```
+`openmatrix step` 会从磁盘读取真实状态，不依赖上下文记忆。
 </LOOP-ENFORCEMENT>
 
 对每个任务调用 Agent 工具:
@@ -200,10 +197,47 @@ Agent({
 ```
 
 每个 Agent 完成后:
-1. 更新任务状态: `openmatrix complete <taskId>` 或更新 state
-2. Git 自动提交（必须使用下方统一提交格式）
-3. **立即检查是否还有未完成任务** — 读取 `.openmatrix/state.json` 中的 statistics，如果 completed < totalTasks，继续执行下一个
-4. 检查审批点（auto 模式自动批准，其他模式按配置暂停）
+1. **标记完成并更新统计（必须执行）:**
+```bash
+openmatrix complete TASK-XXX --success
+```
+2. **保存 Agent 上下文** — 将执行结果摘要写入 `.openmatrix/tasks/TASK-XXX/context.md`，格式如下:
+
+```markdown
+## 任务: TASK-XXX 任务标题
+
+### 关键决策
+- [做出的重要决策]
+
+### 创建/修改的文件
+- `path/to/file1.ts` - 简述用途
+- `path/to/file2.ts` - 简述用途
+
+### 重要发现
+- [发现的问题、模式、注意事项]
+
+### 对后续任务的建议
+- [下一个 Agent 应该注意什么]
+```
+
+3. Git 自动提交（必须使用下方统一提交格式）
+4. **获取下一个任务（防止上下文压缩丢失）:**
+```bash
+openmatrix step --json
+```
+如果返回 `status: "next"` → 继续执行返回的 task
+如果返回 `status: "done"` → 所有任务完成，进入最终提交
+如果返回 `status: "blocked"` → 有阻塞任务，处理 Meeting
+5. 检查审批点（auto 模式自动批准，其他模式按配置暂停）
+
+**Agent 上下文共享机制 (Agent Memory):**
+
+每个 Agent 执行时会自动接收前序 Agent 的上下文信息（通过 `context.md` 文件）。
+这确保 Agent 之间共享知识、避免重复工作、保持决策一致性。
+
+```
+Agent-1 完成 → 写入 context.md → Agent-2 读取 Agent-1 的上下文 → 写入 context.md → ...
+```
 
 **中断恢复:** 如果会话中断，再次执行 `/om:start` 时:
 1. 读取 `.openmatrix/state.json`