openmatrix 0.1.62 → 0.1.63

package/dist/cli/commands/brainstorm.js

@@ -449,6 +449,9 @@ async function generateSmartQuestions(taskContent, basePath) {
             multiSelect: q.type === 'multiple',
             why: ''
         }));
+        // 7. 追加领域分析问题（底层逻辑思考）
+        const domainQuestions = generateDomainAnalysisQuestions(taskContent);
+        questions.push(...domainQuestions);
         return questions;
     }
     catch (error) {
@@ -457,3 +460,121 @@ async function generateSmartQuestions(taskContent, basePath) {
         return generateBrainstormQuestions(taskContent, '');
     }
 }
+/**
+ * 领域分析问题 — 底层逻辑思考
+ *
+ * 从任务描述中提取：
+ * 1. 核心领域实体及其关系
+ * 2. 数据流转路径
+ * 3. 关键不变量/约束
+ * 4. 核心用户场景链路
+ */
+function generateDomainAnalysisQuestions(taskContent) {
+    const questions = [];
+    const content = taskContent.toLowerCase();
+    // ===== 问题 1: 领域实体建模 =====
+    const entityHints = extractEntities(taskContent);
+    if (entityHints.length > 0) {
+        questions.push({
+            id: 'domain_entities',
+            question: `从任务描述中识别到以下核心实体，请确认或补充：\n${entityHints.map(e => `  • ${e}`).join('\n')}`,
+            header: '领域实体',
+            options: [
+                { label: '以上实体正确', description: '已覆盖核心领域实体，无需补充' },
+                { label: '需要补充实体', description: '还有重要实体未被识别，我会在"其他"中补充' },
+                { label: '需要调整实体', description: '部分实体不准确，需要修正' }
+            ],
+            multiSelect: false,
+            why: '明确领域实体是设计数据模型和 API 的基础'
+        });
+    }
+    else {
+        questions.push({
+            id: 'domain_entities',
+            question: '这个系统涉及哪些核心领域实体？它们之间是什么关系？（如 用户-订单-商品）',
+            header: '领域实体',
+            options: [
+                { label: '单一实体', description: '系统围绕一个核心实体（如用户管理）' },
+                { label: '2-3 个实体', description: '少量实体间有简单关系（如用户-文章）' },
+                { label: '多实体复杂关系', description: '多个实体间有多对多等复杂关系' },
+                { label: '我来说明', description: '在"其他"中描述具体实体' }
+            ],
+            multiSelect: false,
+            why: '明确领域实体是设计数据模型和 API 的基础'
+        });
+    }
+    // ===== 问题 2: 数据流分析 =====
+    questions.push({
+        id: 'data_flow',
+        question: '数据在系统中如何流转？（从输入到存储到输出）',
+        header: '数据流',
+        options: [
+            { label: '用户输入 → 处理 → 存储 → 展示', description: '经典 CRUD 流程（如后台管理、博客）' },
+            { label: '外部 API → 转换 → 存储 → 查询', description: '数据采集/聚合类系统' },
+            { label: '事件触发 → 处理 → 通知/存储', description: '事件驱动型（如消息队列、Webhook）' },
+            { label: '实时流处理', description: '数据持续流入，实时处理（如监控、聊天）' },
+            { label: '我来说明', description: '在"其他"中描述具体数据流' }
+        ],
+        multiSelect: false,
+        why: '数据流决定架构选型（请求驱动 vs 事件驱动 vs 流处理）'
+    });
+    // ===== 问题 3: 不变量/约束 =====
+    questions.push({
+        id: 'invariants',
+        question: '系统中存在哪些关键不变量或业务约束？（什么条件必须永远成立）',
+        header: '不变量',
+        options: [
+            { label: '数据一致性', description: '如：余额不能为负、库存不能超卖、状态只能单向流转' },
+            { label: '权限控制', description: '如：用户只能操作自己的数据、管理员才能访问后台' },
+            { label: '唯一性约束', description: '如：用户名唯一、订单号不重复、同一时间只能有一个活跃会话' },
+            { label: '无明显约束', description: '纯展示或简单计算，无严格不变量' }
+        ],
+        multiSelect: true,
+        why: '不变量决定了哪些地方需要加锁、事务、校验和防御性编程'
+    });
+    // ===== 问题 4: 核心场景链路 =====
+    questions.push({
+        id: 'core_scenarios',
+        question: '从用户视角，核心操作链路是什么？（用户会走过的关键路径）',
+        header: '场景链路',
+        options: [
+            { label: '注册→登录→使用→退出', description: '典型用户系统链路' },
+            { label: '浏览→选择→下单→支付→确认', description: '电商/交易类链路' },
+            { label: '创建→编辑→预览→发布', description: '内容管理类链路' },
+            { label: '输入→处理→查看结果', description: '工具/计算类链路' },
+            { label: '我来说明', description: '在"其他"中描述具体场景链路' }
+        ],
+        multiSelect: true,
+        why: '核心场景链路决定了 MVP 的功能范围和优先级排序'
+    });
+    return questions;
+}
+/**
+ * 从任务描述中提取可能的领域实体
+ */
+function extractEntities(taskContent) {
+    const entities = [];
+    // 中文常见领域实体
+    const zhPatterns = [
+        { pattern: /用户|账号|账户|注册|登录|权限|角色/gi, entity: '用户 (User)' },
+        { pattern: /订单|交易|购买|支付|退款|结算/gi, entity: '订单 (Order)' },
+        { pattern: /商品|产品|物品|库存|上架|下架/gi, entity: '商品 (Product)' },
+        { pattern: /文章|帖子|内容|评论|标签|分类/gi, entity: '内容 (Content)' },
+        { pattern: /任务|工单|项目|里程碑|迭代/gi, entity: '任务 (Task)' },
+        { pattern: /消息|通知|推送|邮件|短信/gi, entity: '消息 (Message)' },
+        { pattern: /文件|附件|图片|视频|媒体|上传/gi, entity: '文件 (File)' },
+        { pattern: /配置|设置|参数|选项|规则/gi, entity: '配置 (Config)' },
+        { pattern: /日志|记录|审计|追踪|监控/gi, entity: '日志 (Log)' },
+        { pattern: /数据|报表|统计|分析|仪表盘|dashboard/gi, entity: '数据 (Data)' },
+        { pattern: /API|接口|端点|路由|endpoint/gi, entity: 'API' },
+        { pattern: /数据库|存储|缓存|表|collection/gi, entity: '存储 (Storage)' },
+    ];
+    const seen = new Set();
+    for (const { pattern, entity } of zhPatterns) {
+        if (pattern.test(taskContent) && !seen.has(entity)) {
+            entities.push(entity);
+            seen.add(entity);
+        }
+    }
+    return entities;
+}

package/dist/orchestrator/executor.d.ts

@@ -39,7 +39,9 @@ export declare class OrchestratorExecutor {
     private approvalManager;
     private stateMachine;
     private phaseExecutor;
+    private retryManager;
     private config;
+    private taskTimers;
     constructor(stateManager: StateManager, approvalManager: ApprovalManager, config?: Partial<ExecutorConfig>);
     /**
      * 获取 PhaseExecutor 实例
@@ -112,4 +114,21 @@ export declare class OrchestratorExecutor {
      * 获取 Scheduler 实例
      */
     getScheduler(): Scheduler;
+    /**
+     * 设置任务超时计时器
+     */
+    private setupTaskTimeout;
+    /**
+     * 清除任务超时计时器
+     */
+    private clearTaskTimeout;
+    /**
+     * 处理失败任务的重试
+     * @returns 成功加入重试队列的任务数量
+     */
+    private processRetries;
+    /**
+     * 销毁执行器，清理所有资源
+     */
+    destroy(): void;
 }

package/dist/orchestrator/executor.js

@@ -6,6 +6,7 @@ const scheduler_js_1 = require("./scheduler.js");
 const agent_runner_js_1 = require("../agents/agent-runner.js");
 const state_machine_js_1 = require("./state-machine.js");
 const phase_executor_js_1 = require("./phase-executor.js");
+const retry_manager_js_1 = require("./retry-manager.js");
 /**
  * OrchestratorExecutor - 执行循环核心
  *
@@ -18,7 +19,9 @@ class OrchestratorExecutor {
     approvalManager;
     stateMachine;
     phaseExecutor;
+    retryManager;
     config;
+    taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
@@ -37,6 +40,7 @@ class OrchestratorExecutor {
         });
         this.stateMachine = new state_machine_js_1.StateMachine();
         this.phaseExecutor = new phase_executor_js_1.PhaseExecutor(stateManager, approvalManager);
+        this.retryManager = new retry_manager_js_1.RetryManager();
     }
     /**
      * 获取 PhaseExecutor 实例
@@ -64,6 +68,18 @@ class OrchestratorExecutor {
             // 4. 检查是否有失败任务需要重试
             const failedTasks = allTasks.filter(t => t.status === 'failed');
             if (failedTasks.length > 0) {
+                // 尝试自动重试
+                const retried = await this.processRetries(failedTasks);
+                if (retried > 0) {
+                    // 有任务被重新放入队列，继续执行循环
+                    return {
+                        status: 'continue',
+                        subagentTasks: [],
+                        message: `${retried} 个失败任务已加入重试队列`,
+                        statistics: this.getStatistics(state)
+                    };
+                }
+                // 所有重试次数已耗尽
                 return this.createRetryNeededResult(failedTasks, state);
             }
             // 5. 检查是否有阻塞任务
@@ -85,9 +101,10 @@ class OrchestratorExecutor {
         }
         // 10. 准备 Subagent 任务
         const subagentTasks = await this.agentRunner.prepareSubagentTasks(executableTasks);
-        // 8. 更新任务状态为 scheduled
+        // 8. 更新任务状态为 scheduled 并设置超时
         for (const task of executableTasks) {
             await this.scheduler.markTaskStarted(task.id);
+            this.setupTaskTimeout(task.id);
         }
         return {
             status: 'continue',
@@ -241,6 +258,8 @@ class OrchestratorExecutor {
             throw new Error(`Task ${taskId} not found`);
         }
         if (result.success) {
+            // 清除超时计时器
+            this.clearTaskTimeout(taskId);
             // 更新阶段状态
             const currentPhase = this.getCurrentPhase(task);
             const updatedPhases = { ...task.phases };
@@ -281,6 +300,7 @@ class OrchestratorExecutor {
             }
         }
         else {
+            this.clearTaskTimeout(taskId);
             await this.scheduler.markTaskFailed(taskId, result.error || 'Unknown error');
         }
     }
@@ -321,5 +341,60 @@ class OrchestratorExecutor {
     getScheduler() {
         return this.scheduler;
     }
+    // ============ Timeout Management ============
+    /**
+     * 设置任务超时计时器
+     */
+    setupTaskTimeout(taskId) {
+        const timer = setTimeout(async () => {
+            console.error(`⏰ 任务超时: ${taskId} (${this.config.taskTimeout / 1000}s)`);
+            this.taskTimers.delete(taskId);
+            await this.scheduler.markTaskFailed(taskId, `Task timed out after ${this.config.taskTimeout / 1000}s`);
+        }, this.config.taskTimeout);
+        this.taskTimers.set(taskId, timer);
+    }
+    /**
+     * 清除任务超时计时器
+     */
+    clearTaskTimeout(taskId) {
+        const timer = this.taskTimers.get(taskId);
+        if (timer) {
+            clearTimeout(timer);
+            this.taskTimers.delete(taskId);
+        }
+    }
+    // ============ Retry Management ============
+    /**
+     * 处理失败任务的重试
+     * @returns 成功加入重试队列的任务数量
+     */
+    async processRetries(failedTasks) {
+        let retried = 0;
+        for (const task of failedTasks) {
+            this.retryManager.addToQueue(task.id, task.error || 'Unknown error');
+            if (this.retryManager.shouldRetry(task.id)) {
+                // 将任务从 failed 转为 retry_queue 再转为 pending
+                await this.stateManager.updateTask(task.id, {
+                    status: 'retry_queue',
+                    retryCount: (task.retryCount || 0) + 1
+                });
+                await this.stateManager.updateTask(task.id, {
+                    status: 'pending'
+                });
+                this.retryManager.removeFromQueue(task.id);
+                retried++;
+            }
+        }
+        return retried;
+    }
+    /**
+     * 销毁执行器，清理所有资源
+     */
+    destroy() {
+        for (const timer of this.taskTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.taskTimers.clear();
+    }
 }
 exports.OrchestratorExecutor = OrchestratorExecutor;

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,12 +1,15 @@
 "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,
@@ -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/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) {
@@ -47,46 +63,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 +120,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,6 +193,7 @@ 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 };
         // Decrement old status count
@@ -188,7 +214,9 @@ class StateManager {
             stats.completed++;
         else if (newStatus === 'failed')
             stats.failed++;
-        await this.updateState({ statistics: stats });
+        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/package.json

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

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: