openmatrix 0.2.21 → 0.2.23

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

@@ -128,6 +128,10 @@ export declare class AgentRunner {
      * 获取运行中的 Agent 数量
      */
     getRunningCount(): number;
+    /**
+     * 标记任务完成，释放 runningAgents 槽位
+     */
+    markTaskCompleted(taskId: string): void;
     /**
      * 检查是否可以启动新 Agent
      */

package/dist/agents/agent-runner.js

@@ -820,6 +820,12 @@ describe('MyFunction', () => {
     getRunningCount() {
         return this.runningAgents.size;
     }
+    /**
+     * 标记任务完成，释放 runningAgents 槽位
+     */
+    markTaskCompleted(taskId) {
+        this.runningAgents.delete(taskId);
+    }
     /**
      * 检查是否可以启动新 Agent
      */

package/dist/orchestrator/executor.d.ts

@@ -46,12 +46,14 @@ export declare class OrchestratorExecutor {
     private aiReviewer;
     private meetingManager;
     private config;
+    private _configReady;
     private taskTimers;
     constructor(stateManager: StateManager, approvalManager: ApprovalManager, config?: Partial<ExecutorConfig>);
     /**
      * 获取 PhaseExecutor 实例
      */
     getPhaseExecutor(): PhaseExecutor;
+    private loadConfigFromState;
     /**
      * 执行一步 - 返回待执行的 Subagent 任务
      *
@@ -65,10 +67,6 @@ export declare class OrchestratorExecutor {
      * 仅在失败/异常时才暂停
      */
     private checkApprovals;
-    /**
-     * 检查是否所有任务完成
-     */
-    private checkAllCompleted;
     /**
      * 获取统计信息
      */

package/dist/orchestrator/executor.js

@@ -26,25 +26,19 @@ class OrchestratorExecutor {
     aiReviewer;
     meetingManager;
     config;
+    _configReady;
     taskTimers = new Map();
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
         this.meetingManager = new meeting_manager_js_1.MeetingManager(stateManager, approvalManager);
-        // 从 state.config 读取 taskTimeout，如果未定义则使用默认值
-        const stateConfig = stateManager.getState().then(s => s.config).catch(() => null);
         const defaultTaskTimeout = 600000; // 10 分钟（毫秒）
         this.config = {
             maxConcurrent: 3,
             taskTimeout: defaultTaskTimeout,
             ...config
         };
-        // 异步获取配置并更新 taskTimeout
-        stateConfig.then(cfg => {
-            if (cfg?.taskTimeout) {
-                this.config.taskTimeout = cfg.taskTimeout;
-            }
-        });
+        this._configReady = this.loadConfigFromState(stateManager);
         this.scheduler = new scheduler_js_1.Scheduler(stateManager, {
             maxConcurrentTasks: this.config.maxConcurrent,
             taskTimeout: this.config.taskTimeout
@@ -64,12 +58,24 @@ class OrchestratorExecutor {
     getPhaseExecutor() {
         return this.phaseExecutor;
     }
+    async loadConfigFromState(stateManager) {
+        try {
+            const state = await stateManager.getState();
+            if (state.config?.taskTimeout) {
+                this.config.taskTimeout = state.config.taskTimeout;
+            }
+        }
+        catch {
+            // use default config
+        }
+    }
     /**
      * 执行一步 - 返回待执行的 Subagent 任务
      *
      * Skills 调用此方法获取任务，然后使用 Agent 工具执行
      */
     async step() {
+        await this._configReady;
         const state = await this.stateManager.getState();
         // 1. 检查是否需要审批
         const pendingApprovals = await this.checkApprovals(state);
@@ -163,14 +169,6 @@ class OrchestratorExecutor {
             return state.config.approvalPoints.includes(approvalPoint);
         });
     }
-    /**
-     * 检查是否所有任务完成
-     */
-    checkAllCompleted(tasks) {
-        if (tasks.length === 0)
-            return true;
-        return tasks.every(task => task.status === 'completed');
-    }
     /**
      * 获取统计信息
      */
@@ -327,6 +325,7 @@ class OrchestratorExecutor {
             }
             else if (currentPhase === 'accept') {
                 await this.scheduler.markTaskCompleted(taskId);
+                this.agentRunner.markTaskCompleted(taskId);
                 // Review 任务完成：自动解析报告并生成修复任务
                 if (task.assignedAgent === 'reviewer' && result.output) {
                     return await this.processReviewResult(taskId, result.output);
@@ -335,6 +334,7 @@ class OrchestratorExecutor {
         }
         else {
             this.clearTaskTimeout(taskId);
+            this.agentRunner.markTaskCompleted(taskId);
             await this.scheduler.markTaskFailed(taskId, result.error || 'Unknown error');
         }
         return {};
@@ -525,6 +525,7 @@ class OrchestratorExecutor {
             console.error(`⏰ 任务超时: ${taskId} (${timeoutSeconds}s)`);
             logger_js_1.logger.task.timeout(taskId, timeoutSeconds);
             this.taskTimers.delete(taskId);
+            this.agentRunner.markTaskCompleted(taskId);
             await this.scheduler.markTaskFailed(taskId, `Task timed out after ${timeoutSeconds}s`);
         }, this.config.taskTimeout);
         this.taskTimers.set(taskId, timer);

package/dist/orchestrator/phase-executor.js

@@ -874,13 +874,20 @@ ACCEPT_FAILED
     async processPhaseResult(task, phase, result) {
         const now = new Date().toISOString();
         if (result.success) {
+            // 计算阶段耗时
+            const phaseKey = phase;
+            const phaseData = task.phases?.[phaseKey];
+            const startedAt = phaseData?.startedAt;
+            const duration = startedAt
+                ? Math.round((new Date(now).getTime() - new Date(startedAt).getTime()) / 1000)
+                : 0;
             // 更新阶段状态
             const updates = {
                 phases: {
                     ...task.phases,
                     [phase]: {
                         status: 'completed',
-                        duration: 0,
+                        duration,
                         completedAt: now
                     }
                 }

package/dist/orchestrator/scheduler.js

@@ -262,14 +262,17 @@ class Scheduler {
         this.cycleCacheKey = hash;
         this.lastCycleCheck = now;
         // 标记阻塞任务
+        const blockedIds = new Set();
         for (const cycle of cycles) {
             for (const taskId of cycle) {
+                if (blockedIds.has(taskId))
+                    continue;
                 const task = tasks.find(t => t.id === taskId);
                 if (task && (task.status === 'pending' || task.status === 'retry_queue')) {
-                    await this.stateManager.updateTask(taskId, {
-                        status: 'blocked',
+                    await this.transitionTask(taskId, 'block', {
                         error: `循环依赖检测: ${cycle.join(' → ')}`
                     });
+                    blockedIds.add(taskId);
                 }
             }
         }

package/dist/orchestrator/state-machine.d.ts

@@ -3,16 +3,19 @@ import type { Task, TaskStatus } from '../types/index.js';
  * 任务状态转换规则
  *
  * pending → scheduled → in_progress → verify → accept → completed
- *                │            │           │        │
- *                │            ▼           ▼        ▼
- *                │        blocked      failed   failed
- *                │            │           │        │
- *                │            ▼           └────────┘
- *                │        waiting              │
- *                │            │                ▼
- *                └────────────┴──────────► retry_queue
+ *    │                       │           │        │
+ *    ├──────► blocked ◄──────┘           ▼        ▼
+ *    │            │                   failed ◄─ failed
+ *    │            ▼                      │
+ *    │        waiting                    ▼
+ *    │            │               retry_queue
+ *    │            │                   │  │
+ *    └────────────┴───────────────────┘  └──► blocked
+ *
+ * retry_queue → in_progress (直接重试)
+ * scheduled/blocked/waiting → failed
  */
-export type TransitionEvent = 'schedule' | 'start' | 'develop_done' | 'verify_done' | 'accept_done' | 'need_verify' | 'need_accept' | 'block' | 'unblock' | 'wait' | 'resume' | 'fail' | 'retry' | 'cancel';
+export type TransitionEvent = 'schedule' | 'start' | 'develop_done' | 'verify_done' | 'accept_done' | 'block' | 'wait' | 'resume' | 'fail' | 'retry' | 'cancel';
 export interface TransitionResult {
     success: boolean;
     fromStatus: TaskStatus;

package/dist/orchestrator/state-machine.js

@@ -9,6 +9,12 @@ const TRANSITIONS = [
     { from: 'scheduled', to: 'in_progress', event: 'start' },
     // pending → in_progress (跳过 scheduled，直接开始)
     { from: 'pending', to: 'in_progress', event: 'start' },
+    // retry_queue → in_progress (重试后直接开始)
+    { from: 'retry_queue', to: 'in_progress', event: 'start' },
+    // pending → blocked (循环依赖检测)
+    { from: 'pending', to: 'blocked', event: 'block' },
+    // retry_queue → blocked (循环依赖检测)
+    { from: 'retry_queue', to: 'blocked', event: 'block' },
     // in_progress → verify
     { from: 'in_progress', to: 'verify', event: 'develop_done' },
     // verify → accept
@@ -25,6 +31,9 @@ const TRANSITIONS = [
     { from: 'in_progress', to: 'failed', event: 'fail' },
     { from: 'verify', to: 'failed', event: 'fail' },
     { from: 'accept', to: 'failed', event: 'fail' },
+    { from: 'scheduled', to: 'failed', event: 'fail' },
+    { from: 'blocked', to: 'failed', event: 'fail' },
+    { from: 'waiting', to: 'failed', event: 'fail' },
     // failed → retry_queue
     { from: 'failed', to: 'retry_queue', event: 'retry' },
     // retry_queue → pending (安全上限 100，由 executor 层控制具体 maxRetries)
@@ -110,10 +119,7 @@ class StateMachine {
             'develop_done': '开发完成',
             'verify_done': '验证完成',
             'accept_done': '验收完成',
-            'need_verify': '需要验证',
-            'need_accept': '需要验收',
             'block': '阻塞任务',
-            'unblock': '解除阻塞',
             'wait': '等待外部',
             'resume': '恢复执行',
             'fail': '标记失败',

package/dist/orchestrator/task-planner.js

@@ -1368,7 +1368,7 @@ ${typeConfig.runCommand}
                 if (b.title.startsWith('系统集成:') && devTaskIds.length > 0) {
                     // 集成任务依赖当前阶段的所有开发任务
                     const currentDeps = b.dependencies;
-                    if (currentDeps.every(d => devTaskIds.includes(d) || !devTaskIds.includes(d))) {
+                    if (currentDeps.length === 0 || currentDeps.some(d => devTaskIds.includes(d))) {
                         integrationTaskId = b.taskId;
                     }
                 }

package/dist/storage/state-manager.js

@@ -292,19 +292,13 @@ class StateManager {
             // 从文件重新读取最新状态（不用缓存，避免 stale）
             const state = await this.store.readJson('state.json') ?? 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;
+            // 确保扩展统计字段已初始化
+            stats.scheduled ??= 0;
+            stats.blocked ??= 0;
+            stats.waiting ??= 0;
+            stats.verify ??= 0;
+            stats.accept ??= 0;
+            stats.retry_queue ??= 0;
             // Decrement old status count
             if (oldStatus === 'pending')
                 stats.pending--;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,18 +41,18 @@
     "url": "https://github.com/bigfish1913/openmatrix/issues"
   },
   "dependencies": {
-    "@types/node": "^22.0.0",
     "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3",
-    "typescript": "^5.3.3",
     "winston": "^3.19.0"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^8.58.1",
     "@typescript-eslint/parser": "^8.58.1",
     "@vitest/coverage-v8": "^1.6.1",
     "eslint": "^10.2.0",
+    "typescript": "^5.3.3",
     "vitest": "^1.6.0"
   },
   "engines": {

package/skills/deploy.md

@@ -91,6 +91,80 @@ cat requirements.txt pyproject.toml 2>/dev/null
 
 ---
 
+## Step 2.1: 检测并优化依赖源
+
+检测项目使用的包管理器和镜像源，如果是国外慢源则建议替换为国内镜像：
+
+```bash
+# npm/yarn/pnpm 源
+npm config get registry 2>/dev/null
+cat .npmrc 2>/dev/null
+cat .yarnrc 2>/dev/null
+cat .yarnrc.yml 2>/dev/null
+
+# pip 源
+cat pip.conf 2>/dev/null
+pip config get global.index-url 2>/dev/null
+
+# Docker 镜像源
+cat /etc/docker/daemon.json 2>/dev/null
+cat ~/.docker/daemon.json 2>/dev/null
+
+# Go 代理
+go env GOPROXY 2>/dev/null
+
+# Rust 源
+cat ~/.cargo/config.toml 2>/dev/null
+
+# Gradle/Maven 源
+cat build.gradle 2>/dev/null | grep -i "repositories" -A 5
+cat pom.xml 2>/dev/null | grep -i "mirror" -A 5
+```
+
+**AI 分析源速度，如果检测到国外源，建议替换：**
+
+| 包管理器 | 国外源 | 国内镜像 |
+|---------|--------|---------|
+| npm/yarn/pnpm | registry.npmjs.org | https://registry.npmmirror.com |
+| pip | pypi.org | https://pypi.tuna.tsinghua.edu.cn/simple |
+| Docker | docker.io | mirror.ccs.tencentyun.com |
+| Go | proxy.golang.org | https://goproxy.cn,direct |
+| Rust/Cargo | crates.io | https://rsproxy.cn/crates.io-index |
+| Gradle/Maven | repo.maven.apache.org | https://maven.aliyun.com/repository/public |
+
+**如果检测到慢源，输出建议并询问：**
+
+```
+AskUserQuestion:
+  header: "镜像源"
+  question: "检测到 npm 使用官方源（registry.npmjs.org），国内访问较慢。是否切换到国内镜像？"
+
+  options:
+  - label: "切换到淘宝镜像 (推荐)"
+    description: "npmmirror.com，国内速度快，同步延迟 < 10 分钟"
+  - label: "保持不变"
+    description: "当前源可用，不需要切换"
+  - label: "使用其他镜像"
+    description: "指定自定义镜像地址"
+```
+
+**用户确认后执行切换：**
+```bash
+# npm
+npm config set registry https://registry.npmmirror.com
+
+# pip
+pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
+
+# Go
+go env -w GOPROXY=https://goproxy.cn,direct
+
+# Dockerfile 中的 apt 源（如果有）
+# AI 读取 Dockerfile，将 archive.ubuntu.com 替换为 mirrors.aliyun.com
+```
+
+---
+
 ## Step 3: 检测系统环境
 
 ```bash
@@ -181,6 +255,40 @@ AskUserQuestion:
 
 ---
 
+## Step 6.1: 生成部署任务清单
+
+根据前面的分析和用户选择，将所有部署步骤写入 TodoWrite，逐条执行：
+
+**示例（Docker 本地部署 + 源优化 + 脚本生成）：**
+
+```typescript
+TodoWrite({
+  todos: [
+    { content: "切换 npm 源到淘宝镜像", activeForm: "正在切换 npm 镜像源", status: "pending" },
+    { content: "构建 Docker 镜像", activeForm: "正在构建 Docker 镜像", status: "pending" },
+    { content: "启动容器", activeForm: "正在启动容器", status: "pending" },
+    { content: "验证部署：容器状态", activeForm: "正在检查容器状态", status: "pending" },
+    { content: "验证部署：端口监听", activeForm: "正在检查端口", status: "pending" },
+    { content: "验证部署：HTTP 连通", activeForm: "正在验证 HTTP 连通性", status: "pending" },
+    { content: "生成 Taskfile.yml 一键脚本", activeForm: "正在生成一键脚本", status: "pending" },
+    { content: "保存部署配置", activeForm: "正在保存部署配置", status: "pending" }
+  ]
+})
+```
+
+**任务清单根据实际情况动态生成：**
+- 需要切换源 → 加入源切换任务
+- 需要生成 Dockerfile → 加入生成任务
+- 多服务 → 每个服务一条任务
+- 选择生成脚本 → 加入脚本生成任务
+
+**执行规则：**
+- 每次只执行一条，完成后立即标记 completed
+- 失败时停止，输出错误信息
+- 用户可以看到整体进度
+
+---
+
 ## Step 7: 执行部署
 
 根据用户选择，AI 执行对应命令：