openmatrix 0.1.61 → 0.1.62

package/dist/cli/commands/approve.js

@@ -10,6 +10,7 @@ exports.approveCommand = new commander_1.Command('approve')
     .argument('[approvalId]', '审批ID')
     .option('-d, --decision <decision>', '决策 (approve/modify/reject)')
     .option('-c, --comment <comment>', '备注说明')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
     .action(async (approvalId, options) => {
     const basePath = process.cwd();
     const omPath = `${basePath}/.openmatrix`;
@@ -20,23 +21,33 @@ exports.approveCommand = new commander_1.Command('approve')
     if (!approvalId) {
         const pendingApprovals = await approvalManager.getPendingApprovals();
         if (pendingApprovals.length === 0) {
-            console.log('✅ 没有待处理的审批');
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'empty', pending: [] }));
+            }
+            else {
+                console.log('✅ 没有待处理的审批');
+            }
             return;
         }
-        console.log('📋 待处理审批:\n');
-        pendingApprovals.forEach((approval, i) => {
-            const typeEmoji = {
-                plan: '📋',
-                merge: '🔀',
-                deploy: '🚀',
-                meeting: '🔴',
-                custom: '📝'
-            };
-            const emoji = typeEmoji[approval.type] || '📝';
-            console.log(`  [${i + 1}] ${emoji} ${approval.id}: ${approval.title}`);
-            console.log(`      类型: ${approval.type} | 任务: ${approval.taskId}`);
-        });
-        console.log('\n💡 使用 openmatrix approve <ID> 处理审批');
+        if (options.json) {
+            console.log(JSON.stringify({ status: 'pending', pending: pendingApprovals }));
+        }
+        else {
+            console.log('📋 待处理审批:\n');
+            pendingApprovals.forEach((approval, i) => {
+                const typeEmoji = {
+                    plan: '📋',
+                    merge: '🔀',
+                    deploy: '🚀',
+                    meeting: '🔴',
+                    custom: '📝'
+                };
+                const emoji = typeEmoji[approval.type] || '📝';
+                console.log(`  [${i + 1}] ${emoji} ${approval.id}: ${approval.title}`);
+                console.log(`      类型: ${approval.type} | 任务: ${approval.taskId}`);
+            });
+            console.log('\n💡 使用 openmatrix approve <ID> 处理审批');
+        }
         return;
     }
     // 获取审批

package/dist/cli/commands/brainstorm.js

@@ -38,6 +38,10 @@ exports.brainstormCommand = void 0;
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
 const gitignore_js_1 = require("../../utils/gitignore.js");
+const smart_question_analyzer_js_1 = require("../../orchestrator/smart-question-analyzer.js");
+const interactive_question_generator_js_1 = require("../../orchestrator/interactive-question-generator.js");
+const task_parser_js_1 = require("../../orchestrator/task-parser.js");
+const answer_mapper_js_1 = require("../../orchestrator/answer-mapper.js");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 exports.brainstormCommand = new commander_1.Command('brainstorm')
@@ -175,8 +179,8 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
             break;
         }
     }
-    // 生成头脑风暴问题
-    const questions = generateBrainstormQuestions(taskContent, taskTitle);
+    // 生成头脑风暴问题 — 使用智能管道
+    const questions = await generateSmartQuestions(taskContent, basePath);
     // 检测是否涉及垂直领域
     const domainDetection = detectVerticalDomain(taskContent);
     // 创建会话
@@ -411,3 +415,45 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
     }
     return questions;
 }
+/**
+ * 智能问题生成 — 使用 SmartQuestionAnalyzer + InteractiveQuestionGenerator
+ */
+async function generateSmartQuestions(taskContent, basePath) {
+    try {
+        // 1. 解析任务为 ParsedTask
+        const parser = new task_parser_js_1.TaskParser();
+        const parsedTask = parser.parse(taskContent);
+        // 2. 分析项目上下文 + 推断答案
+        const analyzer = new smart_question_analyzer_js_1.SmartQuestionAnalyzer(basePath);
+        const analysisResult = await analyzer.analyze(taskContent, parsedTask);
+        // 3. 映射推断结果为规范 brainstorm ID
+        const inferenceMap = (0, answer_mapper_js_1.translateAnalyzerInferences)(analysisResult.inferences);
+        // 4. 创建问题生成器 + 设置推断
+        const questionGen = new interactive_question_generator_js_1.InteractiveQuestionGenerator();
+        questionGen.setInferences(inferenceMap);
+        // 5. 生成基础问题 + 上下文问题
+        const session = questionGen.startSession(parsedTask);
+        questionGen.addContextualQuestions(parsedTask, session.questions);
+        // 6. 转换为 BrainstormQuestion[] 格式
+        const questions = session.questions
+            .filter(q => !session.skippedQuestionIds?.includes(q.id)) // 跳过高置信度推断的问题
+            .sort((a, b) => (a.priority ?? 5) - (b.priority ?? 5))
+            .map(q => ({
+            id: q.id,
+            question: q.question,
+            header: q.category,
+            options: (q.options || []).map(o => ({
+                label: o.label,
+                description: o.description || ''
+            })),
+            multiSelect: q.type === 'multiple',
+            why: ''
+        }));
+        return questions;
+    }
+    catch (error) {
+        // Fallback: 如果智能管道出错，使用静态问题
+        console.error(`⚠️ 智能问题生成失败，使用静态问题: ${error instanceof Error ? error.message : error}`);
+        return generateBrainstormQuestions(taskContent, '');
+    }
+}

package/dist/orchestrator/answer-mapper.d.ts

@@ -0,0 +1,24 @@
+import type { QuestionInference } from './smart-question-analyzer.js';
+/**
+ * 将 brainstorm 答案键翻译为 TaskPlanner 期望的键
+ *
+ * 支持两种输入:
+ * 1. 规范 ID (如 objective, quality_level) → 直接映射
+ * 2. 旧 brainstorm ID (如 core_objective, quality) → 先转规范 ID 再映射
+ */
+export declare function translateBrainstormAnswers(answers: Record<string, string | string[]>): Record<string, string | string[]>;
+/**
+ * 将 SmartQuestionAnalyzer 推理结果转换为 brainstorm 规范 ID
+ */
+export declare function translateAnalyzerInferences(inferences: QuestionInference[]): Map<string, {
+    answer: string | string[];
+    reason: string;
+}>;
+/**
+ * 从 brainstorm 答案中提取 tasks-input.json 所需的字段
+ */
+export declare function extractTasksInputFields(answers: Record<string, string | string[]>): {
+    quality?: string;
+    mode?: string;
+    e2eTests?: boolean;
+};

package/dist/orchestrator/answer-mapper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateBrainstormAnswers = translateBrainstormAnswers;
+exports.translateAnalyzerInferences = translateAnalyzerInferences;
+exports.extractTasksInputFields = extractTasksInputFields;
+/**
+ * 答案键映射 — 统一三套 ID 体系
+ *
+ * Brainstorm 问题 ID  →  规范 ID  →  TaskPlanner 期望的键
+ */
+/** Brainstorm 旧 ID → 规范 ID */
+const BRAINSTORM_TO_CANONICAL = {
+    core_objective: 'objective',
+    user_value: 'user_value',
+    complexity: 'complexity',
+    tech_constraints: 'tech_stack',
+    risks: 'risks',
+    acceptance: 'acceptance',
+    priority: 'priority',
+    quality: 'quality_level',
+    execution_mode: 'execution_mode',
+    e2e_tests: 'e2e_tests',
+};
+/** 规范 ID → TaskPlanner extractUserContext() 期望的键 */
+const CANONICAL_TO_PLANNER = {
+    objective: { '目标': '', objective: '' },
+    tech_stack: { '技术栈': '', techStack: '' },
+    test_coverage: { '测试': '', testCoverage: '' },
+    documentation_level: { '文档': '', documentationLevel: '' },
+    e2e_tests: { 'E2E测试': '', e2eTests: '', e2e: '' },
+    e2e_type: { 'E2E类型': '', e2eType: '' },
+};
+/** Analyzer 旧 ID → 规范 ID */
+const ANALYZER_TO_CANONICAL = {
+    quality_level: 'quality_level',
+    tech_stack: 'tech_stack',
+    doc_level: 'documentation_level',
+    e2e_test: 'e2e_tests',
+    execution_mode: 'execution_mode',
+    objective: 'objective',
+    test_coverage: 'test_coverage',
+};
+/**
+ * 将 brainstorm 答案键翻译为 TaskPlanner 期望的键
+ *
+ * 支持两种输入:
+ * 1. 规范 ID (如 objective, quality_level) → 直接映射
+ * 2. 旧 brainstorm ID (如 core_objective, quality) → 先转规范 ID 再映射
+ */
+function translateBrainstormAnswers(answers) {
+    const result = {};
+    for (const [key, value] of Object.entries(answers)) {
+        // 步骤 1: 旧 brainstorm ID → 规范 ID
+        const canonical = BRAINSTORM_TO_CANONICAL[key] || key;
+        // 步骤 2: 规范 ID → planner 键
+        const plannerKeys = CANONICAL_TO_PLANNER[canonical];
+        if (plannerKeys) {
+            for (const plannerKey of Object.keys(plannerKeys)) {
+                result[plannerKey] = value;
+            }
+        }
+        // 同时保留原始键和规范 ID（向后兼容）
+        result[key] = value;
+        if (canonical !== key) {
+            result[canonical] = value;
+        }
+    }
+    return result;
+}
+/**
+ * 将 SmartQuestionAnalyzer 推理结果转换为 brainstorm 规范 ID
+ */
+function translateAnalyzerInferences(inferences) {
+    const result = new Map();
+    for (const inf of inferences) {
+        if (inf.inferredAnswer === undefined)
+            continue;
+        const canonical = ANALYZER_TO_CANONICAL[inf.questionId] || inf.questionId;
+        result.set(canonical, {
+            answer: inf.inferredAnswer,
+            reason: inf.reason
+        });
+    }
+    return result;
+}
+/**
+ * 从 brainstorm 答案中提取 tasks-input.json 所需的字段
+ */
+function extractTasksInputFields(answers) {
+    const result = {};
+    // quality_level / quality → quality 字段
+    const quality = answers['quality_level'] || answers['quality'];
+    if (typeof quality === 'string') {
+        result.quality = quality;
+    }
+    // execution_mode → mode 字段
+    const mode = answers['execution_mode'];
+    if (typeof mode === 'string') {
+        result.mode = mode;
+    }
+    // e2e_tests → e2eTests 布尔字段
+    const e2e = answers['e2e_tests'] || answers['e2eTests'] || answers['E2E测试'];
+    if (e2e !== undefined) {
+        const e2eStr = Array.isArray(e2e) ? e2e[0] : e2e;
+        result.e2eTests = e2eStr === 'true' || e2eStr === '启用 E2E 测试' || e2eStr === '是';
+    }
+    return result;
+}

package/dist/orchestrator/interactive-question-generator.js

