openmatrix 0.1.55 → 0.1.56

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.55",
+  "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 工具执行:
@@ -176,8 +174,17 @@ Agent({
 - [下一个 Agent 应该注意什么]
 ```
 
-2. 更新任务状态
-3. **立即检查是否还有未完成任务** — 读取 `.openmatrix/state.json` 中的 statistics，如果 completed < totalTasks，继续执行下一个
+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):**

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,7 +197,11 @@ Agent({
 ```
 
 每个 Agent 完成后:
-1. **保存 Agent 上下文** — 将执行结果摘要写入 `.openmatrix/tasks/TASK-XXX/context.md`，格式如下:
+1. **标记完成并更新统计（必须执行）:**
+```bash
+openmatrix complete TASK-XXX --success
+```
+2. **保存 Agent 上下文** — 将执行结果摘要写入 `.openmatrix/tasks/TASK-XXX/context.md`，格式如下:
 
 ```markdown
 ## 任务: TASK-XXX 任务标题
@@ -219,9 +220,14 @@ Agent({
 - [下一个 Agent 应该注意什么]
 ```
 
-2. 更新任务状态: `openmatrix complete <taskId>` 或更新 state
 3. Git 自动提交（必须使用下方统一提交格式）
-4. **立即检查是否还有未完成任务** — 读取 `.openmatrix/state.json` 中的 statistics，如果 completed < totalTasks，继续执行下一个
+4. **获取下一个任务（防止上下文压缩丢失）:**
+```bash
+openmatrix step --json
+```
+如果返回 `status: "next"` → 继续执行返回的 task
+如果返回 `status: "done"` → 所有任务完成，进入最终提交
+如果返回 `status: "blocked"` → 有阻塞任务，处理 Meeting
 5. 检查审批点（auto 模式自动批准，其他模式按配置暂停）
 
 **Agent 上下文共享机制 (Agent Memory):**