openmatrix 0.1.20 → 0.1.21

package/README.md

@@ -251,6 +251,7 @@ Accept 阶段由 Reviewer Agent 执行:
 | 命令 | 用途 |
 |------|------|
 | `/om` | **默认入口** - 直接输入任务描述即可启动 |
+| `/om:brainstorm` | 🧠 **头脑风暴** - 先探索需求和设计，再执行任务 |
 | `/om:start` | 启动新任务 (第一个问题选质量级别) |
 | `/om:auto` | 🚀 **全自动执行** - 无阻塞、无确认、直接完成 |
 | `/check` | 🔍 **项目检查** - 自动检测可改进点并提供升级建议 |
@@ -461,6 +462,7 @@ cd openmatrix && npm install && npm run build && npm test
 - [x] 质量报告
 - [x] AI 验收
 - [x] `/om:auto` 全自动模式
+- [x] `/om:brainstorm` 头脑风暴模式
 - [x] 多语言支持 (Python/Go/Java/TypeScript 等)
 - [x] E2E 测试支持 (Web/Mobile/GUI)
 - [ ] VSCode 扩展

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

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

package/dist/cli/commands/brainstorm.js

@@ -0,0 +1,326 @@
+"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.brainstormCommand = void 0;
+// src/cli/commands/brainstorm.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+const gitignore_js_1 = require("../../utils/gitignore.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.brainstormCommand = new commander_1.Command('brainstorm')
+    .description('头脑风暴 - 探索需求和设计后再执行任务')
+    .argument('[input]', '任务文件路径或描述')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .option('--complete', '标记头脑风暴完成，准备执行 start')
+    .option('--results <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 });
+    await fs.mkdir(path.join(omPath, 'brainstorm'), { recursive: true });
+    // 确保 .openmatrix 被 git 忽略
+    await (0, gitignore_js_1.ensureOpenmatrixGitignore)(basePath);
+    const stateManager = new state_manager_js_1.StateManager(omPath);
+    await stateManager.initialize();
+    const brainstormPath = path.join(omPath, 'brainstorm', 'session.json');
+    // --complete 模式：头脑风暴完成，输出 start 所需信息
+    if (options.complete) {
+        try {
+            const sessionData = await fs.readFile(brainstormPath, 'utf-8');
+            const session = JSON.parse(sessionData);
+            // 更新状态
+            session.status = 'ready_to_start';
+            // 如果传入了结果，合并
+            if (options.results) {
+                try {
+                    const results = JSON.parse(options.results);
+                    session.answers = { ...session.answers, ...results.answers };
+                    session.insights = [...session.insights, ...(results.insights || [])];
+                    session.designNotes = [...session.designNotes, ...(results.designNotes || [])];
+                }
+                catch {
+                    // 忽略解析错误
+                }
+            }
+            await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'ready_to_start',
+                    message: '头脑风暴完成，准备执行任务',
+                    taskInput: session.taskInput,
+                    taskTitle: session.taskTitle,
+                    answers: session.answers,
+                    insights: session.insights,
+                    designNotes: session.designNotes,
+                    hint: '使用 /om:start 开始执行任务'
+                }));
+            }
+            else {
+                console.log('✅ 头脑风暴完成!');
+                console.log(`   任务: ${session.taskTitle}`);
+                console.log('\n📋 收集的洞察:');
+                session.insights.forEach((insight, i) => {
+                    console.log(`   ${i + 1}. ${insight}`);
+                });
+                console.log('\n📝 设计要点:');
+                session.designNotes.forEach((note, i) => {
+                    console.log(`   ${i + 1}. ${note}`);
+                });
+                console.log('\n🚀 使用 /om:start 开始执行任务');
+            }
+            return;
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: '没有进行中的头脑风暴会话'
+                }));
+            }
+            else {
+                console.log('❌ 没有进行中的头脑风暴会话');
+                console.log('   使用 openmatrix brainstorm <task> 开始新的头脑风暴');
+            }
+            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 brainstorm <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;
+        }
+    }
+    // 从任务内容提取标题
+    const lines = taskContent.split('\n');
+    let taskTitle = '未命名任务';
+    for (const line of lines) {
+        const match = line.match(/^#\s+(.+)$/);
+        if (match) {
+            taskTitle = match[1].trim();
+            break;
+        }
+    }
+    // 生成头脑风暴问题
+    const questions = generateBrainstormQuestions(taskContent, taskTitle);
+    // 创建会话
+    const session = {
+        status: 'brainstorming',
+        taskInput: taskContent,
+        taskTitle,
+        questions,
+        answers: {},
+        insights: [],
+        designNotes: []
+    };
+    await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
+    if (options.json) {
+        // JSON 输出供 Skill 解析
+        console.log(JSON.stringify({
+            status: 'brainstorming',
+            message: '开始头脑风暴',
+            taskTitle,
+            questions: questions.map(q => ({
+                id: q.id,
+                question: q.question,
+                header: q.header,
+                options: q.options,
+                multiSelect: q.multiSelect
+            })),
+            hint: '请逐一回答问题，完成后再调用 --complete'
+        }));
+    }
+    else {
+        console.log('\n🧠 开始头脑风暴...\n');
+        console.log(`📋 任务: ${taskTitle}\n`);
+        console.log('需要探索以下问题:');
+        questions.forEach((q, i) => {
+            console.log(`  ${i + 1}. ${q.question}`);
+        });
+        console.log('\n💡 使用 /om:brainstorm 技能进行交互式问答');
+    }
+});
+/**
+ * 根据任务内容生成头脑风暴问题
+ */
+function generateBrainstormQuestions(taskContent, taskTitle) {
+    const questions = [];
+    const content = taskContent.toLowerCase();
+    // 问题 1: 核心目标
+    questions.push({
+        id: 'core_objective',
+        question: '这个任务的核心目标是什么？想要解决什么问题？',
+        header: '核心目标',
+        options: [
+            { label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
+            { label: '修复问题', description: '修复 Bug 或解决已知问题' },
+            { label: '重构优化', description: '改进代码结构、性能或可维护性' },
+            { label: '技术探索', description: '探索新技术方案，验证可行性' }
+        ],
+        multiSelect: false,
+        why: '明确核心目标有助于选择正确的实现策略和质量标准'
+    });
+    // 问题 2: 用户价值
+    questions.push({
+        id: 'user_value',
+        question: '这个任务为用户带来什么价值？最终用户是谁？',
+        header: '用户价值',
+        options: [
+            { label: '开发者', description: '主要用户是开发者，需要清晰的 API 和文档' },
+            { label: '终端用户', description: '主要用户是终端用户，需要良好的用户体验' },
+            { label: '运维人员', description: '主要用户是运维，需要稳定性和可观测性' },
+            { label: '内部团队', description: '主要用户是内部团队，需要高效协作支持' }
+        ],
+        multiSelect: false,
+        why: '了解目标用户有助于设计合适的接口和交互方式'
+    });
+    // 问题 3: 实现复杂度 - 如果任务内容包含复杂关键词
+    if (content.includes('架构') || content.includes('系统') || content.includes('集成') || content.includes('多个')) {
+        questions.push({
+            id: 'complexity',
+            question: '这个任务的实现复杂度如何？需要哪些关键组件？',
+            header: '复杂度',
+            options: [
+                { label: '简单', description: '单一功能，少量代码修改' },
+                { label: '中等', description: '需要多个组件协作，有依赖关系' },
+                { label: '复杂', description: '涉及架构调整，需要仔细规划' },
+                { label: '非常复杂', description: '大型重构或新系统，需要分阶段实施' }
+            ],
+            multiSelect: false,
+            why: '复杂度评估有助于决定是否需要分阶段实施和额外的设计审查'
+        });
+    }
+    // 问题 4: 技术约束 - 如果涉及技术选型
+    if (content.includes('技术') || content.includes('框架') || content.includes('库')) {
+        questions.push({
+            id: 'tech_constraints',
+            question: '有哪些技术约束或偏好？需要使用/避免什么技术？',
+            header: '技术约束',
+            options: [
+                { label: '使用现有技术栈', description: '复用项目已有的技术选择' },
+                { label: '引入新技术', description: '需要引入新的库或框架' },
+                { label: '保持技术中立', description: '不引入新依赖，使用原生方案' },
+                { label: '需要技术调研', description: '技术选型不确定，需要先调研' }
+            ],
+            multiSelect: false,
+            why: '技术约束影响实现方案和后续维护成本'
+        });
+    }
+    // 问题 5: 风险评估
+    questions.push({
+        id: 'risks',
+        question: '这个任务可能面临哪些风险或挑战？',
+        header: '风险',
+        options: [
+            { label: '技术风险', description: '技术实现存在不确定性' },
+            { label: '时间风险', description: '需要在短时间内完成' },
+            { label: '兼容性风险', description: '可能影响现有功能' },
+            { label: '无明显风险', description: '任务清晰，风险可控' }
+        ],
+        multiSelect: true,
+        why: '识别风险有助于提前规划应对策略'
+    });
+    // 问题 6: 验收标准
+    questions.push({
+        id: 'acceptance',
+        question: '如何判断任务完成？有哪些验收标准？',
+        header: '验收标准',
+        options: [
+            { label: '功能完整', description: '所有功能按预期工作' },
+            { label: '测试覆盖', description: '有足够的测试覆盖' },
+            { label: '性能达标', description: '满足性能要求' },
+            { label: '文档完善', description: '有完整的使用文档' }
+        ],
+        multiSelect: true,
+        why: '明确的验收标准有助于判断任务完成度'
+    });
+    // 问题 7: 实现优先级
+    questions.push({
+        id: 'priority',
+        question: '这个任务的优先级如何？是否需要 MVP 版本？',
+        header: '优先级',
+        options: [
+            { label: '高优先级', description: '需要尽快完成，影响其他工作' },
+            { label: '中优先级', description: '计划内任务，按正常节奏推进' },
+            { label: '低优先级', description: '可延后处理，有更重要的任务' },
+            { label: '需要 MVP', description: '先实现最小可用版本，再迭代' }
+        ],
+        multiSelect: false,
+        why: '优先级决定资源分配和实施策略'
+    });
+    return questions;
+}

package/dist/cli/index.js

@@ -14,6 +14,7 @@ const install_skills_js_1 = require("./commands/install-skills.js");
 const check_js_1 = require("./commands/check.js");
 const check_gitignore_js_1 = require("./commands/check-gitignore.js");
 const analyze_js_1 = require("./commands/analyze.js");
+const brainstorm_js_1 = require("./commands/brainstorm.js");
 const program = new commander_1.Command();
 program
     .name('openmatrix')
@@ -32,5 +33,6 @@ program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
 program.addCommand(analyze_js_1.analyzeCommand);
+program.addCommand(brainstorm_js_1.brainstormCommand);
 // 默认帮助
 program.parse();

package/package.json

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

package/skills/brainstorm.md

@@ -0,0 +1,238 @@
+---
+name: om:brainstorm
+description: 头脑风暴 - 探索需求和设计后再执行任务
+---
+
+<NO-OTHER-SKILLS>
+执行此技能时，不得调用其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
+</NO-OTHER-SKILLS>
+
+<objective>
+在进行任务执行前，先进行头脑风暴，深入探索需求、设计和技术方案，确保理解完整后再开始执行。
+</objective>
+
+<process>
+1. **初始化头脑风暴会话**
+
+   调用 CLI 创建头脑风暴会话:
+   ```bash
+   openmatrix brainstorm --json
+   ```
+
+   这会返回:
+   ```json
+   {
+     "status": "brainstorming",
+     "message": "开始头脑风暴",
+     "taskTitle": "任务标题",
+     "questions": [
+       {
+         "id": "core_objective",
+         "question": "这个任务的核心目标是什么？",
+         "header": "核心目标",
+         "options": [...],
+         "multiSelect": false
+       }
+     ],
+     "hint": "请逐一回答问题，完成后再调用 --complete"
+   }
+   ```
+
+2. **交互式问答**
+
+   对每个问题使用 `AskUserQuestion` 进行提问:
+
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: questions[0].question,
+       header: questions[0].header,
+       options: questions[0].options,
+       multiSelect: questions[0].multiSelect
+     }]
+   })
+   ```
+
+   **收集回答并记录洞察**:
+   - 每个回答后，思考其含义
+   - 记录可能的设计决策
+   - 识别潜在风险
+
+3. **深入追问** (可选)
+
+   如果用户选择了"其他"或回答不够清晰，进行追问:
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: "请详细描述:",
+       header: "详情",
+       options: []
+     }]
+   })
+   ```
+
+4. **总结头脑风暴结果**
+
+   所有问题回答完成后，总结:
+   - 核心目标
+   - 用户价值
+   - 技术方案要点
+   - 风险和应对
+   - 验收标准
+
+   展示总结:
+   ```
+   🧠 头脑风暴总结
+
+   📋 任务: 实现登录功能
+
+   🎯 核心目标
+      - 实现用户登录功能，支持邮箱和密码
+
+   👥 用户价值
+      - 终端用户可以安全登录系统
+
+   🔧 技术方案
+      - 使用 JWT 进行身份验证
+      - 密码使用 bcrypt 加密
+
+   ⚠️ 风险评估
+      - 安全风险: 需要防止暴力破解
+
+   ✅ 验收标准
+      - 功能完整
+      - 测试覆盖
+   ```
+
+5. **确认并开始执行**
+
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: "头脑风暴完成，是否开始执行任务？",
+       header: "下一步",
+       options: [
+         { label: "✅ 开始执行 (推荐)", description: "使用收集的信息开始执行任务" },
+         { label: "🔄 继续探索", description: "还有问题需要进一步讨论" },
+         { label: "📋 仅生成计划", description: "生成详细计划但不执行" }
+       ],
+       multiSelect: false
+     }]
+   })
+   ```
+
+6. **自动执行 start**
+
+   如果用户选择"开始执行":
+   - 调用 CLI 标记头脑风暴完成:
+     ```bash
+     openmatrix brainstorm --complete --json
+     ```
+   - 自动调用 `/om:start` 开始执行任务
+   - 将头脑风暴收集的洞察传递给 start
+
+</process>
+
+<arguments>
+$ARGUMENTS
+</arguments>
+
+<examples>
+/om:brainstorm                      # 交互式头脑风暴
+/om:brainstorm docs/task.md         # 基于任务文件头脑风暴
+/om:brainstorm "实现用户登录功能"    # 基于描述头脑风暴
+</examples>
+
+<notes>
+## 头脑风暴流程图
+
+```
+┌─────────────────┐
+│   开始头脑风暴   │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  CLI 初始化会话  │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│ 获取问题列表     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│ 交互式问答       │◀─────┐
+│ (AskUserQuestion)│      │
+└────────┬────────┘       │
+         │                │
+    ┌────┴────┐           │
+    │         │           │
+  有下一题   无下一题      │
+    │         │           │
+    └────────┤           │
+             │           │
+             ▼           │
+┌─────────────────┐      │
+│ 总结头脑风暴结果 │      │
+└────────┬────────┘      │
+         │               │
+         ▼               │
+┌─────────────────┐      │
+│ 用户确认         │      │
+└────────┬────────┘      │
+         │               │
+    ┌────┴────┐          │
+    │         │          │
+  开始执行   继续探索 ────┘
+    │
+    ▼
+┌─────────────────┐
+│ 自动执行 start   │
+└─────────────────┘
+```
+
+## 问题类型
+
+| 问题 ID | 目的 | 为什么重要 |
+|---------|------|-----------|
+| core_objective | 明确核心目标 | 选择正确的实现策略 |
+| user_value | 了解用户价值 | 设计合适的接口 |
+| complexity | 评估复杂度 | 决定实施策略 |
+| tech_constraints | 技术约束 | 影响方案选择 |
+| risks | 风险评估 | 提前规划应对 |
+| acceptance | 验收标准 | 判断完成度 |
+| priority | 优先级 | 资源分配 |
+
+## 与 start 的集成
+
+头脑风暴完成后，收集的信息会传递给 start:
+
+```json
+{
+  "answers": {
+    "core_objective": "实现新功能",
+    "user_value": "终端用户",
+    "complexity": "中等",
+    "risks": ["技术风险", "兼容性风险"],
+    "acceptance": ["功能完整", "测试覆盖"],
+    "priority": "中优先级"
+  },
+  "insights": [
+    "需要考虑安全性",
+    "应该支持多种登录方式"
+  ],
+  "designNotes": [
+    "使用 JWT 认证",
+    "密码需要加密存储"
+  ]
+}
+```
+
+这些信息会影响:
+- 任务拆解策略
+- 质量级别选择
+- 技术栈确认
+- 风险应对措施
+</notes>

package/skills/om.md

@@ -75,6 +75,7 @@ OpenMatrix 的默认入口 - 自动启动任务编排。
 
    用法:
      /om <任务描述>        直接启动任务
+     /om:brainstorm <任务> 先头脑风暴，再执行
      /om:start <任务>      交互式启动 (可选质量级别)
      /om:auto <任务>       全自动执行
 
@@ -89,9 +90,10 @@ OpenMatrix 的默认入口 - 自动启动任务编排。
      ⚡ fast     - 无质量门禁 (快速原型)
 
    其他命令:
-     /om:status  - 查看状态
-     /om:meeting - 处理阻塞
-     /om:report  - 生成报告
+     /om:brainstorm - 头脑风暴后再执行
+     /om:status     - 查看状态
+     /om:meeting    - 处理阻塞
+     /om:report     - 生成报告
    ```
 
 </process>

