openmatrix 0.2.6 → 0.2.7

package/dist/cli/commands/brainstorm.js

@@ -34,6 +34,20 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.brainstormCommand = void 0;
+exports.handleCompleteMode = handleCompleteMode;
+exports.mergeSessionResults = mergeSessionResults;
+exports.outputCompleteResult = outputCompleteResult;
+exports.outputSessionNotFound = outputSessionNotFound;
+exports.loadTaskContent = loadTaskContent;
+exports.loadTaskFromDefaultFile = loadTaskFromDefaultFile;
+exports.loadTaskFromSpecifiedFile = loadTaskFromSpecifiedFile;
+exports.extractTaskTitle = extractTaskTitle;
+exports.createNewSession = createNewSession;
+exports.outputNewSession = outputNewSession;
+exports.outputNewSessionJson = outputNewSessionJson;
+exports.outputNewSessionText = outputNewSessionText;
+exports.buildSmartQuestionSession = buildSmartQuestionSession;
+exports.convertToBrainstormQuestions = convertToBrainstormQuestions;
 // src/cli/commands/brainstorm.ts
 const commander_1 = require("commander");
 const state_manager_js_1 = require("../../storage/state-manager.js");
@@ -58,132 +72,177 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
     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;
-        }
+        await handleCompleteMode(brainstormPath, options);
+        return;
     }
     // 获取任务内容
+    const taskContent = await loadTaskContent(input, basePath, options);
+    if (!taskContent)
+        return;
+    // 创建新的头脑风暴会话
+    await createNewSession(taskContent, basePath, brainstormPath, options);
+});
+/**
+ * 处理 --complete 模式：标记头脑风暴完成，输出 start 所需信息
+ */
+async function handleCompleteMode(brainstormPath, options) {
+    try {
+        const sessionData = await fs.readFile(brainstormPath, 'utf-8');
+        const session = JSON.parse(sessionData);
+        session.status = 'ready_to_start';
+        mergeSessionResults(session, options.results);
+        await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
+        outputCompleteResult(session, options.json);
+    }
+    catch {
+        outputSessionNotFound(options.json);
+    }
+}
+/**
+ * 合并外部传入的结果到已有会话
+ */
+function mergeSessionResults(session, resultsJson) {
+    if (!resultsJson)
+        return;
+    try {
+        const results = JSON.parse(resultsJson);
+        session.answers = { ...session.answers, ...results.answers };
+        session.insights = [...session.insights, ...(results.insights || [])];
+        session.designNotes = [...session.designNotes, ...(results.designNotes || [])];
+    }
+    catch {
+        // 忽略解析错误
+    }
+}
+/**
+ * 输出 complete 模式的结果
+ */
+function outputCompleteResult(session, jsonMode) {
+    if (jsonMode) {
+        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 开始执行任务');
+    }
+}
+/**
+ * 输出会话未找到的错误信息
+ */
+function outputSessionNotFound(jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify({
+            status: 'error',
+            message: '没有进行中的头脑风暴会话'
+        }));
+    }
+    else {
+        console.log('❌ 没有进行中的头脑风暴会话');
+        console.log('   使用 openmatrix brainstorm <task> 开始新的头脑风暴');
+    }
+}
+/**
+ * 从输入参数或文件加载任务内容，返回 null 表示加载失败（已输出错误）
+ */
+async function loadTaskContent(input, basePath, options) {
     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}`);
-            }
+        return loadTaskFromDefaultFile(basePath, options.json);
+    }
+    else if (taskContent.endsWith('.md')) {
+        return loadTaskFromSpecifiedFile(taskContent, input, options.json);
+    }
+    return taskContent;
+}
+/**
+ * 从默认 TASK.md 文件加载任务内容
+ */
+async function loadTaskFromDefaultFile(basePath, jsonMode) {
+    const defaultPath = path.join(basePath, 'TASK.md');
+    try {
+        const content = await fs.readFile(defaultPath, 'utf-8');
+        if (!jsonMode) {
+            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;
+        return content;
+    }
+    catch {
+        if (jsonMode) {
+            console.log(JSON.stringify({ status: 'error', message: '请提供任务文件路径或描述' }));
+        }
+        else {
+            console.log('❌ 请提供任务文件路径或描述');
+            console.log('   用法: openmatrix brainstorm <task.md>');
+            console.log('   或创建 TASK.md 文件');
         }
+        return null;
     }
-    else if (taskContent.endsWith('.md')) {
-        try {
-            taskContent = await fs.readFile(taskContent, 'utf-8');
-            if (!options.json) {
-                console.log(`📄 读取任务文件: ${input}`);
-            }
+}
+/**
+ * 从用户指定的 .md 文件加载任务内容
+ */
+async function loadTaskFromSpecifiedFile(filePath, displayName, jsonMode) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (!jsonMode) {
+            console.log(`📄 读取任务文件: ${displayName}`);
         }
-        catch {
-            if (options.json) {
-                console.log(JSON.stringify({
-                    status: 'error',
-                    message: `无法读取文件: ${input}`
-                }));
-            }
-            else {
-                console.log(`❌ 无法读取文件: ${input}`);
-            }
-            return;
+        return content;
+    }
+    catch {
+        if (jsonMode) {
+            console.log(JSON.stringify({ status: 'error', message: `无法读取文件: ${displayName}` }));
         }
+        else {
+            console.log(`❌ 无法读取文件: ${displayName}`);
+        }
+        return null;
     }
-    // 从任务内容提取标题
+}
+/**
+ * 从任务内容中提取标题
+ */
+function extractTaskTitle(taskContent) {
     const lines = taskContent.split('\n');
-    let taskTitle = '未命名任务';
     for (const line of lines) {
         const match = line.match(/^#\s+(.+)$/);
         if (match) {
-            taskTitle = match[1].trim();
-            break;
+            return match[1].trim();
         }
     }
-    // 生成头脑风暴问题 — 使用智能管道
+    return '未命名任务';
+}
+/**
+ * 创建新的头脑风暴会话并输出
+ */
+async function createNewSession(taskContent, basePath, brainstormPath, options) {
+    const taskTitle = extractTaskTitle(taskContent);
     const questions = await generateSmartQuestions(taskContent, basePath);
-    // 检测是否涉及垂直领域
     const domainDetection = detectVerticalDomain(taskContent);
-    // 创建会话
     const session = {
         status: 'brainstorming',
         taskInput: taskContent,
@@ -195,42 +254,58 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
         suggestResearch: domainDetection.isVertical ? domainDetection.domain : undefined
     };
     await fs.writeFile(brainstormPath, JSON.stringify(session, null, 2));
-    if (options.json) {
-        // JSON 输出供 Skill 解析
-        const output = {
-            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'
-        };
-        // 如果检测到垂直领域，添加建议
-        if (domainDetection.isVertical) {
-            output.suggestResearch = domainDetection.domain;
-            output.researchHint = `检测到垂直领域「${domainDetection.domain}」，建议先进行领域调研`;
-        }
-        console.log(JSON.stringify(output));
+    outputNewSession(taskTitle, questions, domainDetection, options.json);
+}
+/**
+ * 输出新头脑风暴会话的信息
+ */
+function outputNewSession(taskTitle, questions, domainDetection, jsonMode) {
+    if (jsonMode) {
+        outputNewSessionJson(taskTitle, questions, domainDetection);
     }
     else {
-        console.log('\n🧠 开始头脑风暴...\n');
-        console.log(`📋 任务: ${taskTitle}\n`);
-        if (domainDetection.isVertical) {
-            console.log(`🔍 检测到垂直领域: ${domainDetection.domain}`);
-            console.log('   建议使用 /om:research 进行领域调研\n');
-        }
-        console.log('需要探索以下问题:');
-        questions.forEach((q, i) => {
-            console.log(`  ${i + 1}. ${q.question}`);
-        });
-        console.log('\n💡 使用 /om:brainstorm 技能进行交互式问答');
+        outputNewSessionText(taskTitle, questions, domainDetection);
     }
-});
+}
+/**
+ * JSON 模式输出新会话信息
+ */
+function outputNewSessionJson(taskTitle, questions, domainDetection) {
+    const output = {
+        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'
+    };
+    if (domainDetection.isVertical) {
+        output.suggestResearch = domainDetection.domain;
+        output.researchHint = `检测到垂直领域「${domainDetection.domain}」，建议先进行领域调研`;
+    }
+    console.log(JSON.stringify(output));
+}
+/**
+ * 文本模式输出新会话信息
+ */
+function outputNewSessionText(taskTitle, questions, domainDetection) {
+    console.log('\n🧠 开始头脑风暴...\n');
+    console.log(`📋 任务: ${taskTitle}\n`);
+    if (domainDetection.isVertical) {
+        console.log(`🔍 检测到垂直领域: ${domainDetection.domain}`);
+        console.log('   建议使用 /om:research 进行领域调研\n');
+    }
+    console.log('需要探索以下问题:');
+    questions.forEach((q, i) => {
+        console.log(`  ${i + 1}. ${q.question}`);
+    });
+    console.log('\n💡 使用 /om:brainstorm 技能进行交互式问答');
+}
 /**
  * 检测是否可能需要领域调研
  * 不硬编码领域，只判断是否像垂直领域任务
@@ -268,8 +343,24 @@ function detectVerticalDomain(taskContent) {
 function generateBrainstormQuestions(taskContent, taskTitle) {
     const questions = [];
     const content = taskContent.toLowerCase();
-    // 问题 1: 核心目标
-    questions.push({
+    questions.push(createCoreObjectiveQuestion());
+    questions.push(createUserValueQuestion());
+    if (content.includes('架构') || content.includes('系统') || content.includes('集成') || content.includes('多个')) {
+        questions.push(createComplexityQuestion());
+    }
+    if (content.includes('技术') || content.includes('框架') || content.includes('库')) {
+        questions.push(createTechConstraintsQuestion());
+    }
+    questions.push(createRisksQuestion());
+    questions.push(createAcceptanceQuestion());
+    questions.push(createPriorityQuestion());
+    questions.push(createQualityQuestion());
+    questions.push(createExecutionModeQuestion());
+    questions.push(createE2ETestsQuestion());
+    return questions;
+}
+function createCoreObjectiveQuestion() {
+    return {
         id: 'core_objective',
         question: '这个任务的核心目标是什么？想要解决什么问题？',
         header: '核心目标',
@@ -281,9 +372,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: false,
         why: '明确核心目标有助于选择正确的实现策略和质量标准'
-    });
-    // 问题 2: 用户价值
-    questions.push({
+    };
+}
+function createUserValueQuestion() {
+    return {
         id: 'user_value',
         question: '这个任务为用户带来什么价值？最终用户是谁？',
         header: '用户价值',
@@ -295,41 +387,40 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         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({
+    };
+}
+function createComplexityQuestion() {
+    return {
+        id: 'complexity',
+        question: '这个任务的实现复杂度如何？需要哪些关键组件？',
+        header: '复杂度',
+        options: [
+            { label: '简单', description: '单一功能，少量代码修改' },
+            { label: '中等', description: '需要多个组件协作，有依赖关系' },
+            { label: '复杂', description: '涉及架构调整，需要仔细规划' },
+            { label: '非常复杂', description: '大型重构或新系统，需要分阶段实施' }
+        ],
+        multiSelect: false,
+        why: '复杂度评估有助于决定是否需要分阶段实施和额外的设计审查'
+    };
+}
+function createTechConstraintsQuestion() {
+    return {
+        id: 'tech_constraints',
+        question: '有哪些技术约束或偏好？需要使用/避免什么技术？',
+        header: '技术约束',
+        options: [
+            { label: '使用现有技术栈', description: '复用项目已有的技术选择' },
+            { label: '引入新技术', description: '需要引入新的库或框架' },
+            { label: '保持技术中立', description: '不引入新依赖，使用原生方案' },
+            { label: '需要技术调研', description: '技术选型不确定，需要先调研' }
+        ],
+        multiSelect: false,
+        why: '技术约束影响实现方案和后续维护成本'
+    };
+}
+function createRisksQuestion() {
+    return {
         id: 'risks',
         question: '这个任务可能面临哪些风险或挑战？',
         header: '风险',
@@ -341,9 +432,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: true,
         why: '识别风险有助于提前规划应对策略'
-    });
-    // 问题 6: 验收标准
-    questions.push({
+    };
+}
+function createAcceptanceQuestion() {
+    return {
         id: 'acceptance',
         question: '如何判断任务完成？有哪些验收标准？',
         header: '验收标准',
@@ -355,9 +447,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: true,
         why: '明确的验收标准有助于判断任务完成度'
-    });
-    // 问题 7: 实现优先级
-    questions.push({
+    };
+}
+function createPriorityQuestion() {
+    return {
         id: 'priority',
         question: '这个任务的优先级如何？是否需要 MVP 版本？',
         header: '优先级',
@@ -369,9 +462,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: false,
         why: '优先级决定资源分配和实施策略'
-    });
-    // 问题 8: 质量级别
-    questions.push({
+    };
+}
+function createQualityQuestion() {
+    return {
         id: 'quality',
         question: '选择质量门禁级别（决定测试覆盖、Lint、安全扫描等要求）',
         header: '质量级别',
@@ -382,9 +476,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: false,
         why: '质量级别影响任务拆分、测试要求和执行时间'
-    });
-    // 问题 9: 执行模式
-    questions.push({
+    };
+}
+function createExecutionModeQuestion() {
+    return {
         id: 'execution_mode',
         question: '选择执行模式（控制 AI 执行过程中的审批节点）',
         header: '执行模式',
@@ -395,10 +490,10 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: false,
         why: '执行模式决定自动化程度和人工干预频率'
-    });
-    // 问题 10: E2E 测试（必填）
-    // E2E 测试是必问问题，由用户在问答中选择是否启用
-    questions.push({
+    };
+}
+function createE2ETestsQuestion() {
+    return {
         id: 'e2e_tests',
         question: '是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）',
         header: 'E2E 测试',
@@ -408,54 +503,57 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         ],
         multiSelect: false,
         why: 'E2E 测试能验证完整用户流程，但增加执行时间'
-    });
-    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: ''
-        }));
-        // 7. 追加领域分析问题（底层逻辑思考）
-        const domainQuestions = generateDomainAnalysisQuestions(taskContent);
-        questions.push(...domainQuestions);
+        const session = await buildSmartQuestionSession(taskContent, basePath);
+        const questions = convertToBrainstormQuestions(session);
+        questions.push(...generateDomainAnalysisQuestions(taskContent));
         return questions;
     }
     catch (error) {
-        // Fallback: 如果智能管道出错，使用静态问题
         console.error(`⚠️ 智能问题生成失败，使用静态问题: ${error instanceof Error ? error.message : error}`);
         return generateBrainstormQuestions(taskContent, '');
     }
 }
+/**
+ * 构建智能问题会话：解析任务 → 分析推断 → 生成问题
+ */
+async function buildSmartQuestionSession(taskContent, basePath) {
+    const parser = new task_parser_js_1.TaskParser();
+    const parsedTask = parser.parse(taskContent);
+    const analyzer = new smart_question_analyzer_js_1.SmartQuestionAnalyzer(basePath);
+    const analysisResult = await analyzer.analyze(taskContent, parsedTask);
+    const inferenceMap = (0, answer_mapper_js_1.translateAnalyzerInferences)(analysisResult.inferences);
+    const questionGen = new interactive_question_generator_js_1.InteractiveQuestionGenerator();
+    questionGen.setInferences(inferenceMap);
+    const session = questionGen.startSession(parsedTask);
+    questionGen.addContextualQuestions(parsedTask, session.questions);
+    return session;
+}
+/**
+ * 将智能会话问题转换为 BrainstormQuestion[] 格式
+ */
+function convertToBrainstormQuestions(session) {
+    return 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: ''
+    }));
+}
 /**
  * 领域分析问题 — 底层逻辑思考
  *
@@ -467,11 +565,16 @@ async function generateSmartQuestions(taskContent, basePath) {
  */
 function generateDomainAnalysisQuestions(taskContent) {
     const questions = [];
-    const content = taskContent.toLowerCase();
-    // ===== 问题 1: 领域实体建模 =====
+    questions.push(createDomainEntitiesQuestion(taskContent));
+    questions.push(createDataFlowQuestion());
+    questions.push(createInvariantsQuestion());
+    questions.push(createCoreScenariosQuestion());
+    return questions;
+}
+function createDomainEntitiesQuestion(taskContent) {
     const entityHints = extractEntities(taskContent);
     if (entityHints.length > 0) {
-        questions.push({
+        return {
             id: 'domain_entities',
             question: `从任务描述中识别到以下核心实体，请确认或补充：\n${entityHints.map(e => `  • ${e}`).join('\n')}`,
             header: '领域实体',
@@ -482,25 +585,24 @@ function generateDomainAnalysisQuestions(taskContent) {
             ],
             multiSelect: false,
             why: '明确领域实体是设计数据模型和 API 的基础'
-        });
-    }
-    else {
-        questions.push({
-            id: 'domain_entities',
-            question: '这个系统涉及哪些核心领域实体？它们之间是什么关系？（如 用户-订单-商品）',
-            header: '领域实体',
-            options: [
-                { label: '单一实体', description: '系统围绕一个核心实体（如用户管理）' },
-                { label: '2-3 个实体', description: '少量实体间有简单关系（如用户-文章）' },
-                { label: '多实体复杂关系', description: '多个实体间有多对多等复杂关系' },
-                { label: '我来说明', description: '在"其他"中描述具体实体' }
-            ],
-            multiSelect: false,
-            why: '明确领域实体是设计数据模型和 API 的基础'
-        });
+        };
     }
-    // ===== 问题 2: 数据流分析 =====
-    questions.push({
+    return {
+        id: 'domain_entities',
+        question: '这个系统涉及哪些核心领域实体？它们之间是什么关系？（如 用户-订单-商品）',
+        header: '领域实体',
+        options: [
+            { label: '单一实体', description: '系统围绕一个核心实体（如用户管理）' },
+            { label: '2-3 个实体', description: '少量实体间有简单关系（如用户-文章）' },
+            { label: '多实体复杂关系', description: '多个实体间有多对多等复杂关系' },
+            { label: '我来说明', description: '在"其他"中描述具体实体' }
+        ],
+        multiSelect: false,
+        why: '明确领域实体是设计数据模型和 API 的基础'
+    };
+}
+function createDataFlowQuestion() {
+    return {
         id: 'data_flow',
         question: '数据在系统中如何流转？（从输入到存储到输出）',
         header: '数据流',
@@ -513,9 +615,10 @@ function generateDomainAnalysisQuestions(taskContent) {
         ],
         multiSelect: false,
         why: '数据流决定架构选型（请求驱动 vs 事件驱动 vs 流处理）'
-    });
-    // ===== 问题 3: 不变量/约束 =====
-    questions.push({
+    };
+}
+function createInvariantsQuestion() {
+    return {
         id: 'invariants',
         question: '系统中存在哪些关键不变量或业务约束？（什么条件必须永远成立）',
         header: '不变量',
@@ -527,9 +630,10 @@ function generateDomainAnalysisQuestions(taskContent) {
         ],
         multiSelect: true,
         why: '不变量决定了哪些地方需要加锁、事务、校验和防御性编程'
-    });
-    // ===== 问题 4: 核心场景链路 =====
-    questions.push({
+    };
+}
+function createCoreScenariosQuestion() {
+    return {
         id: 'core_scenarios',
         question: '从用户视角，核心操作链路是什么？（用户会走过的关键路径）',
         header: '场景链路',
@@ -542,8 +646,7 @@ function generateDomainAnalysisQuestions(taskContent) {
         ],
         multiSelect: true,
         why: '核心场景链路决定了 MVP 的功能范围和优先级排序'
-    });
-    return questions;
+    };
 }
 /**
  * 从任务描述中提取可能的领域实体