openmatrix 0.1.63 → 0.1.64

package/dist/orchestrator/scheduler.js

@@ -12,7 +12,7 @@ class Scheduler {
         this.stateMachine = new state_machine_js_1.StateMachine();
         this.config = {
             maxConcurrentTasks: 3,
-            taskTimeout: 120000,
+            taskTimeout: 600000, // 10 分钟
             ...config
         };
     }

package/dist/storage/file-store.d.ts

@@ -3,8 +3,16 @@ export declare class FileStore {
     constructor(basePath: string);
     ensureDir(path: string): Promise<void>;
     writeJson<T>(path: string, data: T): Promise<void>;
-    readJson<T>(path: string): Promise<T | null>;
     writeMarkdown(path: string, content: string): Promise<void>;
+    /**
+     * 读取 JSON 文件
+     * @returns 文件内容，如果文件不存在则返回 null；其他错误会抛出异常
+     */
+    readJson<T>(path: string): Promise<T | null>;
+    /**
+     * 读取 Markdown 文件
+     * @returns 文件内容，如果文件不存在则返回 null；其他错误会抛出异常
+     */
     readMarkdown(path: string): Promise<string | null>;
     exists(path: string): Promise<boolean>;
     listFiles(dir: string): Promise<string[]>;

package/dist/storage/file-store.js

@@ -18,28 +18,43 @@ class FileStore {
         await (0, promises_1.mkdir)((0, path_1.dirname)(fullPath), { recursive: true });
         await (0, promises_1.writeFile)(fullPath, JSON.stringify(data, null, 2), 'utf-8');
     }
+    async writeMarkdown(path, content) {
+        const fullPath = (0, path_1.join)(this.basePath, path);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(fullPath), { recursive: true });
+        await (0, promises_1.writeFile)(fullPath, content, 'utf-8');
+    }
+    /**
+     * 读取 JSON 文件
+     * @returns 文件内容，如果文件不存在则返回 null；其他错误会抛出异常
+     */
     async readJson(path) {
         const fullPath = (0, path_1.join)(this.basePath, path);
         try {
             const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
             return JSON.parse(content);
         }
-        catch {
-            return null;
+        catch (error) {
+            // 只隐藏"文件不存在"错误，其他错误（权限、磁盘等）抛出以便调用者处理
+            if (error.code === 'ENOENT' || error.code === 'EISDIR') {
+                return null;
+            }
+            throw error;
         }
     }
-    async writeMarkdown(path, content) {
-        const fullPath = (0, path_1.join)(this.basePath, path);
-        await (0, promises_1.mkdir)((0, path_1.dirname)(fullPath), { recursive: true });
-        await (0, promises_1.writeFile)(fullPath, content, 'utf-8');
-    }
+    /**
+     * 读取 Markdown 文件
+     * @returns 文件内容，如果文件不存在则返回 null；其他错误会抛出异常
+     */
     async readMarkdown(path) {
         const fullPath = (0, path_1.join)(this.basePath, path);
         try {
             return await (0, promises_1.readFile)(fullPath, 'utf-8');
         }
-        catch {
-            return null;
+        catch (error) {
+            if (error.code === 'ENOENT' || error.code === 'EISDIR') {
+                return null;
+            }
+            throw error;
         }
     }
     async exists(path) {

package/dist/storage/state-manager.js

@@ -46,13 +46,33 @@ class StateManager {
                     completed: 0,
                     inProgress: 0,
                     failed: 0,
-                    pending: 0
+                    pending: 0,
+                    scheduled: 0,
+                    blocked: 0,
+                    waiting: 0,
+                    verify: 0,
+                    accept: 0,
+                    retry_queue: 0
                 }
             };
             await this.store.writeJson('state.json', initialState);
             this.stateCache = initialState;
         }
         else {
+            // 合并旧状态的统计字段（兼容旧版本）
+            existing.statistics = {
+                totalTasks: existing.statistics.totalTasks ?? 0,
+                completed: existing.statistics.completed ?? 0,
+                inProgress: existing.statistics.inProgress ?? 0,
+                failed: existing.statistics.failed ?? 0,
+                pending: existing.statistics.pending ?? 0,
+                scheduled: existing.statistics.scheduled ?? 0,
+                blocked: existing.statistics.blocked ?? 0,
+                waiting: existing.statistics.waiting ?? 0,
+                verify: existing.statistics.verify ?? 0,
+                accept: existing.statistics.accept ?? 0,
+                retry_queue: existing.statistics.retry_queue ?? 0
+            };
             this.stateCache = existing;
         }
     }