@@ -193,18 +193,18 @@ class InteractiveQuestionGenerator {
      */
     generateBaseQuestions(task) {
         const questions = [];
-        // 1. 核心目标
+        // 1. 任务目标
         questions.push({
             id: 'objective',
-            question: '这个任务的主要目标是什么？',
+            question: '这个任务的核心目标是什么？想要解决什么问题？',
             type: 'single',
             required: true,
             category: 'objective',
             priority: 1,
             options: [
-                { key: 'new_feature', label: '实现新功能', description: '添加新的功能特性' },
-                { key: 'bug_fix', label: '修复 Bug', description: '修复已知问题' },
-                { key: 'refactor', label: '重构优化', description: '改进代码结构或性能' },
+                { key: 'new_feature', label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
+                { key: 'bug_fix', label: '修复问题', description: '修复 Bug 或解决已知问题' },
+                { key: 'refactor', label: '重构优化', description: '改进代码结构、性能或可维护性' },
                 { key: 'other', label: '其他', description: '其他类型任务' }
             ],
             followUpCondition: {
@@ -221,14 +221,28 @@ class InteractiveQuestionGenerator {
                 ]
             }
         });
-        // 2. 技术栈
+        // 2. 质量级别
+        questions.push({
+            id: 'quality_level',
+            question: '选择质量门禁级别（决定测试覆盖、Lint、安全扫描等要求）',
+            type: 'single',
+            required: true,
+            category: 'quality',
+            priority: 2,
+            options: [
+                { key: 'strict', label: 'strict', description: 'TDD + 80% 覆盖率 + 严格 Lint + 安全扫描 — 生产级代码' },
+                { key: 'balanced', label: 'balanced (推荐)', description: '60% 覆盖率 + Lint + 安全扫描 — 日常开发' },
+                { key: 'fast', label: 'fast', description: '无质量门禁 — 快速原型/验证' }
+            ]
+        });
+        // 3. 技术栈
         questions.push({
             id: 'tech_stack',
             question: '使用什么技术栈？',
             type: 'multiple',
             required: true,
             category: 'technical',
-            priority: 2,
+            priority: 3,
             options: [
                 { key: 'typescript', label: 'TypeScript', description: '类型安全的 JavaScript' },
                 { key: 'javascript', label: 'JavaScript', description: '标准 JavaScript' },
@@ -247,64 +261,33 @@ class InteractiveQuestionGenerator {
                         type: 'text',
                         required: true,
                         category: 'technical',
-                        priority: 2.5
+                        priority: 3.5
                     }
                 ]
             }
         });
-        // 3. 数据存储
-        questions.push({
-            id: 'data_storage',
-            question: '需要什么类型的存储？',
-            type: 'single',
-            required: true,
-            category: 'technical',
-            priority: 3,
-            options: [
-                { key: 'postgresql', label: 'PostgreSQL', description: '关系型数据库' },
-                { key: 'mongodb', label: 'MongoDB', description: '文档数据库' },
-                { key: 'sqlite', label: 'SQLite', description: '本地数据库' },
-                { key: 'none', label: '无需存储', description: '不需要数据持久化' }
-            ]
-        });
-        // 4. 认证方式
+        // 4. 执行模式
         questions.push({
-            id: 'auth_method',
-            question: '需要用户认证吗？',
+            id: 'execution_mode',
+            question: '选择执行模式（控制 AI 执行过程中的审批节点）',
             type: 'single',
             required: true,
-            category: 'technical',
+            category: 'quality',
             priority: 4,
             options: [
-                { key: 'jwt', label: 'JWT Token', description: '无状态认证' },
-                { key: 'oauth', label: 'OAuth 2.0', description: '第三方授权' },
-                { key: 'session', label: 'Session Cookie', description: '传统会话' },
-                { key: 'none', label: '无需认证', description: '无用户系统' }
+                { key: 'auto', label: 'auto (推荐)', description: '全自动执行，无需人工审批，遇到阻塞自动 Meeting' },
+                { key: 'confirm-key', label: 'confirm-key', description: '关键节点审批（计划、合并、部署）' },
+                { key: 'confirm-all', label: 'confirm-all', description: '每个阶段都需人工确认' }
             ]
         });
-        // 5. API 风格
-        questions.push({
-            id: 'api_style',
-            question: 'API 采用什么风格？',
-            type: 'single',
-            required: true,
-            category: 'technical',
-            priority: 5,
-            options: [
-                { key: 'rest', label: 'RESTful', description: 'REST API' },
-                { key: 'graphql', label: 'GraphQL', description: 'GraphQL API' },
-                { key: 'grpc', label: 'gRPC', description: '高性能 RPC' },
-                { key: 'mixed', label: '混合', description: '多种风格混合' }
-            ]
-        });
-        // 6. 测试要求
+        // 5. 测试覆盖率
         questions.push({
             id: 'test_coverage',
             question: '测试覆盖率要求？',
             type: 'single',
             required: true,
             category: 'quality',
-            priority: 6,
+            priority: 5,
             options: [
                 { key: 'high', label: '>80% (严格)', description: '完整单元测试和集成测试' },
                 { key: 'medium', label: '>60% (标准)', description: '核心功能测试' },
@@ -312,14 +295,14 @@ class InteractiveQuestionGenerator {
                 { key: 'none', label: '无要求', description: '不需要测试' }
             ]
         });
-        // 7. 文档要求
+        // 6. 文档要求
         questions.push({
-            id: 'doc_level',
+            id: 'documentation_level',
             question: '需要什么级别的文档？',
             type: 'single',
             required: true,
             category: 'quality',
-            priority: 7,
+            priority: 6,
             options: [
                 { key: 'full', label: '完整文档', description: 'API + 使用指南 + 架构' },
                 { key: 'basic', label: '基础文档', description: 'README + API' },
@@ -327,6 +310,49 @@ class InteractiveQuestionGenerator {
                 { key: 'none', label: '无需文档', description: '不生成文档' }
             ]
         });
+        // 7. E2E 测试
+        questions.push({
+            id: 'e2e_tests',
+            question: '是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
+            type: 'single',
+            required: false,
+            category: 'quality',
+            priority: 7,
+            options: [
+                { key: 'true', label: '启用 E2E 测试', description: '使用 Playwright/Cypress 等框架进行端到端测试' },
+                { key: 'false', label: '不启用 (推荐)', description: '仅进行单元测试和集成测试，节省时间' }
+            ]
+        });
+        // 8. 风险评估
+        questions.push({
+            id: 'risks',
+            question: '这个任务可能面临哪些风险或挑战？',
+            type: 'multiple',
+            required: true,
+            category: 'risk',
+            priority: 8,
+            options: [
+                { key: 'technical', label: '技术风险', description: '技术实现存在不确定性' },
+                { key: 'time', label: '时间风险', description: '需要在短时间内完成' },
+                { key: 'compatibility', label: '兼容性风险', description: '可能影响现有功能' },
+                { key: 'none', label: '无明显风险', description: '任务清晰，风险可控' }
+            ]
+        });
+        // 9. 验收标准
+        questions.push({
+            id: 'acceptance',
+            question: '如何判断任务完成？有哪些验收标准？',
+            type: 'multiple',
+            required: true,
+            category: 'scope',
+            priority: 9,
+            options: [
+                { key: 'functional', label: '功能完整', description: '所有功能按预期工作' },
+                { key: 'tested', label: '测试覆盖', description: '有足够的测试覆盖' },
+                { key: 'performance', label: '性能达标', description: '满足性能要求' },
+                { key: 'documented', label: '文档完善', description: '有完整的使用文档' }
+            ]
+        });
         return questions;
     }
     /**

package/dist/orchestrator/smart-question-analyzer.d.ts

@@ -75,6 +75,14 @@ export declare class SmartQuestionAnalyzer {
      * 推断执行模式
      */
     private inferExecutionMode;
+    /**
+     * 推断任务目标类型
+     */
+    private inferObjective;
+    /**
+     * 推断测试覆盖率级别
+     */
+    private inferTestCoverage;
     /**
      * 生成推断摘要
      */

package/dist/orchestrator/smart-question-analyzer.js

@@ -176,6 +176,10 @@ class SmartQuestionAnalyzer {
         inferences.push(this.inferE2ETest(desc, context));
         // 5. 推断执行模式
         inferences.push(this.inferExecutionMode(desc, context));
+        // 6. 推断任务目标类型
+        inferences.push(this.inferObjective(desc, context));
+        // 7. 推断测试覆盖率级别
+        inferences.push(this.inferTestCoverage(desc, context));
         return inferences;
     }
     /**
@@ -384,6 +388,74 @@ class SmartQuestionAnalyzer {
         inference.reason = '无法确定执行模式';
         return inference;
     }
+    /**
+     * 推断任务目标类型
+     */
+    inferObjective(desc, context) {
+        const inference = {
+            questionId: 'objective',
+            confidence: 'low',
+            reason: ''
+        };
+        if (/(fix|bug|修复|hotfix|patch)/i.test(desc)) {
+            inference.inferredAnswer = 'bug_fix';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含修复关键词';
+        }
+        else if (/(implement|add|新功能|实现|开发|feature|新增)/i.test(desc)) {
+            inference.inferredAnswer = 'new_feature';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含新功能关键词';
+        }
+        else if (/(refactor|优化|重构|improve|性能)/i.test(desc)) {
+            inference.inferredAnswer = 'refactor';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含重构关键词';
+        }
+        else if (/(test|测试|coverage|覆盖)/i.test(desc)) {
+            inference.inferredAnswer = 'test';
+            inference.confidence = 'medium';
+            inference.reason = '任务描述包含测试关键词';
+        }
+        else {
+            inference.reason = '无法确定任务目标类型';
+        }
+        return inference;
+    }
+    /**
+     * 推断测试覆盖率级别
+     */
+    inferTestCoverage(desc, context) {
+        const inference = {
+            questionId: 'test_coverage',
+            confidence: 'low',
+            reason: ''
+        };
+        if (context.hasTests && /(test|测试)/i.test(desc)) {
+            inference.inferredAnswer = 'high';
+            inference.confidence = 'medium';
+            inference.reason = '项目已有测试，且任务涉及测试';
+        }
+        else if (/(implement|add|新功能|实现|feature)/i.test(desc)) {
+            inference.inferredAnswer = 'medium';
+            inference.confidence = 'low';
+            inference.reason = '新功能任务，中等测试覆盖率';
+        }
+        else if (/(fix|bug|修复)/i.test(desc)) {
+            inference.inferredAnswer = 'low';
+            inference.confidence = 'medium';
+            inference.reason = 'Bug 修复，需要回归测试但覆盖率要求不高';
+        }
+        else if (/(prototype|poc|demo|快速|原型)/i.test(desc)) {
+            inference.inferredAnswer = 'none';
+            inference.confidence = 'medium';
+            inference.reason = '原型任务，不需要测试';
+        }
+        else {
+            inference.reason = '无法确定测试覆盖率级别';
+        }
+        return inference;
+    }
     /**
      * 生成推断摘要
      */

package/dist/orchestrator/task-planner.d.ts

@@ -16,7 +16,7 @@ export interface UserAnswers {
     techStack?: string[];
     testCoverage?: string;
     documentationLevel?: string;
-    additionalContext?: Record<string, string>;
+    additionalContext?: Record<string, string | string[]>;
     /** 是否启用 E2E 测试 */
     e2eTests?: boolean;
     /** E2E 测试类型 (web/mobile/gui) */

package/dist/orchestrator/task-planner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskPlanner = void 0;
+const answer_mapper_js_1 = require("./answer-mapper.js");
 /**
  * TaskPlanner - 任务拆解器
  *
@@ -261,16 +262,21 @@ ${userContext.documentationLevel}
      * 提取用户上下文
      */
     extractUserContext(answers) {
-        const e2eAnswer = answers['E2E测试'] || answers['e2eTests'] || answers['e2e'];
-        const e2eTypeAnswer = answers['E2E类型'] || answers['e2eType'];
+        // 先翻译 brainstorm 规范键为 planner 期望的键
+        const translated = (0, answer_mapper_js_1.translateBrainstormAnswers)(answers);
+        const merged = { ...answers, ...translated };
+        // 辅助函数：提取字符串值（处理 string[] 情况）
+        const str = (v) => Array.isArray(v) ? v.join(', ') : v;
+        const e2eAnswer = str(merged['E2E测试'] || merged['e2eTests'] || merged['e2e']);
+        const e2eTypeAnswer = str(merged['E2E类型'] || merged['e2eType']);
         return {
-            objective: answers['目标'] || answers['objective'],
-            techStack: this.parseArrayAnswer(answers['技术栈'] || answers['techStack']),
-            testCoverage: answers['测试'] || answers['testCoverage'],
-            documentationLevel: answers['文档'] || answers['documentationLevel'],
+            objective: str(merged['目标'] || merged['objective']),
+            techStack: this.parseArrayAnswer(str(merged['技术栈'] || merged['techStack']) || ''),
+            testCoverage: str(merged['测试'] || merged['testCoverage']),
+            documentationLevel: str(merged['文档'] || merged['documentationLevel']),
             e2eTests: e2eAnswer === 'true' || e2eAnswer === '✅ 启用 E2E 测试' || e2eAnswer === '是',
             e2eType: e2eTypeAnswer || 'web',
-            additionalContext: answers
+            additionalContext: merged
         };
     }
     parseArrayAnswer(answer) {

package/package.json

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

package/scripts/install-skills.js

@@ -7,45 +7,51 @@ const os = require('os');
 // Change to home directory to avoid cwd issues
 process.chdir(os.homedir());
 
-try {
-  // Get the package skills directory - use the path relative to this script
-  const scriptDir = __dirname;
-  const skillsDir = path.join(scriptDir, '..', 'skills');
+// Get the package skills directory - use the path relative to this script
+const scriptDir = __dirname;
+const skillsDir = path.join(scriptDir, '..', 'skills');
+
+// Target directories for different AI coding tools
+const targets = [
+  {
+    name: 'Claude Code',
+    dir: path.join(os.homedir(), '.claude', 'commands', 'om'),
+  },
+  {
+    name: 'OpenCode',
+    dir: path.join(os.homedir(), '.config', 'opencode', 'commands', 'om'),
+  },
+];
+
+if (!fs.existsSync(skillsDir)) {
+  console.log('Skills directory not found, skipping installation.');
+  process.exit(0);
+}
 
-  // Get user's .claude directory
-  const claudeDir = path.join(os.homedir(), '.claude');
-  const commandsDir = path.join(claudeDir, 'commands', 'om');
+const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
 
-  // Create commands directory if it doesn't exist
+for (const target of targets) {
   try {
-    if (!fs.existsSync(commandsDir)) {
-      fs.mkdirSync(commandsDir, { recursive: true });
+    // Create commands directory if it doesn't exist
+    if (!fs.existsSync(target.dir)) {
+      fs.mkdirSync(target.dir, { recursive: true });
     }
-  } catch (mkdirErr) {
-    console.log(`⚠️  Cannot create ${commandsDir}`);
-    console.log(`   Please run: mkdir -p ${commandsDir}`);
-    process.exit(0);
-  }
 
-  // Copy skill files
-  if (fs.existsSync(skillsDir)) {
-    const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
-
-    files.forEach(file => {
+    let installed = 0;
+    for (const file of files) {
       const src = path.join(skillsDir, file);
-      const dest = path.join(commandsDir, file);
+      const dest = path.join(target.dir, file);
       try {
         fs.copyFileSync(src, dest);
-        console.log(`✓ Installed: om:${path.basename(file, '.md')}`);
+        installed++;
       } catch (copyErr) {
-        console.log(`⚠️  Skipped: om:${path.basename(file, '.md')} (${copyErr.message})`);
+        console.log(`  ⚠️  Skipped: ${file} (${copyErr.message})`);
       }
-    });
+    }
 
-    console.log(`\n✅ OpenMatrix skills installed to ${commandsDir}`);
-  } else {
-    console.log('Skills directory not found, skipping installation.');
+    console.log(`✅ ${target.name}: ${installed} skills installed to ${target.dir}`);
+  } catch (err) {
+    console.log(`⚠️  ${target.name}: skipped (${err.message})`);
+    console.log(`   Please run: mkdir -p ${target.dir}`);
   }
-} catch (err) {
-  console.log('OpenMatrix skills installation skipped:', err.message);
 }

package/skills/approve.md

@@ -14,7 +14,7 @@ description: 审批待处理项（包括计划、合并、部署、Meeting）
 <process>
 1. **获取待审批列表**
    ```bash
-   openmatrix approve --list
+   openmatrix approve
    ```
 
 2. **如果没有待审批项**
@@ -152,9 +152,11 @@ description: 审批待处理项（包括计划、合并、部署、Meeting）
 
 5. **执行审批**
    ```bash
-   openmatrix approve <approvalId> -d <approve|reject|modify> [-c "备注"]
+   openmatrix approve <approvalId> -d <approve|reject|modify> [-c "备注"] --json
    ```
 
+   **注意**: approvalId 是位置参数，不要使用 --id。正确格式: `openmatrix approve APPR-001 -d approve --json`
+
 6. **更新状态**
 
    - 写入审批结果到 `approvals/{id}.json`
@@ -214,18 +216,13 @@ Meeting 审批需要更细致的交互:
 ## CLI 命令
 
 ```bash
-# 列出待审批
-openmatrix approve
-
-# 处理审批
-openmatrix approve APPR-001 -d approve -c "同意此方案"
-openmatrix approve APPR-001 -d reject -c "需要重新设计"
-openmatrix approve APPR-001 -d modify -c "增加测试覆盖率要求"
-
-# Meeting 专用 (使用 meeting 命令)
-openmatrix meeting APPR-002 --action provide-info --info "数据库连接字符串是..."
-openmatrix meeting APPR-002 --action skip --message "此任务可选"
-openmatrix meeting APPR-002 --action cancel --message "需求变更，停止执行"
+# 列出待审批 (不传 ID)
+openmatrix approve --json
+
+# 处理审批 (ID 是位置参数，不要用 --id)
+openmatrix approve APPR-001 -d approve -c "同意此方案" --json
+openmatrix approve APPR-001 -d reject -c "需要重新设计" --json
+openmatrix approve APPR-001 -d modify -c "增加测试覆盖率要求" --json
 ```
 
 ## 与执行循环的集成

package/skills/brainstorm.md

@@ -23,7 +23,7 @@ OpenMatrix 独立运行，不依赖外部任务编排系统。
 
    调用 CLI 创建头脑风暴会话:
    ```bash
-   openmatrix brainstorm --json
+   openmatrix brainstorm "$ARGUMENTS" --json
    ```
 
    这会返回:
@@ -271,13 +271,17 @@ $ARGUMENTS
 
 | 问题 ID | 目的 | 为什么重要 |
 |---------|------|-----------|
-| core_objective | 明确核心目标 | 选择正确的实现策略 |
-| user_value | 了解用户价值 | 设计合适的接口 |
-| complexity | 评估复杂度 | 决定实施策略 |
-| tech_constraints | 技术约束 | 影响方案选择 |
-| risks | 风险评估 | 提前规划应对 |
-| acceptance | 验收标准 | 判断完成度 |
-| priority | 优先级 | 资源分配 |
+| objective | 明确任务目标（新功能/修复/重构） | 选择正确的实现策略 |
+| quality_level | 质量门禁级别（strict/balanced/fast） | 影响测试覆盖、Lint、安全扫描要求 |
+| tech_stack | 技术栈选择 | 决定使用什么框架和工具 |
+| execution_mode | 执行模式（auto/confirm-key/confirm-all） | 控制审批节点和自动化程度 |
+| test_coverage | 测试覆盖率要求 | 影响测试任务生成 |
+| documentation_level | 文档要求级别 | 影响文档任务生成 |
+| e2e_tests | 是否启用 E2E 测试 | Web/Mobile/GUI 项目适用 |
+| risks | 风险评估 | 提前规划应对策略 |
+| acceptance | 验收标准 | 判断任务完成度 |
+
+> **智能预填**：当 `SmartQuestionAnalyzer` 对某个问题有高置信度推断时，该问题会被自动跳过，不需要用户回答。
 
 ## 与 start 的集成
 
@@ -286,12 +290,15 @@ $ARGUMENTS
 ```json
 {
   "answers": {
-    "core_objective": "实现新功能",
-    "user_value": "终端用户",
-    "complexity": "中等",
-    "risks": ["技术风险", "兼容性风险"],
-    "acceptance": ["功能完整", "测试覆盖"],
-    "priority": "中优先级"
+    "objective": "new_feature",
+    "quality_level": "balanced",
+    "tech_stack": ["typescript", "react"],
+    "execution_mode": "auto",
+    "test_coverage": "medium",
+    "documentation_level": "basic",
+    "e2e_tests": "false",
+    "risks": ["technical", "compatibility"],
+    "acceptance": ["functional", "tested"]
   },
   "insights": [
     "需要考虑安全性",