openmatrix 0.1.98 → 0.2.1

package/skills/start.md

@@ -101,7 +101,8 @@ git init
 | 情况 | 处理方式 |
 |------|---------|
 | 已存在（来自 `/om:brainstorm`） | 读取文件内容 → **立即执行 Step 4 必选问题**（质量等级、E2E、执行模式） |
-| 不存在 | 根据用户输入解析 |
+| 不存在，但 `.openmatrix/research/context.json` 存在 | 读取研究上下文 → 提取 goals/constraints/deliverables → **执行 Step 4 必选问题** |
+| 均不存在 | 根据用户输入解析 |
 
 > ⚠️ **注意**: 即使 `tasks-input.json` 已存在，Step 4 必选问题仍然必须执行！
 > - 开发任务：质量等级、E2E、执行模式必须由用户选择
@@ -109,6 +110,20 @@ git init
 - `$ARGUMENTS` 为任务描述 → 直接使用
 - 无参数 → AskUserQuestion 询问任务内容
 
+**检测研究上下文（当 tasks-input.json 不存在时）:**
+
+```bash
+cat .openmatrix/research/context.json 2>/dev/null || echo "NO_RESEARCH"
+```
+
+如果检测到研究上下文：
+1. 读取 `.openmatrix/research/context.json`，提取 `topic`、`domain`、`goals`、`constraints`、`deliverables`、`reportPath`
+2. 读取 `RESEARCH.md` 内容作为领域知识
+3. 告知用户："🔬 检测到「${domain}」领域研究结果，将作为任务基础"
+4. 在 Step 6 中，AI 只需**确认/补充** goals，而非从头提取
+5. Step 7 写入 `tasks-input.json` 时，将研究 goals 与 AI 补充的 goals 合并
+6. Step 8 的 CLI 调用必须增加 `--research-context @.openmatrix/research/context.json` 参数
+
 ### Step 3: 智能分析任务类型
 
 判断是开发任务还是非开发任务，这决定 Step 4 需要问哪些问题。
@@ -124,92 +139,50 @@ git init
 
 ---
 
-## ⚠️⚠️⚠️ 以下 Step 4 不可跳过 ⚠️⚠️⚠️
+### Step 4: 必选问题（不可跳过，不可使用默认值，必须通过 AskUserQuestion 让用户选择）
 
-**无论任务类型、复杂度、大小 — Step 4 必须执行。**
-**不允许使用任何默认值。必须通过 AskUserQuestion 让用户选择。**
-**如果没有执行 Step 4 就进入 Step 5+，任务执行失败。**
+根据 `goalTypes` 字段判断需要询问哪些问题：
 
-### Step 4: 必选问题（不可跳过）
+| goalTypes | 需要询问 |
+|-----------|---------|
+| `development` | 4.1 质量等级 → 4.2 E2E → 4.3 执行模式 |
+| `testing` | 仅 4.3 执行模式 |
+| `documentation` / `other` | 仅 4.3 执行模式 |
 
-**根据任务类型选择需要询问的问题：**
+#### 4.1 质量等级（仅 `goalTypes: development`）
 
-| 任务类型 | 需要询问的问题 |
-|---------|---------------|
-| **开发任务**（新功能、Bug修复、重构） | 4.1 质量等级 + 4.2 E2E + 4.3 执行模式 |
-| **测试任务**（纯测试、写测试用例） | 仅 4.3 执行模式 |
-| **非开发任务**（文档、配置、纯阅读） | 仅 4.3 执行模式 |
+AskUserQuestion: `header: "质量等级"`, `multiSelect: false`
 
-**判断依据：** 查看 Step 6 生成的 `tasks-input.json` 中的 `goalTypes` 字段：
-- `development` → 开发任务 → 问 4.1 + 4.2 + 4.3
-- `testing` → 测试任务 → 仅问 4.3
-- `documentation` / `other` → 非开发任务 → 仅问 4.3
+**question:** 选择质量等级（决定测试覆盖、Lint、安全扫描等要求）
 
