openmatrix 0.1.62 → 0.1.64

package/dist/orchestrator/scheduler.d.ts

@@ -12,6 +12,7 @@ export interface TaskAssignment {
 }
 export declare class Scheduler {
     private stateManager;
+    private stateMachine;
     private config;
     private runningTasks;
     constructor(stateManager: StateManager, config?: Partial<SchedulerConfig>);
@@ -27,6 +28,10 @@ export declare class Scheduler {
      * 获取优先级权重
      */
     private getPriorityWeight;
+    /**
+     * 通过状态机验证并执行状态转换
+     */
+    private transitionTask;
     /**
      * 标记任务开始执行
      */
@@ -48,9 +53,18 @@ export declare class Scheduler {
      */
     markTaskBlocked(taskId: string, reason: string): Promise<void>;
     /**
-     * 获取所有可并行执行的任务
+     * 获取所有可并行执行的任务（按优先级排序）
      */
     getParallelTasks(): Promise<Task[]>;
+    /**
+     * 检测循环依赖（DFS）
+     * 返回所有检测到的循环路径
+     */
+    detectCircularDependencies(tasks: Task[]): string[][];
+    /**
+     * 检测循环依赖并将相关任务标记为 blocked
+     */
+    private handleCircularDependencies;
     /**
      * 获取调度状态
      */

package/dist/orchestrator/scheduler.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scheduler = void 0;
+const state_machine_js_1 = require("./state-machine.js");
 class Scheduler {
     stateManager;
+    stateMachine;
     config;
     runningTasks = new Set();
     constructor(stateManager, config) {
         this.stateManager = stateManager;
+        this.stateMachine = new state_machine_js_1.StateMachine();
         this.config = {
             maxConcurrentTasks: 3,
-            taskTimeout: 120000,
+            taskTimeout: 600000, // 10 分钟
             ...config
         };
     }
@@ -18,6 +21,8 @@ class Scheduler {
      */
     async getNextTask() {
         const tasks = await this.stateManager.listTasks();
+        // 检测并处理循环依赖
+        await this.handleCircularDependencies(tasks);
         // 筛选可执行任务
         const executable = tasks.filter(task => this.canExecute(task, tasks));
         if (executable.length === 0) {
@@ -62,13 +67,28 @@ class Scheduler {
         };
         return weights[priority] || 0;
     }
+    /**
+     * 通过状态机验证并执行状态转换
+     */
+    async transitionTask(taskId, event, extraUpdates) {
+        const task = await this.stateManager.getTask(taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        const result = this.stateMachine.transition(task, event);
+        if (!result.success) {
+            throw new Error(`状态转换失败 [${task.id}]: ${result.error}`);
+        }
+        await this.stateManager.updateTask(taskId, {
+            status: result.toStatus,
+            ...extraUpdates
+        });
+    }
     /**
      * 标记任务开始执行
      */
     async markTaskStarted(taskId) {
         this.runningTasks.add(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'in_progress',
+        await this.transitionTask(taskId, 'start', {
             phases: {
                 develop: { status: 'in_progress', duration: null, startedAt: new Date().toISOString() },
                 verify: { status: 'pending', duration: null },
@@ -83,8 +103,7 @@ class Scheduler {
         this.runningTasks.delete(taskId);
         const task = await this.stateManager.getTask(taskId);
         if (task) {
-            await this.stateManager.updateTask(taskId, {
-                status: 'completed',
+            await this.transitionTask(taskId, 'accept_done', {
                 phases: {
                     ...task.phases,
                     accept: { status: 'completed', duration: 0, completedAt: new Date().toISOString() }
@@ -97,42 +116,96 @@ class Scheduler {
      */
     async markTaskFailed(taskId, error) {
         this.runningTasks.delete(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'failed',
+        const task = await this.stateManager.getTask(taskId);
+        const retryCount = task?.retryCount || 0;
+        await this.transitionTask(taskId, 'fail', {
             error,
-            retryCount: (await this.stateManager.getTask(taskId))?.retryCount || 0
+            retryCount
         });
     }
     /**
      * 标记任务等待确认
      */
     async markTaskWaiting(taskId) {
-        await this.stateManager.updateTask(taskId, {
-            status: 'waiting'
-        });
+        await this.transitionTask(taskId, 'wait');
     }
     /**
      * 标记任务阻塞（需要 Meeting）
      */
     async markTaskBlocked(taskId, reason) {
         this.runningTasks.delete(taskId);
-        await this.stateManager.updateTask(taskId, {
-            status: 'blocked',
+        await this.transitionTask(taskId, 'block', {
             error: reason
         });
     }
     /**
-     * 获取所有可并行执行的任务
+     * 获取所有可并行执行的任务（按优先级排序）
      */
     async getParallelTasks() {
         const tasks = await this.stateManager.listTasks();
-        const available = [];
+        // 检测并处理循环依赖
+        await this.handleCircularDependencies(tasks);
+        // 筛选可执行任务
+        const executable = tasks.filter(task => this.canExecute(task, tasks));
+        // 按优先级排序（高优先级优先）
+        executable.sort((a, b) => this.getPriorityWeight(b.priority) - this.getPriorityWeight(a.priority));
+        // 限制并发数
+        return executable.slice(0, this.config.maxConcurrentTasks);
+    }
+    /**
+     * 检测循环依赖（DFS）
+     * 返回所有检测到的循环路径
+     */
+    detectCircularDependencies(tasks) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (taskId, path) => {
+            visited.add(taskId);
+            recursionStack.add(taskId);
+            const task = tasks.find(t => t.id === taskId);
+            if (!task || !task.dependencies) {
+                recursionStack.delete(taskId);
+                return;
+            }
+            for (const depId of task.dependencies) {
+                if (!visited.has(depId)) {
+                    dfs(depId, [...path, depId]);
+                }
+                else if (recursionStack.has(depId)) {
+                    // 找到循环
+                    const cycleStart = path.indexOf(depId);
+                    const cycle = cycleStart >= 0
+                        ? [...path.slice(cycleStart), depId]
+                        : [taskId, depId];
+                    cycles.push(cycle);
+                }
+            }
+            recursionStack.delete(taskId);
+        };
         for (const task of tasks) {
-            if (this.canExecute(task, tasks) && available.length < this.config.maxConcurrentTasks) {
-                available.push(task);
+            if (!visited.has(task.id)) {
+                dfs(task.id, [task.id]);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * 检测循环依赖并将相关任务标记为 blocked
+     */
+    async handleCircularDependencies(tasks) {
+        const cycles = this.detectCircularDependencies(tasks);
+        for (const cycle of cycles) {
+            for (const taskId of cycle) {
+                const task = tasks.find(t => t.id === taskId);
+                if (task && (task.status === 'pending' || task.status === 'retry_queue')) {
+                    await this.stateManager.updateTask(taskId, {
+                        status: 'blocked',
+                        error: `循环依赖检测: ${cycle.join(' → ')}`
+                    });
+                }
             }
         }
-        return available;
     }
     /**
      * 获取调度状态

package/dist/orchestrator/state-machine.js

@@ -7,6 +7,8 @@ const TRANSITIONS = [
     { from: 'pending', to: 'scheduled', event: 'schedule' },
     // scheduled → in_progress
     { from: 'scheduled', to: 'in_progress', event: 'start' },
+    // pending → in_progress (跳过 scheduled，直接开始)
+    { from: 'pending', to: 'in_progress', event: 'start' },
     // in_progress → verify
     { from: 'in_progress', to: 'verify', event: 'develop_done' },
     // verify → accept

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.d.ts

@@ -2,7 +2,12 @@ import type { GlobalState, Task, Approval, ApprovalStatus } from '../types/index
 export declare class StateManager {
     private store;
     private stateCache;
+    private writeLock;
     constructor(basePath: string);
+    /**
+     * 串行化异步写操作，防止并发 read-modify-write 竞态
+     */
+    private withLock;
     initialize(): Promise<void>;
     getState(): Promise<GlobalState>;
     updateState(updates: Partial<GlobalState>): Promise<void>;

package/dist/storage/state-manager.js

@@ -12,9 +12,25 @@ const DEFAULT_CONFIG = {
 class StateManager {
     store;
     stateCache = null;
+    writeLock = Promise.resolve();
     constructor(basePath) {
         this.store = new file_store_js_1.FileStore(basePath);
     }
+    /**
+     * 串行化异步写操作，防止并发 read-modify-write 竞态
+     */
+    async withLock(fn) {
+        const prev = this.writeLock;
+        let resolve;
+        this.writeLock = new Promise(r => { resolve = r; });
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            resolve();
+        }
+    }
     async initialize() {
         const existing = await this.store.readJson('state.json');
         if (!existing) {
@@ -30,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;
         }
     }
@@ -47,46 +83,53 @@ class StateManager {
         return this.stateCache;
     }
     async updateState(updates) {
-        const state = await this.getState();
-        const newState = { ...state, ...updates };
-        await this.store.writeJson('state.json', newState);
-        this.stateCache = newState;
+        await this.withLock(async () => {
+            const state = await this.getState();
+            const newState = { ...state, ...updates };
+            await this.store.writeJson('state.json', newState);
+            this.stateCache = newState;
+        });
     }
     async createTask(input) {
-        const taskId = this.generateTaskId();
-        const now = new Date().toISOString();
-        const task = {
-            id: taskId,
-            title: input.title,
-            description: input.description,
-            status: 'pending',
-            priority: input.priority,
-            timeout: input.timeout,
-            dependencies: input.dependencies,
-            assignedAgent: input.assignedAgent,
-            phases: {
-                develop: { status: 'pending', duration: null },
-                verify: { status: 'pending', duration: null },
-                accept: { status: 'pending', duration: null }
-            },
-            retryCount: 0,
-            error: null,
-            createdAt: now,
-            updatedAt: now
-        };
-        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
-        // Create artifacts subdirectory
-        await this.store.ensureDir(`tasks/${taskId}/artifacts`);
-        // Update statistics
-        const state = await this.getState();
-        await this.updateState({
-            statistics: {
-                ...state.statistics,
-                totalTasks: state.statistics.totalTasks + 1,
-                pending: state.statistics.pending + 1
-            }
+        return this.withLock(async () => {
+            const taskId = this.generateTaskId();
+            const now = new Date().toISOString();
+            const task = {
+                id: taskId,
+                title: input.title,
+                description: input.description,
+                status: 'pending',
+                priority: input.priority,
+                timeout: input.timeout,
+                dependencies: input.dependencies,
+                assignedAgent: input.assignedAgent,
+                phases: {
+                    develop: { status: 'pending', duration: null },
+                    verify: { status: 'pending', duration: null },
+                    accept: { status: 'pending', duration: null }
+                },
+                retryCount: 0,
+                error: null,
+                createdAt: now,
+                updatedAt: now
+            };
+            await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+            // Create artifacts subdirectory
+            await this.store.ensureDir(`tasks/${taskId}/artifacts`);
+            // Update statistics
+            const state = await this.getState();
+            const newState = {
+                ...state,
+                statistics: {
+                    ...state.statistics,
+                    totalTasks: state.statistics.totalTasks + 1,
+                    pending: state.statistics.pending + 1
+                }
+            };
+            await this.store.writeJson('state.json', newState);
+            this.stateCache = newState;
+            return task;
         });
-        return task;
     }
     async getTask(taskId) {
         // Try subdirectory structure first, fall back to flat file
@@ -97,21 +140,23 @@ class StateManager {
         return task;
     }
     async updateTask(taskId, updates) {
-        const task = await this.getTask(taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        const oldStatus = task.status;
-        const updatedTask = {
-            ...task,
-            ...updates,
-            updatedAt: new Date().toISOString()
-        };
-        // Always write to subdirectory structure
-        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
-        // Update statistics if status changed
-        if (updates.status && updates.status !== oldStatus) {
-            await this.updateTaskStatistics(oldStatus, updates.status);
-        }
+        await this.withLock(async () => {
+            const task = await this.getTask(taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            const oldStatus = task.status;
+            const updatedTask = {
+                ...task,
+                ...updates,
+                updatedAt: new Date().toISOString()
+            };
+            // Always write to subdirectory structure
+            await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
+            // Update statistics if status changed
+            if (updates.status && updates.status !== oldStatus) {
+                await this.updateTaskStatistics(oldStatus, updates.status);
+            }
+        });
     }
     async listTasks() {
         const tasks = [];
@@ -168,27 +213,67 @@ class StateManager {
         return await this.store.readMarkdown(`tasks/${taskId}/context.md`);
     }
     async updateTaskStatistics(oldStatus, newStatus) {
+        // 直接写入状态，不经过 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++;
-        await this.updateState({ statistics: stats });
+        else if (newStatus === 'retry_queue')
+            stats.retry_queue++;
+        const newState = { ...state, statistics: stats };
+        await this.store.writeJson('state.json', newState);
+        this.stateCache = newState;
     }
     generateRunId() {
         const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');

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.62",
+  "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/brainstorm.md

@@ -269,6 +269,8 @@ $ARGUMENTS
 
 ## 问题类型
 
+### 项目配置问题（智能管道生成）
+
 | 问题 ID | 目的 | 为什么重要 |
 |---------|------|-----------|
 | objective | 明确任务目标（新功能/修复/重构） | 选择正确的实现策略 |
@@ -283,6 +285,17 @@ $ARGUMENTS
 
 > **智能预填**：当 `SmartQuestionAnalyzer` 对某个问题有高置信度推断时，该问题会被自动跳过，不需要用户回答。
 
+### 领域分析问题（底层逻辑思考）
+
+| 问题 ID | 目的 | 为什么重要 |
+|---------|------|-----------|
+| domain_entities | 核心领域实体建模 | 决定数据模型和 API 设计的基础 |
+| data_flow | 数据流转路径分析 | 决定架构选型（请求驱动 vs 事件驱动 vs 流处理） |
+| invariants | 关键不变量/业务约束 | 决定哪里需要加锁、事务、校验 |
+| core_scenarios | 核心用户场景链路 | 决定 MVP 功能范围和优先级排序 |
+
+> **领域分析的价值**：这四个问题帮助 AI 在执行前建立对系统的深层理解，而不是机械地按需求列表编码。答案会作为上下文注入到每个 Agent 的执行提示词中。
+
 ## 与 start 的集成
 
 头脑风暴完成后，收集的信息会传递给 start: