openmatrix 0.2.15 → 0.2.17

package/README.md

@@ -253,18 +253,97 @@ Accept 阶段由 Reviewer Agent 执行:
 | `/om` | **默认入口** - 直接输入任务描述即可启动 |
 | `/om:brainstorm` | 🧠 **头脑风暴** - 先探索需求和设计，再执行任务 |
 | `/om:research` | 📚 **领域调研** - AI 驱动的领域调研和问题探索 |
+| `/om:debug` | 🔧 **系统化调试** - 四阶段根因分析 + 自动修复验证循环 |
+| `/om:feature` | ⚡ **轻量小需求** - 快速迭代小功能，无完整任务追踪 |
 | `/om:start` | 启动新任务 (第一个问题选质量级别) |
 | `/om:auto` | 🚀 **全自动执行** - 无阻塞、无确认、直接完成 |
 | `/check` | 🔍 **项目检查** - 自动检测可改进点并提供升级建议 |
 | `/om:status` | 查看状态 |
 | `/om:approve` | 审批决策 |
 | `/om:meeting` | 处理阻塞问题 |
-| `/om:resume` | 恢复中断 |
+| `/om:resume` | **智能恢复** - 自动检测轻量/完整流程并恢复中断任务 |
 | `/om:retry` | 重试失败 |
 | `/om:report` | 生成报告 |
 
 > `/om` 是 `/om:start` 的快捷方式，功能完全相同
 
+### `/om:debug` 系统化调试
+
+**适用场景**: Bug 修复、测试失败、异常行为、构建失败
+
+```bash
+/om:debug                          # 交互式调试
+/om:debug --task TASK-003          # 调试指定失败任务
+/om:debug "API 返回 500 错误"      # 带问题描述调试
+```
+
+**四阶段流程**:
+
+```
+Step 1: 接收问题
+    ↓
+Step 2: CLI 初始化会话
+    ↓
+Step 3: 根因调查（只读，Explore Agent）
+    ↓
+Step 4: 模式分析（只读，Explore Agent）
+    ↓
+Step 5: 展示诊断报告
+    ↓
+    ⛔ 必须等待用户确认是否修复
+    ↓
+Step 6: 用户选择是否修复
+    ├─ "仅查看报告" → 输出报告后结束
+    ├─ "继续深入调查" → 回到 Step 3
+    └─ "需要修复" ↓
+Step 7: 选择修复策略（自动/手动）
+    ↓
+Step 8: 实施修复（Agent）
+    ↓
+Step 9: 自动验证修复（无需用户确认）
+    ├─ 验证通过 → 进入报告阶段 ✅
+    └─ 验证失败 → 自动循环重试（最多3次）
+        ├─ < 3次 → 自动回到 Step 8 重新修复
+        └─ >= 3次 → 暂停，质疑架构 ⚠️
+Step 10: 输出 Debug Report
+```
+
+**铁律**:
+- 不做根因调查，不许提修复方案
+- 验证失败自动循环，无需用户手动确认
+- 最大重试 3 次，超过必须暂停质疑架构
+
+### `/om:feature` 轻量小需求
+
+**适用场景**: 小功能、小改动、快速迭代（≤100字描述，单一功能点）
+
+```bash
+/om:feature 给用户列表页添加搜索功能
+/om:feature 添加一个导出按钮
+/om:feature docs/small-task.md
+```
+
+**触发条件**（从 `/om` 主入口自动路由）:
+- 任务描述 ≤ 100 字
+- 单一功能点（无多个独立子系统）
+- 不涉及架构设计/技术选型
+- 关键词匹配：小需求、小功能、小改动、minor、quick、快速
+
+**与标准流程对比**:
+
+| 特性 | `/om:feature` | `/om:start` |
+|------|---------------|-------------|
+| 任务文件 | ❌ 无 `.openmatrix/tasks/` | ✅ 有完整任务追踪 |
+| 问答确认 | 质量 + E2E | 质量 + E2E + 模式 |
+| 任务拆分 | AI 自动拆分 2-5 块 | Planner Agent 生成计划 |
+| Git 提交 | 分步提交（每块完成后） | 最终统一提交 |
+| 恢复机制 | `/om:resume` (自动检测) | `/om:resume` |
+
+**铁律**:
+- 不验证不得提交，验证失败必须停止
+- 每次只改一个任务块，不得并行修改
+- 验证通过后立即提交，不得积累多个任务块
+
 ### `/check` 项目检查
 
 **适用场景**: 代码质量检查、安全审计、AI 项目配置检查