@@ -196,24 +216,61 @@ class StateManager {
         // 直接写入状态，不经过 updateState（避免重入锁死锁）
         const state = await this.getState();
         const stats = { ...state.statistics };
+        // 扩展统计字段（如果不存在则初始化）
+        if (!('scheduled' in stats))
+            stats.scheduled = 0;
+        if (!('blocked' in stats))
+            stats.blocked = 0;
+        if (!('waiting' in stats))
+            stats.waiting = 0;
+        if (!('verify' in stats))
+            stats.verify = 0;
+        if (!('accept' in stats))
+            stats.accept = 0;
+        if (!('retry_queue' in stats))
+            stats.retry_queue = 0;
         // Decrement old status count
         if (oldStatus === 'pending')
             stats.pending--;
+        else if (oldStatus === 'scheduled')
+            stats.scheduled--;
         else if (oldStatus === 'in_progress')
             stats.inProgress--;
+        else if (oldStatus === 'blocked')
+            stats.blocked--;
+        else if (oldStatus === 'waiting')
+            stats.waiting--;
+        else if (oldStatus === 'verify')
+            stats.verify--;
+        else if (oldStatus === 'accept')
+            stats.accept--;
         else if (oldStatus === 'completed')
             stats.completed--;
         else if (oldStatus === 'failed')
             stats.failed--;
+        else if (oldStatus === 'retry_queue')
+            stats.retry_queue--;
         // Increment new status count
         if (newStatus === 'pending')
             stats.pending++;
+        else if (newStatus === 'scheduled')
+            stats.scheduled++;
         else if (newStatus === 'in_progress')
             stats.inProgress++;
+        else if (newStatus === 'blocked')
+            stats.blocked++;
+        else if (newStatus === 'waiting')
+            stats.waiting++;
+        else if (newStatus === 'verify')
+            stats.verify++;
+        else if (newStatus === 'accept')
+            stats.accept++;
         else if (newStatus === 'completed')
             stats.completed++;
         else if (newStatus === 'failed')
             stats.failed++;
+        else if (newStatus === 'retry_queue')
+            stats.retry_queue++;
         const newState = { ...state, statistics: stats };
         await this.store.writeJson('state.json', newState);
         this.stateCache = newState;

package/dist/types/index.d.ts

@@ -85,6 +85,12 @@ export interface GlobalState {
         inProgress: number;
         failed: number;
         pending: number;
+        scheduled: number;
+        blocked: number;
+        waiting: number;
+        verify: number;
+        accept: number;
+        retry_queue: number;
     };
 }
 export interface AppConfig {

package/package.json

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

package/skills/auto.md

@@ -1,8 +1,17 @@
 ---
 name: om:auto
-description: 全自动执行任务 - AI 拆分，无阻塞，bypass permissions
+description: 全自动执行任务指令 - AI 拆分，无阻塞，bypass permissions
 ---
 
+<NOTE>
+## 注意：区分 `/om:auto` 指令与「全自动执行」模式
+
+- **`/om:auto`** 是一个 **Skill 指令**，为 Agent 无障碍执行准备
+- **「全自动执行」**是 `/om:start` 中用户选择的 **执行模式选项**
+
+**关键区别**：`/om/auto` 不创建 Meeting 记录，直接跳过阻塞任务。
+</NOTE>
+
 <NO-OTHER-SKILLS>
 执行此技能时，不得调用 superpowers、gsd 或其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
 </NO-OTHER-SKILLS>
@@ -191,7 +200,10 @@ openmatrix step --json
 如果返回 `status: "next"` → 继续执行返回的 task
 如果返回 `status: "done"` → 所有任务完成，进入最终提交
 如果返回 `status: "blocked"` → 有阻塞任务，处理 Meeting
-4. Git 自动提交（**必须使用 HEREDOC 格式**）:
+
+**Meeting 处理机制:**
+ `/om:auto` 不创建 Meeting 记录，直接跳过阻塞任务，无障碍执行。
+
 
 **Agent 上下文共享机制 (Agent Memory):**
 

package/skills/meeting.md

@@ -345,4 +345,19 @@ openmatrix meeting --skip-all --message "批量跳过"
         ↓
 恢复执行或标记完成
 ```
+
+## 与 start 的集成
+
+执行 `/om:start` 时：
+1. 阻塞任务自动跳过，创建 Meeting 记录
+2. 非阻塞任务继续执行，最大化并行度
+3. 所有非阻塞任务完成后，自动提示有待处理的 Meeting
+4. 用户使用 `/om:meeting` 统一处理阻塞问题
+
+**全自动执行模式下的 Meeting 流程:**
+```
+/om:start → 执行任务 → 遇到阻塞 → 创建 Meeting → 跳过阻塞 → 继续执行其他任务
+          ↓
+所有非阻塞任务完成 → 提示 Meeting → /om:meeting → 用户处理 → 完成
+```
 </notes>

package/skills/start.md

@@ -131,7 +131,7 @@ AskUserQuestion({
     question: "请选择执行模式:",
     header: "执行模式",
     options: [
-      { label: "全自动执行 (推荐)", description: "无需确认，自动完成" },
+      { label: "全自动执行 (推荐)", description: "无需确认，自动完成，阻塞任务 (Meeting) 留到最后统一处理" },
       { label: "关键节点确认", description: "plan/merge 时暂停确认" },
       { label: "每阶段确认", description: "每个阶段完成后暂停" }
     ],
@@ -277,9 +277,18 @@ Agent-1 完成 → 写入 context.md → Agent-2 读取 Agent-1 的上下文 →
 **Meeting 处理（auto 模式）:** 记录并跳过，执行完成后统一展示。
 
 **执行完成后:**
+
+### Meeting 机制
+
+在「全自动执行」模式下:
+- 遇到阻塞任务时，创建 Meeting 记录并跳过该任务
+- 继续执行其他独立任务，最大化并行度
+- 所有非阻塞任务完成后，提示用户使用 `/om:meeting` 统一处理阻塞问题
+
 ```bash
 openmatrix meeting --list
 ```
+
 如有 pending Meeting，交互式处理。
 
 所有任务完成后，执行最终 Git 提交（**必须使用 HEREDOC 格式**）: