openmatrix 0.1.40 → 0.1.41

package/dist/cli/commands/brainstorm.js

@@ -79,6 +79,12 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
                 }
             }
             await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
+            // 构建下一个步骤的命令
+            const brainstormAnswers = JSON.stringify({
+                answers: session.answers,
+                insights: session.insights,
+                designNotes: session.designNotes
+            });
             if (options.json) {
                 console.log(JSON.stringify({
                     status: 'ready_to_start',
@@ -88,7 +94,23 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
                     answers: session.answers,
                     insights: session.insights,
                     designNotes: session.designNotes,
-                    hint: '使用 /om:start 开始执行任务'
+                    // 关键：告诉 Agent 下一步必须执行什么
+                    nextStep: {
+                        required: true,
+                        description: '必须调用此命令开始任务执行',
+                        command: 'openmatrix',
+                        args: ['start', session.taskInput.slice(0, 100)],
+                        options: {
+                            'brainstorm-answers': brainstormAnswers
+                        },
+                        hint: '使用 /om:start 开始执行任务'
+                    },
+                    // 强制执行标记 - Agent 必须执行 nextStep
+                    _meta: {
+                        requiresAction: true,
+                        actionType: 'cli_command',
+                        blocking: true
+                    }
                 }));
             }
             else {
@@ -216,206 +238,71 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
 });
 /**
  * 根据任务内容生成头脑风暴问题
+ *
+ * 基于"底层逻辑"方法论，不使用固定模板
  */
 function generateBrainstormQuestions(taskContent, taskTitle) {
     const questions = [];
-    const content = taskContent.toLowerCase();
-    const title = taskTitle.toLowerCase();
-    // 检测任务类型
-    const isGame = /游戏|game|玩家|player|塔防|td|rpg|射击|shooter|角色|character|关卡|level|boss|技能|skill|武器|weapon|敌人|enemy/.test(content + title);
-    const isAPI = /api|接口|后端|backend|rest|graphql|微服务|microservice/.test(content + title);
-    const isCLI = /cli|命令行|command|工具|tool|脚本|script/.test(content + title);
-    const isLibrary = /库|library|sdk|包|package|npm|组件|component/.test(content + title);
-    // 根据任务类型生成不同的问题
-    if (isGame) {
-        // ========== 游戏专用问题 ==========
-        questions.push({
-            id: 'game_type',
-            question: '这是什么类型的游戏？核心玩法是什么？',
-            header: '游戏类型',
-            options: [
-                { label: '塔防 (TD)', description: '放置防御塔，阻止敌人到达终点' },
-                { label: 'RPG', description: '角色扮演，升级成长' },
-                { label: '射击/动作', description: '实时战斗，操作为主' },
-                { label: '策略/模拟', description: '资源管理，策略决策' }
-            ],
-            multiSelect: false,
-            why: '游戏类型决定核心机制和技术架构'
-        });
-        questions.push({
-            id: 'target_player',
-            question: '目标玩家是谁？',
-            header: '目标玩家',
-            options: [
-                { label: '休闲玩家', description: '简单易上手，碎片时间游玩' },
-                { label: '硬核玩家', description: '深度策略，挑战性高' },
-                { label: '全年龄', description: '老少皆宜，难度适中' },
-                { label: '核心玩家', description: '游戏爱好者，追求高品质' }
-            ],
-            multiSelect: false,
-            why: '目标玩家决定游戏难度和设计风格'
-        });
-        questions.push({
-            id: 'game_platform',
-            question: '游戏运行在什么平台？',
-            header: '平台',
-            options: [
-                { label: 'Web 浏览器', description: 'HTML5/Canvas/WebGL' },
-                { label: '移动端', description: 'iOS/Android 原生或混合' },
-                { label: 'PC 桌面', description: 'Electron/原生应用' },
-                { label: '跨平台', description: '同时支持多个平台' }
-            ],
-            multiSelect: true,
-            why: '平台决定技术选型和性能优化方向'
-        });
-        questions.push({
-            id: 'game_features',
-            question: '游戏包含哪些核心功能？',
-            header: '核心功能',
-            options: [
-                { label: '多人对战', description: '实时/PVP/联机' },
-                { label: '单机闯关', description: '关卡/剧情模式' },
-                { label: '存档系统', description: '保存/加载进度' },
-                { label: '成就/排行榜', description: '激励机制' }
-            ],
-            multiSelect: true,
-            why: '核心功能决定开发优先级和工作量'
-        });
-        questions.push({
-            id: 'art_style',
-            question: '美术风格是什么？素材如何获取？',
-            header: '美术',
-            options: [
-                { label: '程序化生成', description: '用代码绘制图形' },
-                { label: '像素风', description: '复古像素艺术' },
-                { label: '使用免费素材', description: 'OpenGameArt 等资源' },
-                { label: '需要美术设计', description: '需要定制美术资源' }
-            ],
-            multiSelect: false,
-            why: '美术方案影响开发成本和视觉效果'
-        });
-    }
-    else if (isAPI) {
-        // ========== API 专用问题 ==========
-        questions.push({
-            id: 'api_consumer',
-            question: 'API 的调用方是谁？',
-            header: '调用方',
-            options: [
-                { label: '前端应用', description: 'Web/Mobile 前端调用' },
-                { label: '第三方开发者', description: '公开 API 供外部使用' },
-                { label: '内部服务', description: '微服务间调用' },
-                { label: '混合场景', description: '多种调用方' }
-            ],
-            multiSelect: false,
-            why: '调用方决定 API 设计和文档要求'
-        });
-        questions.push({
-            id: 'api_auth',
-            question: '需要什么样的认证授权？',
-            header: '认证',
-            options: [
-                { label: '无认证', description: '公开 API，无需认证' },
-                { label: 'API Key', description: '简单的密钥认证' },
-                { label: 'JWT/OAuth', description: '用户身份认证' },
-                { label: '需要调研', description: '认证方案待定' }
-            ],
-            multiSelect: false,
-            why: '认证方式影响安全架构'
-        });
-    }
-    else if (isCLI) {
-        // ========== CLI 专用问题 ==========
-        questions.push({
-            id: 'cli_user',
-            question: 'CLI 工具的主要使用者是谁？',
-            header: '使用者',
-            options: [
-                { label: '开发者', description: '开发流程辅助工具' },
-                { label: '运维人员', description: '部署/运维自动化' },
-                { label: '普通用户', description: '非技术用户也能使用' },
-                { label: 'CI/CD', description: '自动化流程中使用' }
-            ],
-            multiSelect: true,
-            why: '使用者决定交互设计和文档要求'
-        });
-        questions.push({
-            id: 'cli_output',
-            question: 'CLI 的输出格式要求？',
-            header: '输出',
-            options: [
-                { label: '人类可读', description: '彩色、表格、友好提示' },
-                { label: 'JSON 机器读', description: '结构化输出，便于解析' },
-                { label: '两种都支持', description: '通过参数切换' },
-                { label: '静默模式', description: '最少输出，仅错误' }
-            ],
-            multiSelect: false,
-            why: '输出格式影响用户体验和自动化集成'
-        });
-    }
-    else {
-        // ========== 通用问题 ==========
-        questions.push({
-            id: 'core_objective',
-            question: '这个任务的核心目标是什么？想要解决什么问题？',
-            header: '核心目标',
-            options: [
-                { label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
-                { label: '修复问题', description: '修复 Bug 或解决已知问题' },
-                { label: '重构优化', description: '改进代码结构、性能或可维护性' },
-                { label: '技术探索', description: '探索新技术方案，验证可行性' }
-            ],
-            multiSelect: false,
-            why: '明确核心目标有助于选择正确的实现策略和质量标准'
-        });
-        questions.push({
-            id: 'user_value',
-            question: '这个任务为用户带来什么价值？最终用户是谁？',
-            header: '用户价值',
-            options: [
-                { label: '开发者', description: '主要用户是开发者，需要清晰的 API 和文档' },
-                { label: '终端用户', description: '主要用户是终端用户，需要良好的用户体验' },
-                { label: '运维人员', description: '主要用户是运维，需要稳定性和可观测性' },
-                { label: '内部团队', description: '主要用户是内部团队，需要高效协作支持' }
-            ],
-            multiSelect: false,
-            why: '了解目标用户有助于设计合适的接口和交互方式'
-        });
-    }
-    // ========== 通用问题（所有类型都有） ==========
-    // 实现复杂度 - 如果任务内容包含复杂关键词
-    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: '复杂度评估有助于决定是否需要分阶段实施和额外的设计审查'
-        });
-    }
-    // 技术约束 - 如果涉及技术选型
-    if (content.includes('技术') || 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: '技术约束影响实现方案和后续维护成本'
-        });
-    }
-    // 风险评估
+    // ========== 第一层：价值逻辑 ==========
+    // 1. 核心目标
+    questions.push({
+        id: 'core_objective',
+        question: '这个任务的核心目标是什么？想要解决什么问题？',
+        header: '核心目标',
+        options: [
+            { label: '创建新系统', description: '从零开始构建新的系统或应用' },
+            { label: '添加新功能', description: '在现有系统上增加新能力' },
+            { label: '修复问题', description: '解决 Bug 或已知问题' },
+            { label: '优化改进', description: '提升性能、体验或代码质量' }
+        ],
+        multiSelect: false,
+        why: '明确核心目标有助于选择正确的实现策略'
+    });
+    // 2. 用户价值
+    questions.push({
+        id: 'user_value',
+        question: '这个任务为谁创造价值？最终用户是谁？',
+        header: '用户价值',
+        options: [
+            { label: '终端用户', description: '产品的最终使用者，需要良好体验' },
+            { label: '开发者', description: '技术用户，需要清晰的 API 和文档' },
+            { label: '团队内部', description: '内部工具，追求效率' },
+            { label: '业务方', description: '满足业务需求，关注指标' }
+        ],
+        multiSelect: false,
+        why: '了解目标用户有助于设计合适的方案'
+    });
+    // ========== 第二层：架构逻辑 ==========
+    // 3. 复杂度评估
+    questions.push({
+        id: 'complexity',
+        question: '这个任务的复杂度如何？涉及哪些关键组件？',
+        header: '复杂度',
+        options: [
+            { label: '简单', description: '单一功能，少量代码' },
+            { label: '中等', description: '多个组件协作，有依赖关系' },
+            { label: '复杂', description: '涉及架构设计，需要仔细规划' },
+            { label: '非常复杂', description: '大型系统，需要分阶段实施' }
+        ],
+        multiSelect: false,
+        why: '复杂度决定是否需要分阶段实施'
+    });
+    // 4. 技术约束
+    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: '这个任务可能面临哪些风险或挑战？',
@@ -429,7 +316,7 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '识别风险有助于提前规划应对策略'
     });