-**⚠️ 以下问题不可跳过，不可使用默认值：**
+| label | description |
+|-------|-------------|
+| `strict` | TDD + >80%覆盖率 + 严格Lint + 安全扫描 — 生产级代码 |
+| `balanced (推荐)` | >60%覆盖率 + Lint + 安全扫描 — 日常开发 |
+| `fast` | 无质量门禁 — 快速原型/验证 |
 
-#### 4.1 质量等级（仅开发任务，测试/文档任务跳过）
+#### 4.2 E2E 测试（仅 `development` 且选 strict/balanced，选 `fast` 跳过）
 
-如果是代码开发任务（`goalTypes` 包含 `development`），必须询问：
+AskUserQuestion: `header: "E2E 测试"`, `multiSelect: false`
 
-```typescript
-AskUserQuestion({
-  questions: [
-    {
-      question: "选择质量等级（决定测试覆盖、Lint、安全扫描等要求）:",
-      header: "质量等级",
-      options: [
-        { label: "strict", description: "TDD + >80%覆盖率 + 严格Lint + 安全扫描 — 生产级代码" },
-        { label: "balanced (推荐)", description: ">60%覆盖率 + Lint + 安全扫描 — 日常开发" },
-        { label: "fast", description: "无质量门禁 — 快速原型/验证" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
-
-#### 4.2 E2E 测试（仅开发任务且选 strict/balanced 时）
-
-如果开发任务且用户选择了 `strict` 或 `balanced`，继续询问:
-
-```typescript
-AskUserQuestion({
-  questions: [
-    {
-      question: "是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）",
-      header: "E2E 测试",
-      options: [
-        { label: "启用 E2E 测试", description: "使用 Playwright/Cypress 等框架进行端到端测试" },
-        { label: "不启用 (推荐)", description: "仅进行单元测试和集成测试，节省时间" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
+**question:** 是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）
 
-**注意:** 如果用户选择 `fast` 质量等级，跳过 E2E 问题（fast 模式不启用 E2E）。
+| label | description |
+|-------|-------------|
+| `不启用 (推荐)` | 仅进行单元测试和集成测试，节省时间 |
+| `启用 E2E 测试` | 使用 Playwright/Cypress 等框架进行端到端测试 |
 
 #### 4.3 执行模式（所有任务必选）
 
-**无论开发还是非开发任务，都必须询问：**
+AskUserQuestion: `header: "执行模式"`, `multiSelect: false`
 
-```typescript
-AskUserQuestion({
-  questions: [
-    {
-      question: "选择执行模式（控制 AI 执行过程中的审批节点）:",
-      header: "执行模式",
-      options: [
-        { label: "全自动执行 (推荐)", description: "全自动执行，无需人工审批，遇到阻塞自动 Meeting" },
-        { label: "关键节点确认", description: "plan/merge/deploy 时暂停确认" },
-        { label: "每阶段确认", description: "每个阶段（develop/verify/accept）完成后暂停" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
+**question:** 选择执行模式（控制 AI 执行过程中的审批节点）
+
+| label | description |
+|-------|-------------|
+| `全自动执行 (推荐)` | 全自动执行，无需人工审批，遇到阻塞自动 Meeting |
+| `关键节点确认` | plan/merge/deploy 时暂停确认 |
+| `每阶段确认` | 每个阶段（develop/verify/accept）完成后暂停 |
 
 ### Step 5: 可选问题（仅复杂任务）
 
@@ -245,6 +218,8 @@ AskUserQuestion({
 - **deliverables**: 交付物列表
 - **plan**: 技术方案、模块划分、接口设计、关键决策
 
+**研究上下文集成**: 如果已加载研究领域，AI 应基于 `RESEARCH.md` 中的领域知识确认/补充 goals，而非从零提取。`plan` 字段应包含领域技术栈、架构模式等知识。
+
 **goalTypes 标注示例：**
 
 | Goal | Type | 理由 |
@@ -273,6 +248,7 @@ AskUserQuestion({
 
 > **注意**: `quality`、`mode`、`e2eTests` 不写入文件，由 Step 8 的 CLI 参数传递。
 > **goalTypes** 必须与 goals 数组长度一致，一一对应。
+> **研究上下文集成**: 如果检测到 `.openmatrix/research/context.json`，将研究的 goals/constraints/deliverables 作为基础，与 AI 提取的内容合并（去重后）。
 
 ### Step 8: 调用 CLI 创建任务 ⚠️ 不可跳过
 
@@ -283,6 +259,11 @@ AskUserQuestion({
 openmatrix start --tasks-json @.openmatrix/tasks-input.json --quality <质量等级> --mode <执行模式> --json
 ```
 
+如果存在 `.openmatrix/research/context.json`，增加 `--research-context` 参数：
+```bash
+openmatrix start --tasks-json @.openmatrix/tasks-input.json --research-context @.openmatrix/research/context.json --quality <质量等级> --mode <执行模式> --json
+```
+
 如果启用了 E2E 测试，加上 `--e2e-tests`：
 ```bash
 openmatrix start --tasks-json @.openmatrix/tasks-input.json --quality balanced --mode auto --e2e-tests --json
@@ -376,31 +357,16 @@ openmatrix step --json
 
 **交互式审批流程（非全自动模式）:**
 
-当到达审批点时，使用 `openmatrix approve --json`（不带 ID）查看待审批项，然后通过 AskUserQuestion 请求用户确认:
+当到达审批点时，使用 `openmatrix approve --json`（不带 ID）查看待审批项，**先在界面展示审批内容摘要**，再用简短 AskUserQuestion 请求确认:
 
-```typescript
-// 检查是否有待审批项
-// 通过 CLI: openmatrix approve --json  (不带 approvalId 时返回列表)
-
-AskUserQuestion({
-  questions: [
-    {
-      question: "审批请求: [审批类型]
-
-[审批内容摘要]
-
-是否批准?",
-      header: "审批",
-      options: [
-        { label: "批准", description: "同意继续执行" },
-        { label: "拒绝", description: "拒绝并停止执行" },
-        { label: "查看详情", description: "查看完整审批内容后再决定" }
-      ],
-      multiSelect: false
-    }
-  ]
-})
-```
+AskUserQuestion: `header: "审批"`, `multiSelect: false`
+**question:** 是否批准此审批请求？（详情已展示在上方）
+
+| label | description |
+|-------|-------------|
+| 批准 | 同意继续执行 |
+| 拒绝 | 拒绝并停止执行 |
+| 查看详情 | 查看完整审批内容后再决定 |
 
 用户选择后，执行对应命令:
 - 批准: `openmatrix approve <approval-id> -d approve --json`

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

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

package/dist/cli/commands/upgrade.js

@@ -1,329 +0,0 @@
-"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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upgradeCommand = void 0;
-// src/cli/commands/upgrade.ts
-const commander_1 = require("commander");
-const upgrade_detector_js_1 = require("../../orchestrator/upgrade-detector.js");
-const readline = __importStar(require("readline"));
-const chalk_1 = __importDefault(require("chalk"));
-exports.upgradeCommand = new commander_1.Command('upgrade')
-    .description('自动检测项目可改进点并提供升级建议')
-    .argument('[hint]', '用户提示 (可选，用于聚焦检测方向)')
-    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
-    .option('--auto', '自动执行所有改进建议 (无需确认)')
-    .option('--categories <items>', '指定检测类别 (逗号分隔)', 'bug,quality,capability,ux,style,security,common')
-    .option('--min-priority <level>', '最小优先级 (critical|high|medium|low)', 'low')
-    .option('--max <number>', '最大建议数量', '50')
-    .option('--scan <dirs>', '扫描目录 (逗号分隔)', 'src,skills,tests,docs')
-    .option('--interactive', '交互式选择要执行的改进', false)
-    .action(async (hint, options) => {
-    const projectRoot = process.cwd();
-    // 解析配置
-    const config = {
-        userHint: hint,
-        categories: options.categories.split(',').map((c) => c.trim()),
-        minPriority: options.minPriority,
-        maxSuggestions: parseInt(options.max),
-        scanDirs: options.scan.split(',').map((d) => d.trim())
-    };
-    // 创建检测器
-    const detector = new upgrade_detector_js_1.UpgradeDetector(projectRoot, config);
-    if (!options.json) {
-        console.log(chalk_1.default.bold.cyan('\n🔍 OpenMatrix 升级检测器'));
-        console.log('━'.repeat(42));
-        console.log(`📁 项目路径: ${projectRoot}`);
-        if (hint) {
-            console.log(`💡 用户提示: ${hint}`);
-        }
-        console.log('\n⏳ 正在扫描项目...\n');
-    }
-    try {
-        // 执行检测
-        const result = await detector.detect();
-        // JSON 输出
-        if (options.json) {
-            console.log(JSON.stringify(result, null, 2));
-            return;
-        }
-        // 显示结果
-        displayResult(result);
-        // 交互式选择
-        if (options.interactive && result.suggestions.length > 0) {
-            const selected = await interactiveSelect(result.suggestions);
-            if (selected.length > 0) {
-                await executeSelected(selected, result.projectType);
-            }
-        }
-        else if (options.auto && result.suggestions.length > 0) {
-            // 自动执行所有
-            await executeAll(result.suggestions, result.projectType);
-        }
-        else if (result.suggestions.length > 0) {
-            // 询问用户
-            const shouldExecute = await askForExecution();
-            if (shouldExecute) {
-                await executeAll(result.suggestions, result.projectType);
-            }
-        }
-    }
-    catch (error) {
-        if (options.json) {
-            console.log(JSON.stringify({ error: String(error) }));
-        }
-        else {
-            console.error(chalk_1.default.red('\n❌ 检测失败:'), error);
-        }
-        process.exit(1);
-    }
-});
-/**
- * 显示检测结果
- */
-function displayResult(result) {
-    const { projectType, projectName, suggestions, summary } = result;
-    console.log(chalk_1.default.bold(`📦 项目: ${projectName}`));
-    console.log(`   类型: ${formatProjectType(projectType)}`);
-    console.log(`   扫描时间: ${new Date(result.timestamp).toLocaleString()}\n`);
-    // 摘要
-    console.log(chalk_1.default.bold('📊 检测摘要'));
-    console.log('━'.repeat(42));
-    const categoryLabels = {
-        bug: '🐛 代码缺陷',
-        quality: '🔧 代码质量',
-        capability: '📦 缺失能力',
-        ux: '👤 用户体验',
-        style: '🎨 代码风格',
-        security: '🔒 安全问题',
-        common: '⚠️ 常见问题',
-        prompt: '🤖 Prompt 问题',
-        skill: '⚡ Skill 问题',
-        agent: '🧠 Agent 配置'
-    };
-    for (const [cat, count] of Object.entries(summary.byCategory)) {
-        if (count > 0) {
-            console.log(`   ${categoryLabels[cat]}: ${chalk_1.default.yellow(count)}`);
-        }
-    }
-    console.log(`\n   总计: ${chalk_1.default.bold(summary.total)} 个建议`);
-    console.log(`   可自动修复: ${chalk_1.default.green(summary.autoFixable)} 个\n`);
-    if (suggestions.length === 0) {
-        console.log(chalk_1.default.green('✅ 未发现问题，项目状态良好！\n'));
-        return;
-    }
-    // 详细建议
-    console.log(chalk_1.default.bold('📋 改进建议'));
-    console.log('━'.repeat(42) + '\n');
-    // 按优先级分组
-    const critical = suggestions.filter(s => s.priority === 'critical');
-    const high = suggestions.filter(s => s.priority === 'high');
-    const medium = suggestions.filter(s => s.priority === 'medium');
-    const low = suggestions.filter(s => s.priority === 'low');
-    if (critical.length > 0) {
-        console.log(chalk_1.default.red.bold('🚨 关键问题:\n'));
-        for (const s of critical) {
-            displaySuggestion(s);
-        }
-    }
-    if (high.length > 0) {
-        console.log(chalk_1.default.yellow.bold('⚠️ 高优先级:\n'));
-        for (const s of high) {
-            displaySuggestion(s);
-        }
-    }
-    if (medium.length > 0) {
-        console.log(chalk_1.default.blue.bold('📋 中优先级:\n'));
-        for (const s of medium) {
-            displaySuggestion(s);
-        }
-    }
-    if (low.length > 0) {
-        console.log(chalk_1.default.gray.bold('💡 低优先级:\n'));
-        for (const s of low.slice(0, 10)) { // 限制显示
-            displaySuggestion(s);
-        }
-        if (low.length > 10) {
-            console.log(chalk_1.default.gray(`   ... 还有 ${low.length - 10} 个低优先级建议\n`));
-        }
-    }
-    // 提示
-    console.log(chalk_1.default.gray('━'.repeat(42)));
-    console.log(chalk_1.default.gray('💡 提示:'));
-    console.log(chalk_1.default.gray('   --interactive  交互式选择改进项'));
-    console.log(chalk_1.default.gray('   --auto         自动执行所有改进'));
-    console.log();
-}
-/**
- * 显示单个建议
- */
-function displaySuggestion(s) {
-    const priorityColors = {
-        critical: chalk_1.default.red,
-        high: chalk_1.default.yellow,
-        medium: chalk_1.default.blue,
-        low: chalk_1.default.gray
-    };
-    const categoryIcons = {
-        bug: '🐛',
-        quality: '🔧',
-        capability: '📦',
-        ux: '👤',
-        style: '🎨',
-        security: '🔒',
-        common: '⚠️',
-        prompt: '🤖',
-        skill: '⚡',
-        agent: '🧠'
-    };
-    const color = priorityColors[s.priority];
-    console.log(`  ${color(`[${s.id}]`)} ${categoryIcons[s.category]} ${s.title}`);
-    console.log(`      位置: ${s.location.file}${s.location.line ? `:${s.location.line}` : ''}`);
-    console.log(`      建议: ${chalk_1.default.gray(s.suggestion)}`);
-    if (s.autoFixable) {
-        console.log(`      ${chalk_1.default.green('✓ 可自动修复')}`);
-    }
-    console.log();
-}
-/**
- * 格式化项目类型
- */
-function formatProjectType(type) {
-    const labels = {
-        openmatrix: '🤖 OpenMatrix',
-        'ai-project': '🧠 AI 项目',
-        nodejs: '📦 Node.js',
-        typescript: '📘 TypeScript',
-        python: '🐍 Python',
-        go: '🔷 Go',
-        rust: '🦀 Rust',
-        java: '☕ Java',
-        csharp: '💜 C#',
-        cpp: '⚙️ C/C++',
-        php: '🐘 PHP',
-        unknown: '❓ 未知'
-    };
-    return labels[type];
-}
-/**
- * 交互式选择
- */
-async function interactiveSelect(suggestions) {
-    console.log(chalk_1.default.bold.cyan('\n🎯 交互式选择'));
-    console.log('━'.repeat(42));
-    console.log('选择要执行的改进项 (空格选择，回车确认):\n');
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    // 显示选项
-    suggestions.forEach((s, i) => {
-        console.log(`  [ ] ${i + 1}. ${s.title} (${s.priority})`);
-    });
-    console.log('\n输入序号 (用逗号分隔)，或输入 "all" 选择全部:');
-    return new Promise((resolve) => {
-        rl.question('> ', (answer) => {
-            rl.close();
-            if (answer.trim().toLowerCase() === 'all') {
-                resolve(suggestions);
-                return;
-            }
-            const indices = answer.split(',')
-                .map(s => parseInt(s.trim()) - 1)
-                .filter(i => i >= 0 && i < suggestions.length);
-            resolve(indices.map(i => suggestions[i]));
-        });
-    });
-}
-/**
- * 询问是否执行
- */
-async function askForExecution() {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    return new Promise((resolve) => {
-        rl.question('\n是否执行这些改进? (y/N) ', (answer) => {
-            rl.close();
-            resolve(answer.trim().toLowerCase() === 'y');
-        });
-    });
-}
-/**
- * 执行选中的改进
- */
-async function executeSelected(suggestions, projectType) {
-    console.log(chalk_1.default.bold.cyan('\n🚀 执行改进'));
-    console.log('━'.repeat(42));
-    console.log(`选择了 ${suggestions.length} 个改进项\n`);
-    // 这里需要调用 /om:start 来执行实际的改进
-    // 输出 JSON 格式供 Skill 解析
-    console.log(JSON.stringify({
-        action: 'execute_upgrades',
-        projectType,
-        suggestions: suggestions.map(s => ({
-            id: s.id,
-            title: s.title,
-            category: s.category,
-            priority: s.priority,
-            location: s.location,
-            suggestion: s.suggestion
-        }))
-    }, null, 2));
-}
-/**
- * 执行所有改进
- */
-async function executeAll(suggestions, projectType) {
-    console.log(chalk_1.default.bold.cyan('\n🚀 自动执行所有改进'));
-    console.log('━'.repeat(42));
-    // 输出 JSON 供 Skill 处理
-    console.log(JSON.stringify({
-        action: 'execute_all_upgrades',
-        projectType,
-        count: suggestions.length,
-        suggestions: suggestions.map(s => ({
-            id: s.id,
-            title: s.title,
-            category: s.category,
-            priority: s.priority,
-            location: s.location,
-            suggestion: s.suggestion
-        }))
-    }, null, 2));
-}

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

@@ -1,87 +0,0 @@
-import type { ParsedTask } from '../types/index.js';
-export interface TaskBreakdown {
-    taskId: string;
-    title: string;
-    description: string;
-    priority: 'P0' | 'P1' | 'P2' | 'P3';
-    dependencies: string[];
-    estimatedComplexity: 'low' | 'medium' | 'high';
-    assignedAgent: 'planner' | 'coder' | 'tester' | 'reviewer' | 'researcher' | 'executor';
-    acceptanceCriteria?: string[];
-    testTaskId?: string;
-    phase: 'design' | 'develop' | 'verify' | 'accept';
-}
-export interface UserAnswers {
-    objective?: string;
-    techStack?: string[];
-    testCoverage?: string;
-    documentationLevel?: string;
-    additionalContext?: Record<string, string>;
-    /** 是否启用 E2E 测试 */
-    e2eTests?: boolean;
-    /** E2E 测试类型 (web/mobile/gui) */
-    e2eType?: 'web' | 'mobile' | 'gui';
-}
-/**
- * TaskPlanner - 任务拆解器
- *
- * 增强版特性:
- * 1. 更细粒度的任务拆分 (每个目标拆分为设计+实现+测试)
- * 2. 测试任务配对 (每个开发任务自动生成对应测试任务)
- * 3. 验收标准注入 (从用户回答中提取)
- * 4. 用户上下文注入 (将用户回答注入任务描述)
- * 5. 依赖关系分析 (自动分析任务间依赖)
- */
-export declare class TaskPlanner {
-    private userAnswers;
-    constructor(userAnswers?: UserAnswers);
-    /**
-     * 设置用户回答
-     */
-    setUserAnswers(answers: UserAnswers): void;
-    /**
-     * Break down a parsed task into sub-tasks
-     *
-     * 增强版: 生成更细粒度的任务，包含设计、开发、测试配对
-     */
-    breakdown(parsedTask: ParsedTask, answers: Record<string, string>): TaskBreakdown[];
-    /**
-     * 提取用户上下文
-     */
-    private extractUserContext;
-    /**
-     * 解析数组类型的回答
-     */
-    private parseArrayAnswer;
-    /**
-     * 构建任务描述 (注入用户上下文)
-     */
-    private buildTaskDescription;
-    /**
-     * 构建测试任务描述
-     */
-    private buildTestDescription;
-    /**
-     * 构建 E2E 测试任务描述
-     */
-    private buildE2ETestDescription;
-    /**
-     * 获取 E2E 测试类型配置
-     */
-    private getE2ETypeConfig;
-    /**
-     * 生成用户流程测试用例
-     */
-    private generateUserFlows;
-    /**
-     * 解析覆盖率数值
-     */
-    private parseCoverage;
-    /**
-     * 生成验收标准
-     */
-    private generateAcceptanceCriteria;
-    private generateTaskId;
-    private determinePriority;
-    private estimateComplexity;
-}