package/skills/openmatrix.md

@@ -17,26 +17,26 @@ This skill MUST be invoked when the user describes ANY work to be done.
 - Answering questions (no code changes needed)
 - Information retrieval (reading files, explaining code)
 
-Everything else → `/om:start` first.
+Everything else → smart selection between `/om:brainstorm` and `/om:start`.
 </EXTREMELY-IMPORTANT>
 
 <objective>
-Automatically detect when user wants to accomplish a development task and invoke /om:start without requiring explicit command.
+Automatically detect when user wants to accomplish a development task and intelligently choose between brainstorm (for complex tasks) or start (for simple tasks).
 </objective>
 
 <trigger-conditions>
 ## AUTO-INVOKE RULES (Mandatory)
 
-**Invoke `/om:start` IMMEDIATELY when user input contains ANY of these patterns:**
+**Invoke IMMEDIATELY when user input contains ANY of these patterns:**
 
 ### Action Verbs (触发词)
 | Chinese | English | Action |
 |---------|---------|--------|
-| 实现/开发/做/写 | implement/build/create/make/write | → `/om:start` |
-| 添加/增加/加 | add/append | → `/om:start` |
-| 修复/解决/改 | fix/resolve/repair | → `/om:start` |
-| 重构/优化/改进 | refactor/optimize/improve | → `/om:start` |
-| 更新/修改/改 | update/modify/change | → `/om:start` |
+| 实现/开发/做/写 | implement/build/create/make/write | → Smart Select |
+| 添加/增加/加 | add/append | → Smart Select |
+| 修复/解决/改 | fix/resolve/repair | → Smart Select |
+| 重构/优化/改进 | refactor/optimize/improve | → Smart Select |
+| 更新/修改/改 | update/modify/change | → Smart Select |
 
 ### Context Patterns (触发场景)
 - **Feature requests**: "用户登录" / "支付功能" / "API接口"
