openmatrix 0.1.0 → 0.1.1

package/README.md

@@ -2,23 +2,21 @@
 
 <div align="center">
 
-**唯一同时实现 TDD + 严格质量门禁 + 全自动执行的 AI 任务编排系统**
+**同时实现 TDD + 严格质量门禁 + 全自动执行的 AI 任务编排系统**
 
 *自动化 ≠ 牺牲质量 | 高质量 ≠ 手动操作*
 
-[![npm version](https://badge.fury.io/js/openmatrix.svg)](https://badge.fury.io/js/openmatrix)
+[![npm version](https://badge.fury.io/js/openmatrix.svg)](https://www.npmjs.com/package/openmatrix)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node](https://img.shields.io/badge/Node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-Compatible-blue.svg)](https://claude.ai/code)
 
-**[中文文档](#中文文档)** | **[English](#english)**
+**[中文](README.md)** | **[English](README_EN.md)**
 
 </div>
 
 ---
 
-# 中文文档
-
 ## 一句话介绍
 
 ```bash
@@ -28,212 +26,24 @@
 
 ---
 
-## 完整流程图
+## 执行流程概览
 
 ```
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│                           OpenMatrix 完整执行流程                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-
-用户输入: /om:start 实现用户登录功能
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 0: 交互式问答                                                              │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  Q0: 选择质量级别?     ◀─── 最重要，第一个问                                     │
-│  ├── 🚀 strict     →  TDD + 80%覆盖率 + 6道门禁 + AI验收                         │
-│  ├── ⚖️ balanced   →  60%覆盖率 + 4道门禁 + AI验收                               │
-│  └── ⚡ fast       →  无质量门禁                                                 │
-│                                                                                 │
-│  Q1: 任务目标?         (新功能/Bug修复/重构)                                     │
-│  Q2: 技术栈?           (TypeScript/Python/Go...)                               │
-│  Q3: 文档要求?         (完整/基础/最小/无)                                       │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 1: 任务规划 (Planner Agent)                                                │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  输入: 用户回答 + 任务描述                                                        │
-│  输出: 执行计划 + 子任务列表 + 依赖图                                             │
-│                                                                                 │
-│  📋 执行计划示例:                                                                │
-│  ├── TASK-001: 数据模型设计 (Planner, 15min)                                    │
-│  ├── TASK-002: API 接口实现 (Coder, 30min)                                      │
-│  ├── TASK-003: 单元测试 (Tester, 20min)                                         │
-│  └── TASK-004: 代码审查 (Reviewer, 10min)                                       │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 2: 任务执行 (根据质量级别)                                                  │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  ┌─────────────────────────────────────────────────────────────────────────┐   │
-│  │ strict 模式 (4阶段)                                                      │   │
-│  │                                                                          │   │
-│  │  ┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐           │   │
-│  │  │   TDD   │────▶│ Develop │────▶│  Verify │────▶│ Accept  │           │   │
-│  │  │ 🧪 RED  │     │ ✨ GREEN│     │ ✅ 6门禁│     │ 🎉 AI   │           │   │
-│  │  └─────────┘     └─────────┘     └─────────┘     └─────────┘           │   │
-│  │       │               │               │               │                 │   │
-│  │       ▼               ▼               ▼               ▼                 │   │
-│  │   Tester 先写      Coder 写代码    6道质量门禁    Reviewer              │   │
-│  │   测试(必须失败)   (测试必须通过)   (见下方)      最终验收                │   │
-│  │                                                                          │   │
-│  └─────────────────────────────────────────────────────────────────────────┘   │
-│                                                                                 │
-│  ┌─────────────────────────────────────────────────────────────────────────┐   │
-│  │ balanced 模式 (3阶段)                                                    │   │
-│  │                                                                          │   │
-│  │  ┌─────────┐     ┌─────────┐     ┌─────────┐                            │   │
-│  │  │ Develop │────▶│  Verify │────▶│ Accept  │                            │   │
-│  │  │ ✨ 编码 │     │ ✅ 4门禁│     │ 🎉 AI   │                            │   │
-│  │  └─────────┘     └─────────┘     └─────────┘                            │   │
-│  │                                                                          │   │
-│  └─────────────────────────────────────────────────────────────────────────┘   │
-│                                                                                 │
-│  ┌─────────────────────────────────────────────────────────────────────────┐   │
-│  │ fast 模式 (1阶段)                                                        │   │
-│  │                                                                          │   │
-│  │  ┌─────────┐     ┌─────────┐                                            │   │
-│  │  │ Develop │────▶│  Done   │                                            │   │
-│  │  │ ✨ 编码 │     │ 🏁 完成 │                                            │   │
-│  │  └─────────┘     └─────────┘                                            │   │
-│  │                                                                          │   │
-│  └─────────────────────────────────────────────────────────────────────────┘   │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 3: 质量门禁 (Verify 阶段)                                                  │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  ┌──────────────────────────────────────────────────────────────────────────┐  │
-│  │                        6 Quality Gates                                    │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 1: 编译检查                                                      │  │
-│  │  │   $ npm run build                                                      │  │
-│  │  └── → ✅ PASS (无编译错误) / ❌ FAIL (阻止继续)                           │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 2: 测试运行                                                      │  │
-│  │  │   $ npm test                                                           │  │
-│  │  └── → ✅ PASS (所有测试通过) / ❌ FAIL (阻止继续)                         │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 3: 覆盖率检查 (strict: 80%, balanced: 60%)                       │  │
-│  │  │   $ npm test -- --coverage                                             │  │
-│  │  └── → ✅ PASS (达标) / ⚠️ WARN (不达标但继续)                             │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 4: Lint 检查 (strict: 无error, balanced: 无严重error)            │  │
-│  │  │   $ npm run lint                                                       │  │
-│  │  └── → ✅ PASS / ❌ FAIL (strict模式阻止)                                  │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 5: 安全扫描                                                      │  │
-│  │  │   $ npm audit --audit-level=high                                       │  │
-│  │  └── → ✅ PASS (无高危漏洞) / ❌ FAIL (阻止继续)                           │  │
-│  │                                                                          │  │
-│  │  🚪 Gate 6: 验收标准                                                      │  │
-│  │  │   逐项检查用户定义的验收标准                                            │  │
-│  │  └── → ✅ PASS (全部满足) / ❌ FAIL (阻止继续)                             │  │
-│  │                                                                          │  │
-│  └──────────────────────────────────────────────────────────────────────────┘  │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 4: AI 验收 (Accept 阶段)                                                   │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  Reviewer Agent 执行:                                                           │
-│  ├── 📄 读取 verify-report.md                                                   │
-│  ├── ✅ 验证所有验收标准已满足                                                    │
-│  ├── 🔍 确认代码可以合并                                                         │
-│  ├── 📊 生成质量报告 (quality-report.json)                                       │
-│  └── 📝 生成验收报告 (accept-report.md)                                          │
-│                                                                                 │
-│  输出示例:                                                                       │
-│  ┌──────────────────────────────────────────────────────────────────────────┐  │
-│  │ ACCEPT_PASSED                                                             │  │
-│  │ Quality Score: A                                                          │  │
-│  │ ├── Tests:     ✅ 15/15 passed, 82% coverage                              │  │
-│  │ ├── Build:     ✅ Success                                                 │  │
-│  │ ├── Lint:      ✅ No errors (3 warnings)                                  │  │
-│  │ ├── Security:  ✅ No vulnerabilities                                      │  │
-│  │ └── Criteria:  ✅ 5/5 acceptance criteria met                             │  │
-│  └──────────────────────────────────────────────────────────────────────────┘  │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 5: Meeting 处理 (如有阻塞)                                                  │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  执行过程中遇到阻塞 → 创建 Meeting → 继续执行其他任务                              │
-│                                                                                 │
-│  执行日志:                                                                       │
-│  ├── TASK-001: ✅ 完成                                                          │
-│  ├── TASK-002: ⚠️ 阻塞 → 创建 Meeting-001 → 跳过 ↷                              │
-│  ├── TASK-003: ✅ 完成                                                          │
-│  ├── TASK-004: ⚠️ 阻塞 → 创建 Meeting-002 → 跳过 ↷                              │
-│  └── TASK-005: ✅ 完成                                                          │
-│                                                                                 │
-│  执行完成! 📋 有 2 个待处理 Meeting                                               │
-│                                                                                 │
-│  用户执行: /om:meeting                                                           │
-│  ├── [1] Meeting-001: 数据库连接失败 (TASK-002)                                  │
-│  │    ├── 💡 提供信息 → 重新执行 TASK-002 → ✅ 完成                              │
-│  │    ├── ⏭️ 跳过任务 → 标记为 skipped                                          │
-│  │    └── 🔄 重试 → 重新执行 TASK-002                                           │
-│  └── [2] Meeting-002: API设计决策 (TASK-004)                                     │
-│       ├── 💡 提供信息 → 重新执行 TASK-004 → ✅ 完成                              │
-│       ├── ⏭️ 跳过任务 → 标记为 skipped                                          │
-│       └── 🔄 重试 → 重新执行 TASK-004                                           │
-│                                                                                 │
-│  Meeting 处理完成后:                                                             │
-│  └── 重新执行被阻塞的任务 (TASK-002, TASK-004)                                    │
-│      └── 每个任务仍需经过完整的 Phase 流程 (Develop → Verify → Accept)            │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│  阶段 6: 最终报告                                                                │
-├─────────────────────────────────────────────────────────────────────────────────┤
-│                                                                                 │
-│  /om:report                                                                     │
-│                                                                                 │
-│  📊 执行报告:                                                                    │
-│  ├── 总任务: 5                                                                   │
-│  ├── 完成: 5 (含 2 个 Meeting 处理后完成)                                         │
-│  ├── 跳过: 0                                                                     │
-│  ├── 质量评分: A                                                                 │
-│  ├── 总耗时: 35 分钟 (含 Meeting 处理)                                            │
-│  └── Git 提交: 5 commits                                                        │
-│                                                                                 │
-│  📁 产出文件:                                                                    │
-│  ├── .openmatrix/state.json           # 全局状态                                │
-│  ├── .openmatrix/tasks/TASK-001/      # 任务详情                                │
-│  │   ├── task.json                    # 任务定义                                │
-│  │   └── artifacts/                   # 产出物                                  │
-│  │       ├── result.md                # 实现说明                                │
-│  │       ├── verify-report.md         # 验证报告                                │
-│  │       ├── quality-report.json      # 质量报告                                │
-│  │       └── accept-report.md         # 验收报告                                │
-│  └── .openmatrix/approvals/           # 审批记录 (含 Meeting)                   │
-│                                                                                 │
-└─────────────────────────────────────────────────────────────────────────────────┘
-
-                                    🎉 完成!
+用户输入 → 质量选择 → 任务规划 → 执行 → 质量门禁 → AI验收 → Meeting处理 → 完成
 ```
 
+| 阶段 | 说明 | 关键点 |
+|:----:|------|--------|
+| 0 | 交互问答 | **第一个问题选质量级别** |
+| 1 | 任务规划 | Planner Agent 生成计划 |
+| 2 | 任务执行 | strict/balanced/fast 三种模式 |
+| 3 | 质量门禁 | 6 道质量门禁验证 |
+| 4 | AI 验收 | Reviewer Agent 最终确认 |
+| 5 | Meeting | 阻塞不中断，最后处理并**重新执行** |
+| 6 | 最终报告 | 质量评分 + 产出文件 |
+
+📖 **详细流程图**: [docs/FLOW.md](docs/FLOW.md) (含 Mermaid 图表)
+
 ---
 
 ## 为什么选择 OpenMatrix？
@@ -257,14 +67,39 @@
 
 ### 安装
 
+**方式一: NPM 安装 (推荐)**
+
+```bash
+# 全局安装
+npm install -g openmatrix
+
+# Skills 会自动安装到 ~/.claude/commands/om/
+# 如果自动安装失败，手动执行:
+openmatrix install-skills
+```
+
+**方式二: 从源码安装**
+
 ```bash
 # 克隆并安装
 git clone https://github.com/bigfish1913/openmatrix.git
 cd openmatrix && npm install && npm run build && npm link
 
-# 复制 Skills
-mkdir -p ~/.claude/commands/om
-cp skills/*.md ~/.claude/commands/om/
+# 安装 Skills (如果 postinstall 未自动执行)
+openmatrix install-skills
+```
+
+### 验证安装
+
+```bash
+# 检查 CLI 是否可用
+openmatrix --version
+
+# 检查 Skills 是否安装成功
+openmatrix install-skills
+# 或直接查看
+ls ~/.claude/commands/om/
+# 应显示: start.md  auto.md  status.md  approve.md  meeting.md  resume.md  retry.md  report.md
 ```
 
 ### 第一次使用
@@ -290,9 +125,11 @@ cp skills/*.md ~/.claude/commands/om/
 
 | 级别 | TDD | 覆盖率 | Lint | 安全 | AI验收 | 适用场景 |
 |:----:|:---:|:------:|:----:|:----:|:------:|---------|
-| **strict** | ✅ | 80% | ✅ 严格 | ✅ | ✅ | 🏭 **生产代码** |
-| **balanced** | ❌ | 60% | ✅ | ✅ | ✅ | 📦 日常开发 |
-| **fast** | ❌ | 0% | ❌ | ❌ | ❌ | 🏃 快速原型 |
+| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ✅ | 🏭 **生产代码** |
+| **balanced** | ❌ | >60% | ✅ | ✅ | ✅ | 📦 日常开发 |
+| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | 🏃 快速原型 |
+
+> strict 可配置为 100%。默认 >80% 覆盖核心业务逻辑。
 
 ### 2️⃣ 六道质量门禁 (Verify 阶段)
 
@@ -302,7 +139,7 @@ cp skills/*.md ~/.claude/commands/om/
 ├─────────────────────────────────────────────────────────────┤
 │  🚪 Gate 1: 编译检查     npm run build     → 必须通过       │
 │  🚪 Gate 2: 测试运行     npm test         → 必须通过       │
-│  🚪 Gate 3: 覆盖率检查   >= 60%/80%       → 可配置         │
+│  🚪 Gate 3: 覆盖率检查   >20%/60%/80%    → 可配置         │
 │  🚪 Gate 4: Lint 检查    无 error         → 可配置         │
 │  🚪 Gate 5: 安全扫描     npm audit        → 无高危漏洞     │
 │  🚪 Gate 6: 验收标准     用户定义         → 必须全部满足   │
@@ -374,6 +211,7 @@ Accept 阶段由 Reviewer Agent 执行:
 | 命令 | 用途 |
 |------|------|
 | `/om:start` | 启动新任务 (第一个问题选质量级别) |
+| `/om:auto` | 🚀 **全自动执行** - 无阻塞、无确认、直接完成 |
 | `/om:status` | 查看状态 |
 | `/om:approve` | 审批决策 |
 | `/om:meeting` | 处理阻塞问题 |
@@ -381,6 +219,84 @@ Accept 阶段由 Reviewer Agent 执行:
 | `/om:retry` | 重试失败 |
 | `/om:report` | 生成报告 |
 
+### `/om:start` 执行流程 (含 Meeting 机制)
+
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│                            执行阶段                                       │
+├──────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  TASK-001 ✅ ──→ TASK-002 ⚠️阻塞 ──→ 创建Meeting ──→ 跳过 ↷             │
+│                      │                                                   │
+│                      ↓                                                   │
+│  TASK-003 ✅ ──→ TASK-004 ✅ ──→ TASK-005 ✅ ──→ 所有任务执行完成        │
+│                                                                          │
+└──────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌──────────────────────────────────────────────────────────────────────────┐
+│                         Meeting 自动检测                                  │
+├──────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│                    ┌─────────────────────┐                               │
+│                    │ 有 pending Meeting? │                               │
+│                    └──────────┬──────────┘                               │
+│                          ╱    \                                          │
+│                        否      是                                        │
+│                        │       │                                         │
+│                        ▼       ▼                                         │
+│                   ┌───────┐ ┌─────────────────────────────┐              │
+│                   │ 完成! │ │  📋 交互式处理 Meeting       │              │
+│                   └───────┘ │  ┌─────────────────────────┐│              │
+│                             │  │ [1] TASK-002: 数据库连接││              │
+│                             │  │     💡提供信息 / ⏭️跳过  ││              │
+│                             │  │ [2] TASK-005: API决策   ││              │
+│                             │  │     🤔选择方案          ││              │
+│                             │  └─────────────────────────┘│              │
+│                             └──────────────┬──────────────┘              │
+│                                            │                              │
+│                                            ▼                              │
+│                             ┌─────────────────────────────┐              │
+│                             │   用户提供信息/选择方案      │              │
+│                             │         ↓                   │              │
+│                             │   🔄 重新执行阻塞任务        │              │
+│                             │   TASK-002 ✅               │              │
+│                             └──────────────┬──────────────┘              │
+│                                            │                              │
+└────────────────────────────────────────────┼──────────────────────────────┘
+                                             │
+                                             ▼
+                                      ┌───────────┐
+                                      │  完成! 🎉  │
+                                      └───────────┘
+```
+
+### `/om:auto` 全自动模式
+
+**适用场景**: CI/CD、自动化脚本、无需人工干预的任务
+
+```bash
+/om:auto 实现用户登录功能              # 默认 strict 模式
+/om:auto --mode=balanced 添加API接口   # 指定 balanced 模式
+/om:auto --fast 创建CLI工具            # 快速原型模式
+```
+
+**特点**:
+- ❌ 无审批点确认
+- ❌ 无 Phase 间暂停
+- ❌ Meeting 自动跳过 (记录但不阻塞)
+- ✅ 默认 strict 质量级别
+- ✅ 适合 CI/CD 集成
+
+**与 `/om:start` 对比**:
+
+| 特性 | `/om:start` | `/om:auto` |
+|------|-------------|------------|
+| 质量级别 | 交互式选择 | 参数指定/默认 strict |
+| 审批确认 | 根据配置 | 全部跳过 |
+| Meeting | 交互式处理 | 自动跳过 |
+| 适用场景 | 日常开发 | CI/CD、自动化 |
+
 ---
 
 ## 质量报告
@@ -456,6 +372,8 @@ cd openmatrix && npm install && npm run build && npm test
 - [x] Meeting 机制
 - [x] 质量报告
 - [x] AI 验收
+- [x] `/om:auto` 全自动模式
+- [x] Meeting 自动处理
 - [ ] VSCode 扩展
 - [ ] Python/Go 支持
 - [ ] CI/CD 集成
@@ -469,44 +387,3 @@ cd openmatrix && npm install && npm run build && npm test
 MIT © 2024 | Made by [bigfish1913](https://github.com/bigfish1913)
 
 </div>
-
----
-
-# English
-
-## OpenMatrix: High Quality + Full Automation
-
-The **only** AI task orchestration with TDD + Quality Gates + 100% Automation.
-
-### Quick Start
-
-```bash
-# Install
-git clone https://github.com/bigfish1913/openmatrix.git
-cd openmatrix && npm install && npm run build && npm link
-mkdir -p ~/.claude/commands/om && cp skills/*.md ~/.claude/commands/om/
-
-# Use (first question asks quality level)
-/om:start Implement user login
-```
-
-### Quality Levels
-
-| Level | TDD | Coverage | Gates | Use Case |
-|-------|:---:|:--------:|:-----:|----------|
-| **strict** | ✅ | 80% | 6 | Production code |
-| **balanced** | ❌ | 60% | 4 | Daily development |
-| **fast** | ❌ | 0% | 1 | Prototypes |
-
-### Key Features
-
-- ✅ **Quality Level Selection** - First question you answer
-- ✅ **TDD Mode** - strict level includes test-first
-- ✅ **6 Quality Gates** - Build, Tests, Coverage, Lint, Security, Acceptance
-- ✅ **AI Acceptance** - Reviewer Agent validates final result
-- ✅ **Meeting Mechanism** - Blockers don't stop execution
-- ✅ **Quality Reports** - JSON format for every task
-
-### License
-
-MIT

package/dist/cli/commands/auto.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const autoCommand: Command;

package/dist/cli/commands/auto.js

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoCommand = void 0;
+// src/cli/commands/auto.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+const task_parser_js_1 = require("../../orchestrator/task-parser.js");
+const task_planner_js_1 = require("../../orchestrator/task-planner.js");
+const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
+const executor_js_1 = require("../../orchestrator/executor.js");
+const index_js_1 = require("../../types/index.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.autoCommand = new commander_1.Command('auto')
+    .description('全自动执行任务 - 无阻塞，bypass permissions')
+    .argument('[input]', '任务文件路径或描述')
+    .option('-q, --quality <level>', '质量级别 (strict|balanced|fast)', 'strict')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .action(async (input, options) => {
+    const basePath = process.cwd();
+    const omPath = path.join(basePath, '.openmatrix');
+    // 确保目录存在
+    await fs.mkdir(omPath, { recursive: true });
+    await fs.mkdir(path.join(omPath, 'tasks'), { recursive: true });
+    await fs.mkdir(path.join(omPath, 'approvals'), { recursive: true });
+    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: '已有任务在执行中',
+                hint: '使用 /om:status 查看状态，或 /om:resume 恢复执行'
+            }));
+        }
+        else {
+            console.log('⚠️  已有任务在执行中');
+            console.log('   使用 /om:status 查看状态');
+            console.log('   使用 /om:resume 恢复执行');
+        }
+        return;
+    }
+    // 验证质量级别
+    const qualityLevel = options.quality;
+    if (!['strict', 'balanced', 'fast'].includes(qualityLevel)) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'error',
+                message: `无效的质量级别: ${qualityLevel}`,
+                hint: '可选值: strict, balanced, fast'
+            }));
+        }
+        else {
+            console.log(`❌ 无效的质量级别: ${qualityLevel}`);
+            console.log('   可选值: strict, balanced, fast');
+        }
+        return;
+    }
+    // 获取任务内容
+    let taskContent = input;
+    if (!taskContent) {
+        // 尝试读取默认任务文件
+        const defaultPath = path.join(basePath, 'TASK.md');
+        try {
+            taskContent = await fs.readFile(defaultPath, 'utf-8');
+            if (!options.json) {
+                console.log(`📄 读取任务文件: ${defaultPath}`);
+            }
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: '请提供任务文件路径或描述'
+                }));
+            }
+            else {
+                console.log('❌ 请提供任务文件路径或描述');
+                console.log('   用法: openmatrix auto <task.md>');
+                console.log('   或创建 TASK.md 文件');
+            }
+            return;
+        }
+    }
+    else if (taskContent.endsWith('.md')) {
+        // 读取文件
+        try {
+            taskContent = await fs.readFile(taskContent, 'utf-8');
+            if (!options.json) {
+                console.log(`📄 读取任务文件: ${input}`);
+            }
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: `无法读取文件: ${input}`
+                }));
+            }
+            else {
+                console.log(`❌ 无法读取文件: ${input}`);
+            }
+            return;
+        }
+    }
+    // 解析任务
+    if (!options.json) {
+        console.log('\n🔍 解析任务...');
+    }
+    const parser = new task_parser_js_1.TaskParser();
+    const parsedTask = parser.parse(taskContent);
+    if (!options.json) {
+        console.log(`\n📋 任务: ${parsedTask.title}`);
+        console.log(`   目标: ${parsedTask.goals.join(', ')}`);
+    }
+    // 拆解任务
+    if (!options.json) {
+        console.log('\n🔧 拆解任务...');
+    }
+    const planner = new task_planner_js_1.TaskPlanner();
+    const subTasks = planner.breakdown(parsedTask, {});
+    // 创建任务到状态管理器
+    for (const subTask of subTasks) {
+        await stateManager.createTask({
+            title: subTask.title,
+            description: subTask.description,
+            priority: subTask.priority,
+            timeout: subTask.estimatedComplexity === 'high' ? 300000 :
+                subTask.estimatedComplexity === 'medium' ? 180000 : 120000,
+            dependencies: subTask.dependencies,
+            assignedAgent: subTask.assignedAgent
+        });
+    }
+    // 获取质量配置
+    const qualityConfig = index_js_1.QUALITY_PRESETS[qualityLevel];
+    // auto 模式: 空审批点数组 = bypass permissions
+    const approvalPoints = [];
+    // 更新状态
+    await stateManager.updateState({
+        status: 'running',
+        currentPhase: 'execution',
+        config: {
+            ...state.config,
+            approvalPoints: approvalPoints,
+            quality: qualityConfig
+        }
+    });
+    // 创建执行器并获取第一批任务
+    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.setAutoMode(true);
+    }
+    const result = await executor.step();
+    if (options.json) {
+        // JSON 输出供 Skill 解析
+        console.log(JSON.stringify({
+            status: result.status,
+            message: result.message,
+            mode: 'auto',
+            quality: qualityLevel,
+            bypassPermissions: true,
+            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
+            }))
+        }));
+    }
+    else {
+        console.log(`\n📋 生成 ${subTasks.length} 个子任务:\n`);
+        subTasks.forEach((task, i) => {
+            console.log(`  ${i + 1}. ${task.title} (${task.priority})`);
+        });
+        console.log(`\n🚀 全自动执行模式`);
+        console.log(`   质量级别: ${qualityLevel}`);
+        console.log(`   审批点: 无 (bypass permissions)`);
+        console.log('\n⏳ 开始执行...');
+        console.log('   使用 /om:status 查看进度');
+    }
+});

package/dist/cli/commands/install-skills.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+export declare const installSkillsCommand: Command;

package/dist/cli/commands/install-skills.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkillsCommand = void 0;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+exports.installSkillsCommand = new commander_1.Command('install-skills')
+    .description('Install OpenMatrix skills to ~/.claude/commands/om/')
+    .option('-f, --force', 'Force overwrite existing skills', false)
+    .action((options) => {
+    const skillsDir = path.join(__dirname, '..', '..', '..', 'skills');
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const commandsDir = path.join(claudeDir, 'commands', 'om');
+    console.log('📦 OpenMatrix Skills Installer\n');
+    // Check if skills directory exists
+    if (!fs.existsSync(skillsDir)) {
+        console.error('❌ Skills directory not found:', skillsDir);
+        console.error('   Make sure openmatrix is installed correctly.');
+        process.exit(1);
+    }
+    // Create commands directory
+    try {
+        if (!fs.existsSync(commandsDir)) {
+            fs.mkdirSync(commandsDir, { recursive: true });
+            console.log('📁 Created directory:', commandsDir);
+        }
+    }
+    catch (err) {
+        console.error('❌ Cannot create directory:', commandsDir);
+        console.error('   Error:', err.message);
+        process.exit(1);
+    }
+    // Get skill files
+    const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        console.error('❌ No skill files found in:', skillsDir);
+        process.exit(1);
+    }
+    console.log(`📋 Found ${files.length} skill files\n`);
+    let installed = 0;
+    let skipped = 0;
+    let failed = 0;
+    files.forEach(file => {
+        const src = path.join(skillsDir, file);
+        const dest = path.join(commandsDir, file);
+        try {
+            // Check if file exists and not forcing
+            if (fs.existsSync(dest) && !options.force) {
+                console.log(`  ⏭️  Skipped: ${file} (already exists)`);
+                skipped++;
+                return;
+            }
+            fs.copyFileSync(src, dest);
+            const skillName = path.basename(file, '.md');
+            console.log(`  ✅ Installed: /om:${skillName}`);
+            installed++;
+        }
+        catch (err) {
+            console.log(`  ❌ Failed: ${file} (${err.message})`);
+            failed++;
+        }
+    });
+    console.log('\n' + '─'.repeat(50));
+    console.log(`📊 Summary:`);
+    console.log(`   ✅ Installed: ${installed}`);
+    console.log(`   ⏭️  Skipped: ${skipped}`);
+    console.log(`   ❌ Failed: ${failed}`);
+    console.log(`\n📁 Location: ${commandsDir}`);
+    if (installed > 0) {
+        console.log('\n🎉 Skills installed successfully!');
+        console.log('   Try: /om:start <your task>');
+    }
+    if (failed > 0) {
+        process.exit(1);
+    }
+});

package/dist/cli/index.js

@@ -9,6 +9,8 @@ const resume_js_1 = require("./commands/resume.js");
 const retry_js_1 = require("./commands/retry.js");
 const report_js_1 = require("./commands/report.js");
 const meeting_js_1 = require("./commands/meeting.js");
+const auto_js_1 = require("./commands/auto.js");
+const install_skills_js_1 = require("./commands/install-skills.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -22,5 +24,7 @@ program.addCommand(resume_js_1.resumeCommand);
 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(install_skills_js_1.installSkillsCommand);
 // 默认帮助
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/cli/index.ts",
-    "test": "vitest"
+    "test": "vitest",
+    "postinstall": "node scripts/install-skills.js"
   },
   "keywords": [
     "claude",

package/skills/auto.md

@@ -0,0 +1,218 @@
+---
+name: om:auto
+description: 全自动执行任务 - 无阻塞，bypass permissions
+---
+
+<NO-OTHER-SKILLS>
+执行此技能时，不得调用 superpowers、gsd 或其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
+</NO-OTHER-SKILLS>
+
+<objective>
+全自动执行任务，跳过所有交互式问答和审批点，直接完成。支持 --quality 参数指定质量级别（默认 strict）。
+</objective>
+
+<process>
+1. **检查并初始化 .openmatrix 目录**
+   - 检查 `.openmatrix/` 目录是否存在
+   - 如果不存在，CLI 会自动创建
+
+2. **检查当前状态**
+   - 读取 `.openmatrix/state.json`
+   - 如果 `status === 'running'`，提示用户先完成或暂停
+
+3. **解析参数**
+   - `$ARGUMENTS` 可能包含:
+     - 任务描述或文件路径
+     - `--quality <level>` 质量级别 (strict|balanced|fast)，默认 strict
+     - `--bypass` 是否 bypass permissions (默认 true)
+
+   参数解析示例:
+   ```
+   /om:auto "实现用户登录" --quality fast
+   /om:auto task.md
+   /om:auto task.md --quality balanced
+   ```
+
+4. **解析任务输入**
+   - 如果提供文件路径 → 读取文件内容
+   - 如果是任务描述 → 直接使用
+   - 如果无参数 → **使用 AskUserQuestion 询问任务**
+
+5. **直接执行 (无交互式问答)**
+   - 跳过所有澄清问题
+   - 使用默认质量配置 (strict 除非指定)
+   - 设置 `approvalPoints: []` (bypass permissions)
+
+6. **调用 CLI**
+   ```bash
+   openmatrix auto --quality <level> --json
+   ```
+
+7. **执行循环 (全自动)**
+
+   ```
+   while (有待执行任务) {
+     1. 读取状态文件获取 SubagentTask
+     2. 调用 Agent 工具执行 Subagent
+     3. Subagent 完成后，更新状态文件:
+        ```bash
+        openmatrix complete <taskId> --success/--failed
+        ```
+     4. **Git 自动提交** (每个子任务完成后):
+        ```bash
+        git add -A
+        git commit -m "feat(task-id): 任务标题
+
+        - 修改内容1
+        - 修改内容2
+
+        任务ID: TASK-XXX
+        RunID: run-XXX"
+        ```
+     5. Phase 验收测试
+     6. **自动批准所有审批点**:
+        - plan/merge/deploy → 自动批准 ✓
+        - meeting → 记录并跳过，继续执行
+     7. 继续下一个任务
+   }
+   ```
+
+8. **执行完成 - 最终 Git 提交**
+
+   所有任务完成后，执行最终提交:
+   ```bash
+   git add -A
+   git commit -m "feat: 完成所有任务 (auto mode)
+
+   RunID: run-XXX
+   任务数: N
+   完成时间: YYYY-MM-DD HH:mm:ss"
+   ```
+
+9. **展示 Meeting (如果有)**
+   如果有 pending 的 Meeting，列出供用户后续处理:
+   ```
+   执行完成!
+   📋 有待处理的 Meeting (2个):
+     - APPR-001: 数据库连接失败 (TASK-B)
+     - APPR-002: API设计决策 (TASK-D)
+
+   请使用 /om:meeting 查看并处理
+   ```
+
+</process>
+
+<arguments>
+$ARGUMENTS
+</arguments>
+
+<examples>
+/om:auto                              # 交互式输入任务
+/om:auto "实现用户登录功能"             # 直接执行，strict 质量
+/om:auto task.md --quality fast       # 快速模式，无质量门禁
+/om:auto task.md --quality balanced   # 平衡模式
+/om:auto task.md --quality strict     # 严格模式 (默认)
+</examples>
+
+<notes>
+## 质量级别
+
+| 级别 | TDD | 覆盖率 | Lint | 安全扫描 | 适用场景 |
+|------|:---:|:------:|:----:|:--------:|---------|
+| **strict** | ✅ | >80% | ✅ 严格 | ✅ | 生产代码 (默认) |
+| **balanced** | ❌ | >60% | ✅ | ✅ | 日常开发 |
+| **fast** | ❌ | >20% | ❌ | ❌ | 快速原型 |
+
+## 与 /om:start 的区别
+
+| 特性 | /om:start | /om:auto |
+|------|-----------|----------|
+| 交互式问答 | ✅ 必须 | ❌ 跳过 |
+| 质量级别选择 | 交互选择 | 参数指定，默认 strict |
+| 执行模式选择 | 交互选择 | 固定 auto |
+| 审批点 | 可配置 | 无 (bypass) |
+| Meeting 处理 | 执行中交互 | 记录并跳过 |
+
+## CLI 命令
+
+```bash
+# 全自动执行，strict 质量
+openmatrix auto task.md
+
+# 全自动执行，fast 质量
+openmatrix auto task.md --quality fast
+
+# JSON 输出 (供 Skill 解析)
+openmatrix auto task.md --json
+```
+
+## 状态配置
+
+auto 模式下的状态配置:
+```json
+{
+  "status": "running",
+  "config": {
+    "approvalPoints": [],
+    "quality": {
+      "level": "strict",
+      "tdd": true,
+      "minCoverage": 80,
+      "strictLint": true,
+      "securityScan": true
+    }
+  }
+}
+```
+
+## 执行流程图
+
+```
+┌─────────────────┐
+│   /om:auto      │
+│   解析参数       │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  读取任务内容    │
+│  (文件或描述)    │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  CLI: auto      │
+│  --quality=X    │
+│  approvalPoints │
+│  = []           │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│   执行循环       │◀────────────┐
+│  (无阻塞)        │             │
+└────────┬────────┘             │
+         │                      │
+         ▼                      │
+   ┌───────────┐                │
+   │ Agent执行 │                │
+   └─────┬─────┘                │
+         │                      │
+         ▼                      │
+   ┌───────────┐                │
+   │ 自动批准  │                │
+   │ (无阻塞)  │                │
+   └─────┬─────┘                │
+         │                      │
+         ▼                      │
+   ┌───────────┐     否         │
+   │ 还有任务? │────────────────┘
+   └─────┬─────┘
+         │ 是
+         ▼
+┌─────────────────┐
+│  展示 Meeting   │
+│  (如果有)       │
+└─────────────────┘
+```
+</notes>

package/skills/start.md

@@ -12,11 +12,19 @@ description: 启动新的任务执行周期
 </objective>
 
 <process>
-1. **检查当前状态**
+1. **检查并初始化 .openmatrix 目录**
+   - 检查 `.openmatrix/` 目录是否存在
+   - 如果不存在，调用 CLI 初始化:
+     ```bash
+     openmatrix start --init-only
+     ```
+   - 这会创建 `.openmatrix/`、`.openmatrix/tasks/`、`.openmatrix/approvals/` 目录
+
+2. **检查当前状态**
    - 读取 `.openmatrix/state.json`
    - 如果 `status === 'running'`，提示用户先完成或暂停
 
-2. **检查 Git 仓库**
+3. **检查 Git 仓库**
    - 检查当前目录是否存在 `.git` 文件夹
    - 如果没有：
      - 询问用户是否初始化 Git 仓库 (使用 AskUserQuestion)
@@ -25,12 +33,12 @@ description: 启动新的任务执行周期
    - 检查是否有远程仓库配置:
      - 如果没有远程仓库，提示用户添加: `git remote add origin <url>`
 
-3. **解析任务输入**
+4. **解析任务输入**
    - 如果 `$ARGUMENTS` 提供文件路径 → 读取文件内容
    - 如果 `$ARGUMENTS` 是任务描述 → 直接使用
    - 如果无参数 → **使用 AskUserQuestion 询问用户要执行的任务**
 
-4. **⚠️ 交互式问答 (必须执行)**
+5. **⚠️ 交互式问答 (必须执行)**
 
    **重要**: 除非用户明确指定 `--skip-questions`，否则必须执行交互式问答。
 
@@ -156,7 +164,7 @@ description: 启动新的任务执行周期
   审批点: plan, merge
 ```
 
-6. **执行模式确认** (使用 AskUserQuestion)
+7. **执行模式确认** (使用 AskUserQuestion)
 
 ```typescript
 AskUserQuestion({
@@ -182,7 +190,7 @@ AskUserQuestion({
 })
 ```
 
-7. **开始执行** (⚠️ 严格模式)
+8. **开始执行** (⚠️ 严格模式)
 
 **重要**: 从此步骤开始，除非遇到 meeting 审批或失败，否则**不得暂停询问用户**。
 
@@ -201,8 +209,21 @@ c) **执行循环** (由 Skill 驱动):
 while (有待执行任务) {
   1. 读取状态文件获取 SubagentTask
   2. 调用 Agent 工具执行 Subagent
-  3. Subagent 完成后，更新状态文件
-  4. Git 提交 (如果配置了自动提交)
+  3. Subagent 完成后，更新状态文件:
+     ```bash
+     openmatrix complete <taskId> --success/--failed
+     ```
+  4. **Git 自动提交** (每个子任务完成后):
+     ```bash
+     git add -A
+     git commit -m "feat(task-id): 任务标题
+
+     - 修改内容1
+     - 修改内容2
+
+     任务ID: TASK-XXX
+     RunID: run-XXX"
+     ```
   5. Phase 验收测试 (verify phase)
   6. **检查是否需要审批**:
      - 如果配置了 auto 模式 (`approvalPoints` 为空):
@@ -219,15 +240,88 @@ while (有待执行任务) {
 ├── 任务C 完成 ✓
 └── 任务D 阻塞 → 创建Meeting → **跳过任务，继续执行** ↷
 
-执行完成!
-📋 有待处理的 Meeting (2个):
-  - APPR-001: 数据库连接失败 (TASK-B)
-  - APPR-002: API设计决策 (TASK-D)
+所有任务执行完成!
+```
+
+d) **执行完成后自动处理 Meeting**:
+
+```bash
+# 检查是否有 pending 的 Meeting
+openmatrix meeting --list --pending
+```
+
+**如果有 pending 的 Meeting，立即进入交互式处理**:
+
+```
+📋 检测到待处理的 Meeting (2个)
+
+┌─────────────────────────────────────────┐
+│ [1] 🔴 TASK-001 - 数据库连接失败          │
+│     阻塞原因: 无法连接到远程数据库         │
+│                                         │
+│ [2] 🤔 TASK-003 - API设计决策             │
+│     问题: 选择 REST 还是 GraphQL         │
+└─────────────────────────────────────────┘
+```
+
+**使用 AskUserQuestion 逐个处理**:
+
+```typescript
+// 1. 先选择要处理的 Meeting
+AskUserQuestion({
+  questions: [{
+    question: "请选择要处理的 Meeting:",
+    header: "Meeting",
+    options: [
+      { label: "[1] TASK-001 - 数据库连接失败", description: "阻塞 - 需要信息" },
+      { label: "[2] TASK-003 - API设计决策", description: "决策 - 技术选型" },
+      { label: "全部跳过", description: "标记所有 Meeting 为跳过" }
+    ],
+    multiSelect: false
+  }]
+})
+
+// 2. 根据类型展示处理选项
+// 阻塞型:
+AskUserQuestion({
+  questions: [{
+    question: "如何处理此阻塞?",
+    header: "处理方式",
+    options: [
+      { label: "💡 提供信息", description: "提供解决问题所需的信息后重试" },
+      { label: "⏭️ 跳过任务", description: "标记为可选，继续执行" },
+      { label: "🔄 重试", description: "直接重试此任务" }
+    ],
+    multiSelect: false
+  }]
+})
+
+// 决策型:
+AskUserQuestion({
+  questions: [{
+    question: "请做出决策:",
+    header: "决策",
+    options: [
+      { label: "方案 A", description: "方案A描述" },
+      { label: "方案 B", description: "方案B描述" }
+    ],
+    multiSelect: false
+  }]
+})
+```
 
-请使用 /om:meeting 查看并处理
+**处理完成后，如果用户提供了信息或选择重试，重新执行阻塞任务**:
+```bash
+openmatrix meeting APPR-001 --action provide-info --info "..."
+# 或
+openmatrix meeting APPR-001 --action retry
+
+# 然后重新执行阻塞的任务
+openmatrix resume TASK-001
 ```
 
-Meeting 保持 `pending` 状态，用户最后使用 `/om:meeting` 以交互式方式处理
+**⚠️ 重要**: Meeting 处理是执行流程的一部分，必须在任务结束前完成。不要让用户手动调用 /om:meeting。
+
   7. 继续下一个任务
 }
 ```
@@ -263,11 +357,16 @@ Agent({
 - 只有遇到 **meeting** 类型的审批时才暂停
 - 其他情况下，让 Agent 完整执行任务并在完成后自动返回结果
 
-8. **状态更新**
+9. **执行完成 - 最终 Git 提交**
 
-每个 Subagent 完成后，更新任务状态:
+所有任务完成后，执行最终提交:
 ```bash
-openmatrix complete <taskId> --success/--failed
+git add -A
+git commit -m "feat: 完成所有任务
+
+RunID: run-XXX
+任务数: N
+完成时间: YYYY-MM-DD HH:mm:ss"
 ```
 
 </process>
@@ -287,9 +386,11 @@ $ARGUMENTS
 
 | 级别 | TDD | 覆盖率 | Lint | 安全扫描 | AI验收 | 适用场景 |
 |------|:---:|:------:|:----:|:--------:|:------:|---------|
-| **strict** | ✅ | 80% | ✅ 严格 | ✅ | ✅ | 生产代码、核心功能 |
-| **balanced** | ❌ | 60% | ✅ | ✅ | ✅ | 日常开发 (默认) |
-| **fast** | ❌ | 0% | ❌ | ❌ | ❌ | 快速原型、POC |
+| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ✅ | 生产代码、核心功能 |
+| **balanced** | ❌ | >60% | ✅ | ✅ | ✅ | 日常开发 (默认) |
+| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | 快速原型、POC |
+
+> strict 可配置为 100%。80% 覆盖核心业务逻辑，100% 成本高收益低。
 
 ### strict 模式 (推荐生产代码)
 ```
@@ -367,7 +468,38 @@ $ARGUMENTS
 ┌─────────────────┐
 │    开始执行     │
 │  (应用质量配置)  │
-└─────────────────┘
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  所有任务完成?   │
+└────────┬────────┘
+         │
+    ┌────┴────┐
+    │         │
+   否        是
+    │         │
+    ▼         ▼
+┌───────┐ ┌─────────────────┐
+│继续执行│ │有 pending       │
+└───────┘ │Meeting?         │
+          └────────┬────────┘
+                   │
+              ┌────┴────┐
+              │         │
+             否        是
+              │         │
+              ▼         ▼
+          ┌───────┐ ┌─────────────┐
+          │  完成  │ │ 交互式处理  │
+          └───────┘ │ Meeting     │
+                    └──────┬──────┘
+                           │
+                           ▼
+                    ┌─────────────┐
+                    │ 重新执行    │
+                    │ 阻塞任务    │
+                    └─────────────┘
 ```
 
 ## 执行模式对比