@@ -497,6 +576,9 @@ cd openmatrix && npm install && npm run build && npm test
 - [x] 系统集成任务 (多模块自动组装)
 - [x] 智能项目检测 (gitignore 根据技术栈自动写入)
 - [x] Git 父级目录支持 (子目录中正常执行 git 操作)
+- [x] `/om:debug` 系统化调试 (四阶段根因分析 + 自动修复验证循环)
+- [x] `/om:feature` 轻量小需求 (快速迭代，分步 Git 提交)
+- [x] `/om:resume` 智能恢复 (自动检测轻量/完整流程)
 - [ ] VSCode 扩展
 - [ ] CI/CD 集成
 

package/dist/agents/agent-runner.d.ts

@@ -67,6 +67,10 @@ export declare class AgentRunner {
      * 构建完整的执行提示词
      */
     buildExecutionPrompt(task: Task): Promise<string>;
+    /**
+     * 构建歧义检测指令
+     */
+    private buildAmbiguityDetectionInstruction;
     /**
      * 构建累积上下文 - 从全局 context.md 读取前序 Agent 的决策和知识
      */

package/dist/agents/agent-runner.js

@@ -136,8 +136,11 @@ class AgentRunner {
         const agentPrompt = this.buildAgentPrompt(task);
         const phaseContext = this.buildPhaseContext(task);
         const accumulatedContext = await this.buildAccumulatedContext(task);
+        const ambiguityInstruction = this.buildAmbiguityDetectionInstruction(task);
         return `# 任务执行
 
+${ambiguityInstruction}
+
 ## 任务信息
 - ID: ${task.id}
 - 标题: ${task.title}
@@ -172,6 +175,89 @@ ${agentPrompt.instructions}
 注意: 任务完成后，由 Skill 调用 \`openmatrix complete\` 并传入 --summary 参数，
 该摘要会自动追加到全局 \`.openmatrix/context.md\` 供后续 Agent 参考。
 `;
+    }
+    /**
+     * 构建歧义检测指令
+     */
+    buildAmbiguityDetectionInstruction(task) {
+        return `## 🚨 歧义检测指令（必须在执行前完成）
+
+在开始执行任务之前，你必须完成歧义检测。检测以下 5 种歧义类型：
+
+### 检测清单
+
+1. **需求歧义** (requirement)
+   - 任务描述是否清晰可理解？
+   - 是否有缺少的关键信息？
+   - 验收标准是否明确？
+
+2. **技术歧义** (technical)
+   - 技术选型是否明确？
+   - 实现方案是否有多种选择？
+   - 是否需要特定的技术决策？
+
+3. **依赖歧义** (dependency)
+   - 依赖任务是否已完成？
+   - 依赖代码是否可找到？
+   - 是否有缺失的依赖项？
+
+4. **验收歧义** (acceptance)
+   - 验收标准是否明确？
+   - 成功定义是否清晰？
+   - 是否有模糊的边界条件？
+
+5. **测试结果歧义** (test_result)
+   - 测试失败原因是否明确？
+   - 测试通过是否可信？
+   - 是否需要额外的验证？
+
+### 严重程度定义
+
+| 级别 | 说明 | 处理方式 |
+|-----|------|---------|
+| **Critical** | 无法继续执行，必须澄清 | 立即报告，等待澄清 |
+| **High** | 可能导致错误结果 | 报告并建议处理方案 |
+| **Medium** | 影响执行效率 | 记录并尝试解决 |
+| **Low** | 轻微不确定性 | 继续执行，备注说明 |
+
+### 输出格式
+
+如果检测到歧义，在任务执行前输出：
+\`\`\`xml
+<ambiguity_report>
+{
+  "hasAmbiguity": true,
+  "taskId": "${task.id}",
+  "detectionPhase": "pre_execution",
+  "ambiguities": [
+    {
+      "type": "requirement|technical|dependency|acceptance|test_result",
+      "severity": "Critical|High|Medium|Low",
+      "description": "歧义描述",
+      "suggestedResolution": "建议的处理方案"
+    }
+  ],
+  "maxSeverity": "Critical|High|Medium|Low",
+  "suggestedStrategy": "ask_immediate|write_meeting|continue",
+  "detectedAt": "<ISO timestamp>"
+}
+</ambiguity_report>
+\`\`\`
+
+如果没有歧义，输出：
+\`\`\`xml
+<ambiguity_report>
+{ "hasAmbiguity": false }
+</ambiguity_report>
+\`\`\`
+
+### 处理策略
+
+- **Critical/High**: 输出报告后暂停，等待用户决策
+- **Medium**: 输出报告后继续执行，采用合理假设
+- **Low**: 记录并继续执行
+
+**重要**: 如果无法解析歧义检测结果，视为无歧义继续执行。`;
     }
     /**
      * 构建累积上下文 - 从全局 context.md 读取前序 Agent 的决策和知识

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

@@ -94,9 +94,9 @@ export declare function outputNewSessionText(taskTitle: string, questions: Brain
     domain: string;
 }): void;
 /**
- * 构建智能问题会话：解析任务 → 分析推断 → 生成问题
+ * 构建智能问题会话：解析任务 → 生成问题
  */
-export declare function buildSmartQuestionSession(taskContent: string, basePath: string): Promise<import("../../orchestrator/interactive-question-generator.js").QuestionSession>;
+export declare function buildSmartQuestionSession(taskContent: string, _basePath: string): Promise<import("../../orchestrator/interactive-question-generator.js").QuestionSession>;
 /**
  * 将智能会话问题转换为 BrainstormQuestion[] 格式
  */

package/dist/cli/commands/brainstorm.js

@@ -52,10 +52,8 @@ exports.convertToBrainstormQuestions = convertToBrainstormQuestions;
 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 logger_js_1 = require("../../utils/logger.js");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
@@ -522,16 +520,12 @@ async function generateSmartQuestions(taskContent, basePath) {
     }
 }
 /**
- * 构建智能问题会话：解析任务 → 分析推断 → 生成问题
+ * 构建智能问题会话：解析任务 → 生成问题
  */