@@ -49,10 +49,63 @@ Automatically detect when user wants to accomplish a development task and invoke
 ```
 用户输入 → 能在3秒内判断是"要做事情"吗?
   ↓ Yes                           ↓ No
-/om:start                      直接回答
+Smart Select                    直接回答
 ```
 </trigger-conditions>
 
+<smart-selection>
+## 智能选择：Brainstorm vs Start
+
+**根据任务复杂度自动选择执行路径：**
+
+### 🧠 复杂任务 → `/om:brainstorm`
+**触发条件 (满足任一):**
+- 新功能开发: "实现用户登录" / "添加支付功能" / "开发 API"
+- 多模块改动: "重构用户系统" / "优化整体性能"
+- 架构相关: "搭建框架" / "从零开始" / "设计架构"
+- 不确定因素: 需要技术选型、涉及多种方案选择
+- 关键词: "系统" / "架构" / "模块" / "集成" / "完整" / "从零"
+
+### 🚀 简单任务 → `/om:start`
+**触发条件 (满足任一):**
+- Bug 修复: "修复登录bug" / "解决样式问题" / "改个报错"
+- 小改动: "修改文案" / "改变量名" / "调整配置"
+- 单一功能: "添加一个按钮" / "写个工具函数"
+- 明确需求: 需求清晰，无需额外探索
+- 关键词: "修复" / "解决" / "改" / "调整" / "小" / "简单"
+
+### 选择流程
+```
+用户输入任务描述
+       │
+       ▼
+┌─────────────────────┐
+│ 分析任务复杂度        │
+└──────────┬──────────┘
+           │
+     ┌─────┴─────┐
+     │           │
+  复杂任务     简单任务
+     │           │
+     ▼           ▼
+/om:brainstorm  /om:start
+```
+
+### 判断示例
+| 用户输入 | 复杂度 | 执行路径 |
+|---------|--------|---------|
+| "实现用户登录功能" | 复杂 | `/om:brainstorm` |
+| "做一个完整的支付系统" | 复杂 | `/om:brainstorm` |
+| "从零搭建后台管理" | 复杂 | `/om:brainstorm` |
+| "修复登录页面的样式问题" | 简单 | `/om:start` |
+| "改一下这个变量名" | 简单 | `/om:start` |
+| "添加一个测试用例" | 简单 | `/om:start` |
+| "重构这个模块" | 中等 | `/om:brainstorm` (保守选择) |
+| "优化性能" | 中等 | `/om:brainstorm` (保守选择) |
+
+**不确定时的默认选择: `/om:brainstorm`** (宁可多问，不可漏问)
+</smart-selection>
+
 <exclusions>
 ## When NOT to Invoke (Rare Cases)
 