-    // 验收标准
+    // 6. 验收标准
     questions.push({
         id: 'acceptance',
         question: '如何判断任务完成？有哪些验收标准？',
@@ -443,15 +330,15 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '明确的验收标准有助于判断任务完成度'
     });
-    // 实现优先级
+    // 7. 优先级
     questions.push({
         id: 'priority',
-        question: '这个任务的优先级如何？是否需要 MVP 版本？',
+        question: '这个任务的优先级如何？实施策略是什么？',
         header: '优先级',
         options: [
             { label: '高优先级', description: '需要尽快完成，影响其他工作' },
             { label: '中优先级', description: '计划内任务，按正常节奏推进' },
-            { label: '低优先级', description: '可延后处理，有更重要的任务' },
+            { label: '低优先级', description: '可延后处理' },
             { label: '需要 MVP', description: '先实现最小可用版本，再迭代' }
         ],
         multiSelect: false,

package/dist/cli/commands/start.js

@@ -145,65 +145,110 @@ exports.startCommand = new commander_1.Command('start')
                 return;
             }
         }
+        else if (brainstormSession.status === 'ready_to_start' || brainstormSession.status === 'completed') {
+            // 头脑风暴已完成，自动使用保存的答案（如果没有显式传递）
+            if (!options.brainstormAnswers && brainstormSession.answers) {
+                // 自动使用保存的 brainstorm 答案
+                options.brainstormAnswers = JSON.stringify({
+                    answers: brainstormSession.answers,
+                    insights: brainstormSession.insights || [],
+                    designNotes: brainstormSession.designNotes || []
+                });
+                if (!options.json) {
+                    console.log('📋 自动使用已完成的头脑风暴结果');
+                }
+            }
+        }
     }
     catch {
         // brainstorm 文件不存在，继续执行
     }
     // 构建任务内容
     let taskContent = input;
-    // 如果提供了 --title 和 --description，构建任务内容
-    if (options.title || options.description) {
-        const title = options.title || '未命名任务';
-        const description = options.description || '';
-        const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
-        const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
-        taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
-    }
-    // 如果没有任务内容，尝试读取默认文件
-    if (!taskContent) {
-        const defaultPath = path.join(basePath, 'TASK.md');
+    let titleOverride = options.title; // 保存标题覆盖选项
+    // 如果输入是文件路径，先读取文件内容
+    if (taskContent && taskContent.endsWith('.md')) {
         try {
-            taskContent = await fs.readFile(defaultPath, 'utf-8');
+            taskContent = await fs.readFile(taskContent, 'utf-8');
             if (!options.json) {
-                console.log(`📄 读取任务文件: ${defaultPath}`);
+                console.log(`📄 读取任务文件: ${input}`);
             }
         }
         catch {
             if (options.json) {
                 console.log(JSON.stringify({
                     status: 'error',
-                    message: '请提供任务文件路径或描述'
+                    message: `无法读取文件: ${input}`
                 }));
             }
             else {
-                console.log('❌ 请提供任务文件路径或描述');
-                console.log('   用法: openmatrix start <task.md>');
-                console.log('   或创建 TASK.md 文件');
-                console.log('   或使用 --title 和 --description 选项');
+                console.log(`❌ 无法读取文件: ${input}`);
             }
             return;
         }
     }
-    else if (taskContent.endsWith('.md')) {
-        // 读取文件
+    else if (!taskContent) {
+        // 如果没有任务内容，尝试读取默认文件
+        const defaultPath = path.join(basePath, 'TASK.md');
         try {
-            taskContent = await fs.readFile(taskContent, 'utf-8');
+            taskContent = await fs.readFile(defaultPath, 'utf-8');
             if (!options.json) {
-                console.log(`📄 读取任务文件: ${input}`);
+                console.log(`📄 读取任务文件: ${defaultPath}`);
             }
         }
         catch {
-            if (options.json) {
-                console.log(JSON.stringify({
-                    status: 'error',
-                    message: `无法读取文件: ${input}`
-                }));
+            // 如果没有默认文件，使用 --title 和 --description 构建
+            if (options.title || options.description) {
+                const title = options.title || '未命名任务';
+                const description = options.description || '';
+                const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
+                const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
+                taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
+                titleOverride = undefined; // 内容已包含标题，不需要覆盖
             }
             else {
-                console.log(`❌ 无法读取文件: ${input}`);
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        status: 'error',
+                        message: '请提供任务文件路径或描述'
+                    }));
+                }
+                else {
+                    console.log('❌ 请提供任务文件路径或描述');
+                    console.log('   用法: openmatrix start <task.md>');
+                    console.log('   或创建 TASK.md 文件');
+                    console.log('   或使用 --title 和 --description 选项');
+                }
+                return;
+            }
+        }
+    }
+    else if (!taskContent.endsWith('.md') && !taskContent.includes('\n')) {
+        // 如果输入是单行文本，可能是文件路径或简短描述
+        // 检查是否是文件
+        const possiblePath = path.join(basePath, taskContent);
+        try {
+            taskContent = await fs.readFile(possiblePath, 'utf-8');
+            if (!options.json) {
+                console.log(`📄 读取任务文件: ${possiblePath}`);
             }
-            return;
         }
+        catch {
+            // 不是文件，作为描述处理
+            if (options.title || options.description) {
+                const title = options.title || '未命名任务';
+                const description = options.description || taskContent;
+                const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
+                const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
+                taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
+                titleOverride = undefined;
+            }
+        }
+    }
+    // 如果有标题覆盖，更新任务内容中的标题
+    if (titleOverride && taskContent) {
+        // 替换第一个 # 标题
+        taskContent = taskContent.replace(/^#\s+.+$/m, `# ${titleOverride}`);
     }
     // 解析任务
     if (!options.json) {

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

@@ -1,4 +1,12 @@
 import type { ParsedTask } from '../types/index.js';
+/**
+ * TaskParser - 任务解析器
+ *
+ * 职责：解析用户输入的任务描述，提取结构化信息
+ *
+ * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
+ * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
+ */
 export declare class TaskParser {
     parse(content: string): ParsedTask;
     private extractTitle;

package/dist/orchestrator/task-parser.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskParser = void 0;
+/**
+ * TaskParser - 任务解析器
+ *
+ * 职责：解析用户输入的任务描述，提取结构化信息
+ *
+ * 注意：TaskParser 只负责格式解析，不做业务逻辑判断
+ * 任务拆解的智能逻辑应该由 TaskPlanner (调用 AI) 来完成
+ */
 class TaskParser {
     parse(content) {
         const title = this.extractTitle(content);
@@ -18,38 +26,43 @@ class TaskParser {
         };
     }
     extractTitle(content) {
-        const match = content.match(/^#\s+(.+)$/m);
-        return match ? match[1].trim() : 'Untitled Task';
+        // 1. 从第一个 # 标题提取
+        const headerMatch = content.match(/^#\s+(.+)$/m);
+        if (headerMatch) {
+            return headerMatch[1].trim();
+        }
+        // 2. 没有标题，取第一行非空内容（截断到 50 字符）
+        const firstLine = content.split('\n').find(l => l.trim());
+        return firstLine ? firstLine.trim().slice(0, 50) : 'Untitled Task';
     }
     extractDescription(content) {
-        // Remove title and sections, get first paragraph
+        // 移除标题和 sections，获取第一段
         let desc = content
             .replace(/^#\s+.+$/m, '')
             .replace(/^##\s+.+$/gm, '')
             .replace(/^- .+$/gm, '')
             .trim();
-        // Get first non-empty line
+        // 获取第一个非空行
         const lines = desc.split('\n').filter(l => l.trim());
         return lines.length > 0 ? lines[0].trim() : '';
     }
     extractSection(content, sectionName) {
-        // Split content into lines and find the section
         const lines = content.split('\n');
         const items = [];
         let inSection = false;
         for (const line of lines) {
-            // Check if we're entering the target section
+            // 检查是否进入目标 section
             if (line.match(new RegExp(`^##\\s+${sectionName}\\s*$`))) {
                 inSection = true;
                 continue;
             }
-            // Check if we've hit another section
+            // 检查是否进入其他 section
             if (line.match(/^##\s+/)) {
                 if (inSection)
-                    break; // Exit if we were in the target section
+                    break;
                 continue;
             }
-            // Extract list items if we're in the target section
+            // 提取列表项
             if (inSection) {
                 const itemMatch = line.match(/^-\s+(.+)$/);
                 if (itemMatch) {

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

@@ -1,4 +1,14 @@
 import type { ParsedTask } from '../types/index.js';
+/**
+ * TaskBreakdown - 计划/任务拆解单元
+ *
+ * 术语区分:
+ * - Plan (计划): planner agent 输出，宏观层面，包含 ARCHITECTURE.md 和 PLAN.md
+ * - Task (任务): 具体执行单元，2-4 小时，有明确的验收标准
+ *
+ * 当 assignedAgent 为 'planner' 时，这是一个规划任务，输出是 Plan
+ * 当 assignedAgent 为其他时，这是具体的执行 Task
+ */
 export interface TaskBreakdown {
     taskId: string;
     title: string;
@@ -42,13 +52,36 @@ export declare class TaskPlanner {
     /**
      * Break down a parsed task into sub-tasks
      *
-     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
+     * 智能拆解策略:
+     * 1. 如果有明确的 goals (来自 ## 目标 section)，按目标拆解
+     * 2. 如果没有 goals 但有复杂内容，创建规划任务交给 AI 拆解
+     * 3. 如果是简单任务，直接创建单个开发任务
      */
     breakdown(parsedTask: ParsedTask, answers: Record<string, string>): TaskBreakdown[];
+    /**
+     * 判断是否为复杂任务
+     */
+    private isComplexTask;
+    /**
+     * 创建规划任务 (由 AI 智能拆解)
+     */
+    private createPlanningTask;
+    /**
+     * 创建单个开发任务
+     */
+    private createSingleTask;
+    /**
+     * 按目标拆解任务 (原有逻辑)
+     */
+    private breakdownByGoals;
     /**
      * 提取用户上下文
      */
     private extractUserContext;
+    /**
+     * 格式化用户上下文为字符串
+     */
+    private formatUserContext;
     /**
      * 解析数组类型的回答
      */

package/dist/orchestrator/task-planner.js

@@ -25,12 +25,129 @@ class TaskPlanner {
     /**
      * Break down a parsed task into sub-tasks
      *
-     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
+     * 智能拆解策略:
+     * 1. 如果有明确的 goals (来自 ## 目标 section)，按目标拆解
+     * 2. 如果没有 goals 但有复杂内容，创建规划任务交给 AI 拆解
+     * 3. 如果是简单任务，直接创建单个开发任务
      */
     breakdown(parsedTask, answers) {
         const breakdowns = [];
-        const seenTitles = new Set();
         const userContext = this.extractUserContext(answers);
+        // 判断任务复杂度
+        const isComplexTask = this.isComplexTask(parsedTask);
+        // 情况1: 没有 goals，但有复杂内容 → 创建规划任务
+        if (parsedTask.goals.length === 0 && isComplexTask) {
+            return this.createPlanningTask(parsedTask, userContext, answers);
+        }
+        // 情况2: 没有 goals，但有简单内容 → 创建单个开发任务
+        if (parsedTask.goals.length === 0 && parsedTask.description) {
+            return this.createSingleTask(parsedTask, userContext, answers);
+        }
+        // 情况3: 没有 goals，也没有内容 → 返回空（无效任务）
+        if (parsedTask.goals.length === 0) {
+            return [];
+        }
+        // 情况4: 有明确的 goals → 按目标拆解
+        return this.breakdownByGoals(parsedTask, userContext, answers);
+    }
+    /**
+     * 判断是否为复杂任务
+     */
+    isComplexTask(parsedTask) {
+        const content = parsedTask.rawContent || '';
+        // 检查是否有多个 markdown sections
+        const sections = content.match(/^#{1,2}\s+/gm) || [];
+        if (sections.length >= 3)
+            return true;
+        // 检查内容长度
+        if (content.length > 500)
+            return true;
+        // 检查是否有列表项
+        const listItems = content.match(/^-\s+/gm) || [];
+        if (listItems.length >= 5)
+            return true;
+        return false;
+    }
+    /**
+     * 创建规划任务 (由 AI 智能拆解)
+     */
+    createPlanningTask(parsedTask, userContext, answers) {
+        const planningTaskId = this.generateTaskId();
+        return [{
+                taskId: planningTaskId,
+                title: `${parsedTask.title} - 需求分析与架构设计`,
+                description: `# 需求分析与架构设计
+
+## 任务背景
+${parsedTask.description || parsedTask.title}
+
+## 原始需求
+\`\`\`
+${parsedTask.rawContent}
+\`\`\`
+
+## 用户上下文
+${this.formatUserContext(userContext, answers)}
+
+## 你的任务
+作为架构师，请:
+1. 深入分析需求，理解核心功能
+2. 设计系统架构
+3. 将需求拆解为可执行的子任务
+4. 为每个子任务定义验收标准
+
+## 输出要求
+- 架构设计文档 (ARCHITECTURE.md)
+- 执行计划 (PLAN.md) - 宏观层面的计划，包含子任务清单
+- 每个子计划包含: 标题、描述、优先级、依赖关系、验收标准
+
+## 注意事项
+- 任务拆解要细粒度，每个任务应该在 2-4 小时内完成
+- 任务之间要有清晰的依赖关系
+- 考虑技术栈和约束条件`,
+                priority: 'P0',
+                dependencies: [],
+                estimatedComplexity: 'high',
+                assignedAgent: 'planner',
+                phase: 'design',
+                acceptanceCriteria: [
+                    '架构设计文档完整',
+                    '执行计划 (PLAN.md) 清晰',
+                    '每个子计划有明确的验收标准',
+                    '依赖关系明确',
+                    '技术方案可行'
+                ]
+            }];
+    }
+    /**
+     * 创建单个开发任务
+     */
+    createSingleTask(parsedTask, userContext, answers) {
+        const taskId = this.generateTaskId();
+        return [{
+                taskId,
+                title: parsedTask.title,
+                description: this.buildTaskDescription(parsedTask.description || parsedTask.title, userContext, answers),
+                priority: 'P1',
+                dependencies: [],
+                estimatedComplexity: 'medium',
+                assignedAgent: 'coder',
+                phase: 'develop',
+                acceptanceCriteria: [
+                    '功能实现完整',
+                    '代码可编译',
+                    '无严重 bug',
+                    '代码符合规范'
+                ]
+            }];
+    }
+    /**
+     * 按目标拆解任务 (原有逻辑)
+     */
+    breakdownByGoals(parsedTask, userContext, answers) {
+        const breakdowns = [];
+        const seenTitles = new Set();
+        const extractedContext = this.extractUserContext(answers);
         // 0. 设计阶段任务
         if (parsedTask.goals.length > 1) {
             breakdowns.push({
@@ -39,10 +156,10 @@ class TaskPlanner {
                 description: `分析需求，设计整体架构，规划实现方案
 
 ## 用户需求
-${userContext.objective || '未指定'}
+${extractedContext.objective || '未指定'}
 
 ## 技术栈
-${userContext.techStack?.join(', ') || '未指定'}
+${extractedContext.techStack?.join(', ') || '未指定'}
 
 ## 输出
 - 架构设计文档
@@ -237,6 +354,29 @@ ${userContext.documentationLevel}
             additionalContext: answers
         };
     }
+    /**
+     * 格式化用户上下文为字符串
+     */
+    formatUserContext(userContext, answers) {
+        const parts = [];
+        if (answers['brainstormAnswers']) {
+            parts.push('### 头脑风暴答案');
+            parts.push(answers['brainstormAnswers']);
+        }
+        if (userContext.objective) {
+            parts.push(`### 目标: ${userContext.objective}`);
+        }
+        if (userContext.techStack && userContext.techStack.length > 0) {
+            parts.push(`### 技术栈: ${userContext.techStack.join(', ')}`);
+        }
+        if (answers['insights']) {
+            parts.push(`### 洞察: ${answers['insights']}`);
+        }
+        if (answers['designNotes']) {
+            parts.push(`### 设计笔记: ${answers['designNotes']}`);
+        }
+        return parts.join('\n\n') || '无额外上下文';
+    }
     /**
      * 解析数组类型的回答
      */

package/package.json

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