-async function buildSmartQuestionSession(taskContent, basePath) {
+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;

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

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import type { EnvironmentInfo, DeployOption, DeployMethod, DevCommands } from '../../types/index.js';
+export declare const deployCommand: Command;
+export declare function displayEnvironmentInfo(info: EnvironmentInfo): void;
+export declare function displayDeployOptions(options: DeployOption[]): void;
+export declare function displayDevCommands(commands: DevCommands): void;
+export declare function getDeployMethodLabel(method: DeployMethod): string;
+export declare function formatDeployCommand(option: DeployOption): string;
+export declare function generateDeployCommands(info: EnvironmentInfo, method?: DeployMethod, dryRun?: boolean): Array<{
+    method: DeployMethod;
+    command: string;
+    configFile?: string;
+    description?: string;
+    dryRun: boolean;
+}>;
+export declare function selectDeployOption(options: DeployOption[], method?: DeployMethod): DeployOption | undefined;

package/dist/cli/commands/deploy.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = void 0;
+exports.displayEnvironmentInfo = displayEnvironmentInfo;
+exports.displayDeployOptions = displayDeployOptions;
+exports.displayDevCommands = displayDevCommands;
+exports.getDeployMethodLabel = getDeployMethodLabel;
+exports.formatDeployCommand = formatDeployCommand;
+exports.generateDeployCommands = generateDeployCommands;
+exports.selectDeployOption = selectDeployOption;
+// src/cli/commands/deploy.ts
+const commander_1 = require("commander");
+const environment_detector_js_1 = require("../../orchestrator/environment-detector.js");
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+exports.deployCommand = new commander_1.Command('deploy')
+    .description('输出项目环境原始数据供 Skill 分析，或执行指定部署命令')
+    .option('--json', '输出 JSON 格式原始数据（供 Skill 层 AI 分析）')
+    .option('--show-dev', '包含开发命令', false)
+    .option('--run <command>', '执行指定部署命令')
+    .option('--dry-run <command>', '预览命令但不执行')
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    // dry-run：仅显示命令
+    if (options.dryRun) {
+        console.log(chalk_1.default.bold.cyan('\n📋 命令预览 (dry-run)'));
+        console.log('━'.repeat(42));
+        console.log(chalk_1.default.white(`  ${options.dryRun}`));
+        console.log(chalk_1.default.gray('  (仅预览，不执行)'));
+        return;
+    }
+    // run：执行指定命令
+    if (options.run) {
+        console.log(chalk_1.default.bold.cyan('\n🚀 执行部署命令'));
+        console.log('━'.repeat(42));
+        console.log(chalk_1.default.white(`  ${options.run}\n`));
+        try {
+            (0, child_process_1.execSync)(options.run, { stdio: 'inherit', cwd: projectRoot });
+            console.log(chalk_1.default.green('\n✅ 命令执行完成'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('\n❌ 命令执行失败'));
+            process.exit(1);
+        }
+        return;
+    }
+    // 默认：输出原始环境数据
+    try {
+        const detector = new environment_detector_js_1.EnvironmentDetector(projectRoot);
+        const envInfo = await detector.detect();
+        if (options.json) {
+            console.log(JSON.stringify(buildRawOutput(envInfo, options.showDev), null, 2));
+            return;
+        }
+        // 非 JSON 模式：简单展示
+        displayEnvironmentInfo(envInfo);
+        displayDeployOptions(envInfo.deployOptions);
+        if (options.showDev)
+            displayDevCommands(envInfo.devCommands);
+        displayHints();
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: String(error) }));
+        }
+        else {
+            console.error(chalk_1.default.red('\n❌ 检测失败:'), error);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * 构建原始数据输出（不含任何推荐逻辑，交给 Skill 层 AI 分析）
+ */
+function buildRawOutput(envInfo, showDev) {
+    return {
+        projectName: envInfo.projectName,
+        projectType: envInfo.projectType,
+        projectRoot: envInfo.projectRoot,
+        timestamp: envInfo.timestamp,
+        buildTools: envInfo.buildTools,
+        deployOptions: envInfo.deployOptions,
+        ciConfig: envInfo.ciConfig,
+        summary: envInfo.summary,
+        devCommands: showDev ? envInfo.devCommands : undefined
+    };
+}
+function displayEnvironmentInfo(info) {
+    console.log(chalk_1.default.bold(`\n📦 项目: ${info.projectName}`));
+    console.log(`   类型: ${formatProjectType(info.projectType)}`);
+    console.log(`   路径: ${info.projectRoot}\n`);
+    console.log(chalk_1.default.bold('📊 环境摘要'));
+    console.log('━'.repeat(42));
+    console.log(`   构建工具: ${chalk_1.default.yellow(info.summary.buildToolCount)} 个`);
+    console.log(`   部署选项: ${chalk_1.default.yellow(info.summary.deployOptionCount)} 个`);
+    console.log(`   CI 配置: ${info.summary.hasCIConfig ? chalk_1.default.green('已配置') : chalk_1.default.gray('未检测到')}`);
+    console.log();
+}
+function displayDeployOptions(options) {
+    console.log(chalk_1.default.bold('🚀 检测到的部署配置'));
+    console.log('━'.repeat(42));
+    if (options.length === 0) {
+        console.log(chalk_1.default.gray('   未检测到部署配置\n'));
+        return;
+    }
+    for (const opt of options) {
+        console.log(`  ${chalk_1.default.cyan(getDeployMethodLabel(opt.method))}`);
+        if (opt.configFile)
+            console.log(`    配置: ${chalk_1.default.gray(opt.configFile)}`);
+        if (opt.command)
+            console.log(`    命令: ${chalk_1.default.white(opt.command)}`);
+        console.log();
+    }
+}
+function displayDevCommands(commands) {
+    console.log(chalk_1.default.bold('🔧 开发命令'));
+    console.log('━'.repeat(42));
+    const sections = [
+        { label: '安装', cmds: commands.setup },
+        { label: '构建', cmds: commands.build },
+        { label: '测试', cmds: commands.test },
+        { label: '开发', cmds: commands.dev },
+        { label: '启动', cmds: commands.start },
+        { label: 'Lint', cmds: commands.lint },
+    ];
+    for (const s of sections) {
+        if (s.cmds && s.cmds.length > 0) {
+            console.log(`  ${chalk_1.default.yellow(s.label)}: ${chalk_1.default.white(s.cmds.join(', '))}`);
+        }
+    }
+    console.log();
+}
+function getDeployMethodLabel(method) {
+    const labels = {
+        'docker': '🐳 Docker',
+        'docker-compose': '🐳 Docker Compose',
+        'kubernetes': '☸️  Kubernetes',
+        'helm': '☸️  Helm',
+        'npm': '📦 npm',
+        'make': '⚙️  Makefile',
+        'script': '📜 自定义脚本',
+        'github-pages': '📄 GitHub Pages',
+        'vercel': '▲ Vercel',
+        'netlify': '🌐 Netlify',
+        'aws': '☁️  AWS',
+        'gcp': '☁️  Google Cloud',
+        'azure': '☁️  Azure',
+        'heroku': '☁️  Heroku',
+        'unknown': '❓ 未知'
+    };
+    return labels[method] ?? method;
+}
+function formatDeployCommand(option) {
+    if (option.command)
+        return option.command;
+    const placeholders = {
+        'docker': 'docker build -t <image> . && docker run <image>',
+        'docker-compose': 'docker-compose up -d',
+        'kubernetes': 'kubectl apply -f k8s/',
+        'helm': 'helm install <release> helm/',
+        'npm': 'npm run deploy',
+        'make': 'make deploy',
+        'script': './deploy.sh',
+    };
+    return placeholders[option.method] ?? '<待配置>';
+}
+function generateDeployCommands(info, method, dryRun) {
+    const options = method ? info.deployOptions.filter(o => o.method === method) : info.deployOptions;
+    return options.map(o => ({
+        method: o.method,
+        command: formatDeployCommand(o),
+        configFile: o.configFile,
+        description: o.description,
+        dryRun: dryRun ?? false
+    }));
+}
+function selectDeployOption(options, method) {
+    if (options.length === 0)
+        return undefined;
+    if (method)
+        return options.find(o => o.method === method);
+    return options.find(o => o.recommended) ?? options[0];
+}
+function displayHints() {
+    console.log(chalk_1.default.gray('━'.repeat(42)));
+    console.log(chalk_1.default.gray('💡 提示:'));
+    console.log(chalk_1.default.gray('   --run "<command>"      执行部署命令'));
+    console.log(chalk_1.default.gray('   --dry-run "<command>"  预览命令'));
+    console.log(chalk_1.default.gray('   --json                 输出原始数据供 /om:deploy 分析'));
+    console.log(chalk_1.default.gray('   --show-dev             显示开发命令'));
+    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', dart: '🎯 Dart',
+    };
+    return labels[type] ?? type;
+}

package/dist/cli/index.js

@@ -48,12 +48,12 @@ const auto_js_1 = require("./commands/auto.js");
 const install_skills_js_1 = require("./commands/install-skills.js");
 const check_js_1 = require("./commands/check.js");
 const check_gitignore_js_1 = require("./commands/check-gitignore.js");
-const analyze_js_1 = require("./commands/analyze.js");
 const brainstorm_js_1 = require("./commands/brainstorm.js");
 const research_js_1 = require("./commands/research.js");
 const debug_js_1 = require("./commands/debug.js");
 const complete_js_1 = require("./commands/complete.js");
 const step_js_1 = require("./commands/step.js");
+const deploy_js_1 = require("./commands/deploy.js");
 // 读取 package.json 版本
 let version = '0.0.0';
 try {
@@ -83,9 +83,9 @@ program.addCommand(step_js_1.stepCommand);
 program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
 program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
-program.addCommand(analyze_js_1.analyzeCommand);
 program.addCommand(brainstorm_js_1.brainstormCommand);
 program.addCommand(research_js_1.researchCommand);
 program.addCommand(debug_js_1.debugCommand);
+program.addCommand(deploy_js_1.deployCommand);
 // 默认帮助
 program.parse();

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

@@ -1,4 +1,3 @@
-import type { QuestionInference } from './smart-question-analyzer.js';
 /**
  * 将 brainstorm 答案键翻译为 TaskPlanner 期望的键
  *
@@ -7,13 +6,6 @@ import type { QuestionInference } from './smart-question-analyzer.js';
  * 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 所需的字段
  */

package/dist/orchestrator/answer-mapper.js

@@ -1,7 +1,7 @@
 "use strict";
+// src/orchestrator/answer-mapper.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.translateBrainstormAnswers = translateBrainstormAnswers;
-exports.translateAnalyzerInferences = translateAnalyzerInferences;
 exports.extractTasksInputFields = extractTasksInputFields;
 /**
  * 答案键映射 — 统一三套 ID 体系
@@ -30,16 +30,6 @@ const CANONICAL_TO_PLANNER = {
     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 期望的键
  *
@@ -67,22 +57,6 @@ function translateBrainstormAnswers(answers) {
     }
     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 所需的字段
  */

package/dist/orchestrator/environment-detector.d.ts

@@ -0,0 +1,51 @@
+import type { EnvironmentInfo, EnvironmentDetectorConfig } from '../types/index.js';
+/**
+ * 默认环境检测器配置
+ */
+export declare const DEFAULT_ENVIRONMENT_DETECTOR_CONFIG: EnvironmentDetectorConfig;
+/**
+ * 环境检测器
+ *
+ * 自动扫描项目结构，检测构建工具、CI配置、部署选项等环境信息。
+ */
+export declare class EnvironmentDetector {
+    private config;
+    private projectRoot;
+    constructor(projectRoot: string, config?: Partial<EnvironmentDetectorConfig>);
+    /**
+     * 执行完整检测
+     */
+    detect(): Promise<EnvironmentInfo>;
+    /**
+     * 检测项目类型
+     */
+    private detectProjectType;
+    /**
+     * 获取项目名称
+     */
+    private getProjectName;
+    /**
+     * 在配置的扫描目录中查找文件
+     */
+    private findFile;
+    /**
+     * 检测构建工具
+     */
+    private detectBuildTools;
+    /**
+     * 检测 CI 配置
+     */
+    private detectCIConfig;
+    /**
+     * 检测部署选项
+     */
+    private detectDeployOptions;
+    /**
+     * 获取开发命令
+     */
+    private getDevCommands;
+    /**
+     * 转换为 JSON 字符串
+     */
+    toJSON(result: EnvironmentInfo): string;
+}