@@ -65,24 +118,19 @@ Automatically detect when user wants to accomplish a development task and invoke
 **Key Test:**
 ```
 用户要我写代码/改代码/做东西吗?
-  ↓ Yes → /om:start
+  ↓ Yes → Smart Select (brainstorm/start)
   ↓ No  → 直接回答
 ```
 
-**When in doubt → INVOKE `/om:start`. It handles both simple and complex tasks.**
+**When in doubt → INVOKE. It handles both simple and complex tasks.**
 </exclusions>
 
 <examples>
-| User Input | Should Invoke? | Reason |
-|------------|----------------|--------|
-| `增加一个 om:upgrade 命令` | ✅ Yes | "增加" = add |
-| `实现用户登录功能` | ✅ Yes | "实现" = implement |
-| `登录页面报错了` | ✅ Yes | Bug report |
-| `重构这个模块` | ✅ Yes | "重构" = refactor |
-| `优化性能` | ✅ Yes | "优化" = optimize |
-| `写个测试` | ✅ Yes | "写" = write |
-| `怎么实现登录?` | ❌ No | Question, not request |
-| `显示当前配置` | ❌ No | Information request |
-| `这个文件是干嘛的` | ❌ No | Question about code |
-| `帮我...` | ✅ Yes | "帮我" usually means task |
-</examples>
+| User Input | Complexity | Action |
+|------------|------------|--------|
+| `实现用户登录功能` | 复杂 | → `/om:brainstorm` |
+| `做一个完整的订单系统` | 复杂 | → `/om:brainstorm` |
+| `修复登录页面的样式问题` | 简单 | → `/om:start` |
+| `改一下这个变量名` | 简单 | → `/om:start` |
+| `重构用户模块` | 中等 | → `/om:brainstorm` |
+| `怎么实现登录?` | - | ❌ Question, not task |