openmatrix 0.1.0

package/dist/cli/commands/report.js

@@ -0,0 +1,202 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommand = void 0;
+// src/cli/commands/report.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+const progress_reporter_js_1 = require("../../utils/progress-reporter.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.reportCommand = new commander_1.Command('report')
+    .description('生成任务执行报告')
+    .option('-f, --format <format>', '输出格式 (markdown/json/console)', 'console')
+    .option('-o, --output <path>', '输出文件路径')
+    .option('--efficiency', '包含效率分析')
+    .option('--graph', '包含依赖图')
+    .action(async (options) => {
+    const basePath = process.cwd();
+    const omPath = `${basePath}/.openmatrix`;
+    const stateManager = new state_manager_js_1.StateManager(omPath);
+    await stateManager.initialize();
+    const state = await stateManager.getState();
+    const tasks = await stateManager.listTasks();
+    const approvals = await stateManager.getAllApprovals();
+    const reporter = new progress_reporter_js_1.ProgressReporter({ width: 30 });
+    // 统计数据
+    const stats = {
+        total: tasks.length,
+        completed: tasks.filter(t => t.status === 'completed').length,
+        failed: tasks.filter(t => t.status === 'failed').length,
+        inProgress: tasks.filter(t => t.status === 'in_progress').length,
+        pending: tasks.filter(t => t.status === 'pending').length,
+        blocked: tasks.filter(t => t.status === 'blocked').length
+    };
+    // 计算效率数据
+    const efficiency = {
+        totalDuration: tasks
+            .filter(t => t.phases?.accept?.duration)
+            .reduce((sum, t) => sum + (t.phases?.accept?.duration || 0), 0),
+        agentCalls: tasks.length,
+        retryCount: tasks.reduce((sum, t) => sum + t.retryCount, 0),
+        parallelism: stats.inProgress > 0 ? Math.min(stats.inProgress, 4) : 1,
+        targetParallelism: 4
+    };
+    // 生成报告
+    let report;
+    if (options.format === 'json') {
+        report = JSON.stringify({
+            runId: state.runId,
+            status: state.status,
+            startedAt: state.startedAt,
+            statistics: stats,
+            efficiency,
+            tasks: tasks.map(t => ({
+                id: t.id,
+                title: t.title,
+                status: t.status,
+                priority: t.priority,
+                duration: t.phases?.accept?.duration || 0,
+                error: t.error
+            })),
+            approvals: approvals.map(a => ({
+                id: a.id,
+                type: a.type,
+                status: a.status,
+                decision: a.decision
+            }))
+        }, null, 2);
+    }
+    else if (options.format === 'console') {
+        // 使用 ProgressReporter 生成控制台报告
+        report = reporter.renderFullReport({
+            tasks,
+            statistics: {
+                total: stats.total,
+                completed: stats.completed,
+                inProgress: stats.inProgress,
+                pending: stats.pending,
+                failed: stats.failed
+            },
+            efficiency
+        });
+        // 可选: 添加依赖图
+        if (options.graph && tasks.length > 0) {
+            report += '\n\n📊 任务依赖图\n';
+            report += '━'.repeat(42) + '\n';
+            report += reporter.renderDependencyGraph(tasks);
+        }
+    }
+    else {
+        // markdown 格式
+        report = generateMarkdownReport(state, tasks, approvals, stats, efficiency, options);
+    }
+    // 输出
+    if (options.output) {
+        const outputPath = path.resolve(basePath, options.output);
+        await fs.writeFile(outputPath, report, 'utf-8');
+        console.log(`\n📄 报告已保存: ${outputPath}`);
+    }
+    else {
+        console.log('\n' + report);
+    }
+});
+function generateMarkdownReport(state, tasks, approvals, stats, efficiency, options) {
+    const duration = Math.round(efficiency.totalDuration / 1000 / 60); // 转为分钟
+    let report = `
+# 📊 OpenMatrix 执行报告
+
+**Run ID:** ${state.runId}
+**时间:** ${state.startedAt}
+**状态:** ${state.status}
+
+## 统计概览
+
+| 状态 | 数量 | 占比 |
+|------|------|------|
+| ✅ 完成 | ${stats.completed} | ${stats.total > 0 ? Math.round(stats.completed / stats.total * 100) : 0}% |
+| ❌ 失败 | ${stats.failed} | ${stats.total > 0 ? Math.round(stats.failed / stats.total * 100) : 0}% |
+| 🔄 进行中 | ${stats.inProgress} | ${stats.total > 0 ? Math.round(stats.inProgress / stats.total * 100) : 0}% |
+| 🔴 阻塞 | ${stats.blocked} | ${stats.total > 0 ? Math.round(stats.blocked / stats.total * 100) : 0}% |
+| ⏳ 待处理 | ${stats.pending} | ${stats.total > 0 ? Math.round(stats.pending / stats.total * 100) : 0}% |
+
+## 任务详情
+
+### ✅ 已完成
+${tasks
+        .filter(t => t.status === 'completed')
+        .map(t => `- ${t.id}: ${t.title}`)
+        .join('\n') || '_无_'}
+
+### ❌ 失败
+${tasks
+        .filter(t => t.status === 'failed')
+        .map(t => `- ${t.id}: ${t.title}\n  原因: ${t.error || '未知'}`)
+        .join('\n') || '_无_'}
+
+### 🔴 阻塞
+${tasks
+        .filter(t => t.status === 'blocked')
+        .map(t => `- ${t.id}: ${t.title}\n  原因: ${t.error || '未知'}`)
+        .join('\n') || '_无_'}
+`;
+    // 效率分析
+    if (options.efficiency) {
+        report += `
+## 🏆 效率分析
+
+| 指标 | 值 |
+|------|-----|
+| 总耗时 | ${duration} 分钟 |
+| Agent 调用 | ${efficiency.agentCalls} 次 |
+| 重试次数 | ${efficiency.retryCount} 次 |
+| 并行度 | ${efficiency.parallelism} / ${efficiency.targetParallelism} |
+`;
+    }
+    // 审批记录
+    report += `
+## 🔔 审批记录
+
+| ID | 类型 | 决策 | 状态 |
+|----|------|------|------|
+${approvals.length > 0
+        ? approvals.map(a => `| ${a.id} | ${a.type} | ${a.decision || '-'} | ${a.status} |`).join('\n')
+        : '| _无_ | | | |'}
+
+---
+*报告生成时间: ${new Date().toISOString()}*
+`;
+    return report.trim();
+}

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

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

package/dist/cli/commands/resume.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resumeCommand = void 0;
+// src/cli/commands/resume.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+exports.resumeCommand = new commander_1.Command('resume')
+    .description('恢复中断或暂停的任务')
+    .argument('[taskId]', '任务ID')
+    .option('--all', '恢复所有可恢复任务')
+    .action(async (taskId, options) => {
+    const basePath = process.cwd();
+    const omPath = `${basePath}/.openmatrix`;
+    const stateManager = new state_manager_js_1.StateManager(omPath);
+    await stateManager.initialize();
+    const state = await stateManager.getState();
+    // 检查状态
+    if (state.status === 'completed') {
+        console.log('✅ 所有任务已完成');
+        return;
+    }
+    // 如果没有提供任务ID，列出可恢复任务
+    if (!taskId && !options.all) {
+        const tasks = await stateManager.listTasks();
+        const resumable = tasks.filter(t => t.status === 'in_progress' ||
+            t.status === 'blocked' ||
+            t.status === 'waiting' ||
+            t.status === 'retry_queue');
+        if (resumable.length === 0) {
+            console.log('✅ 没有需要恢复的任务');
+            return;
+        }
+        console.log('🔄 可恢复任务:\n');
+        const statusEmoji = {
+            in_progress: '⏸️',
+            blocked: '🔴',
+            waiting: '⏳',
+            retry_queue: '🔄'
+        };
+        resumable.forEach((task, i) => {
+            const emoji = statusEmoji[task.status] || '❓';
+            console.log(`  [${i + 1}] ${emoji} ${task.id}: ${task.title}`);
+            console.log(`      状态: ${task.status} | 优先级: ${task.priority}`);
+        });
+        console.log('\n💡 使用 openmatrix resume <ID> 恢复指定任务');
+        console.log('   使用 openmatrix resume --all 恢复所有任务');
+        return;
+    }
+    // 恢复任务
+    if (options.all) {
+        const tasks = await stateManager.listTasks();
+        const resumable = tasks.filter(t => t.status === 'in_progress' ||
+            t.status === 'blocked' ||
+            t.status === 'waiting' ||
+            t.status === 'retry_queue');
+        console.log(`🔄 恢复 ${resumable.length} 个任务...\n`);
+        for (const task of resumable) {
+            await resumeTask(stateManager, task.id);
+            console.log(`  ✅ ${task.id}: ${task.title}`);
+        }
+    }
+    else if (taskId) {
+        const task = await stateManager.getTask(taskId);
+        if (!task) {
+            console.log(`❌ 任务 ${taskId} 不存在`);
+            return;
+        }
+        console.log(`🔄 恢复任务 ${taskId}...\n`);
+        await resumeTask(stateManager, taskId);
+        console.log(`  ✅ ${task.title}`);
+    }
+    // 更新全局状态
+    await stateManager.updateState({
+        status: 'running',
+        currentPhase: 'execution'
+    });
+    console.log('\n✅ 任务已恢复');
+    console.log('💡 使用 /om:status 查看执行进度');
+});
+async function resumeTask(stateManager, taskId) {
+    const task = await stateManager.getTask(taskId);
+    if (!task)
+        return;
+    // 根据状态决定恢复方式
+    switch (task.status) {
+        case 'in_progress':
+            // 中断的任务，继续执行
+            break;
+        case 'blocked':
+            // 阻塞的任务，检查是否已解决
+            await stateManager.updateTask(taskId, { status: 'pending' });
+            break;
+        case 'waiting':
+            // 等待中的任务，检查是否已确认
+            break;
+        case 'retry_queue':
+            // 重试队列，重置为 pending
+            await stateManager.updateTask(taskId, {
+                status: 'pending',
+                retryCount: task.retryCount + 1
+            });
+            break;
+    }
+}

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

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

package/dist/cli/commands/retry.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryCommand = void 0;
+// src/cli/commands/retry.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+const retry_manager_js_1 = require("../../orchestrator/retry-manager.js");
+exports.retryCommand = new commander_1.Command('retry')
+    .description('重试失败的任务')
+    .argument('[taskId]', '任务ID')
+    .option('--all', '重试所有失败任务')
+    .option('--reset', '重置重试计数')
+    .action(async (taskId, options) => {
+    const basePath = process.cwd();
+    const omPath = `${basePath}/.openmatrix`;
+    const stateManager = new state_manager_js_1.StateManager(omPath);
+    await stateManager.initialize();
+    const retryManager = new retry_manager_js_1.RetryManager({
+        maxRetries: 3,
+        backoff: 'exponential',
+        baseDelay: 10000
+    });
+    // 如果没有提供任务ID，列出失败任务
+    if (!taskId && !options.all) {
+        const tasks = await stateManager.listTasks();
+        const failed = tasks.filter(t => t.status === 'failed');
+        if (failed.length === 0) {
+            console.log('✅ 没有失败的任务');
+            return;
+        }
+        console.log('❌ 失败任务列表:\n');
+        failed.forEach((task, i) => {
+            console.log(`  [${i + 1}] ${task.id}: ${task.title}`);
+            console.log(`      失败原因: ${task.error || '未知'}`);
+            console.log(`      重试次数: ${task.retryCount}/3`);
+            console.log(`      失败时间: ${task.updatedAt}`);
+        });
+        console.log('\n💡 使用 openmatrix retry <ID> 重试指定任务');
+        console.log('   使用 openmatrix retry --all 重试所有任务');
+        return;
+    }
+    // 重试任务
+    if (options.all) {
+        const tasks = await stateManager.listTasks();
+        const failed = tasks.filter(t => t.status === 'failed');
+        console.log(`🔄 重试 ${failed.length} 个失败任务...\n`);
+        for (const task of failed) {
+            await retryTask(stateManager, retryManager, task.id, options.reset);
+            console.log(`  ✅ ${task.id}: ${task.title}`);
+        }
+    }
+    else if (taskId) {
+        const task = await stateManager.getTask(taskId);
+        if (!task) {
+            console.log(`❌ 任务 ${taskId} 不存在`);
+            return;
+        }
+        if (task.status !== 'failed') {
+            console.log(`❌ 任务 ${taskId} 状态不是失败`);
+            return;
+        }
+        console.log(`🔄 重试任务 ${taskId}...\n`);
+        await retryTask(stateManager, retryManager, taskId, options.reset);
+        console.log(`  ✅ ${task.title}`);
+    }
+    console.log('\n💡 使用 /om:resume 继续执行');
+});
+async function retryTask(stateManager, retryManager, taskId, reset) {
+    const task = await stateManager.getTask(taskId);
+    if (!task)
+        return;
+    const newRetryCount = reset ? 0 : task.retryCount + 1;
+    await stateManager.updateTask(taskId, {
+        status: 'pending',
+        retryCount: newRetryCount,
+        error: null
+    });
+    retryManager.addToQueue(taskId, 'manual retry');
+}

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

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

package/dist/cli/commands/start.js

@@ -0,0 +1,252 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCommand = void 0;
+// src/cli/commands/start.ts
+const commander_1 = require("commander");
+const state_manager_js_1 = require("../../storage/state-manager.js");
+const task_parser_js_1 = require("../../orchestrator/task-parser.js");
+const task_planner_js_1 = require("../../orchestrator/task-planner.js");
+const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
+const executor_js_1 = require("../../orchestrator/executor.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.startCommand = new commander_1.Command('start')
+    .description('启动新的任务执行周期')
+    .argument('[input]', '任务文件路径或描述')
+    .option('-c, --config <path>', '配置文件路径')
+    .option('--skip-questions', '跳过澄清问题')
+    .option('--mode <mode>', '执行模式 (confirm-all|confirm-key|auto)')
+    .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .action(async (input, options) => {
+    const basePath = process.cwd();
+    const omPath = path.join(basePath, '.openmatrix');
+    // 确保目录存在
+    await fs.mkdir(omPath, { recursive: true });
+    await fs.mkdir(path.join(omPath, 'tasks'), { recursive: true });
+    await fs.mkdir(path.join(omPath, 'approvals'), { recursive: true });
+    const stateManager = new state_manager_js_1.StateManager(omPath);
+    await stateManager.initialize();
+    const state = await stateManager.getState();
+    // 检查是否已有运行中的任务
+    if (state.status === 'running') {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'error',
+                message: '已有任务在执行中',
+                hint: '使用 /om:status 查看状态，或 /om:resume 恢复执行'
+            }));
+        }
+        else {
+            console.log('⚠️  已有任务在执行中');
+            console.log('   使用 /om:status 查看状态');
+            console.log('   使用 /om:resume 恢复执行');
+        }
+        return;
+    }
+    // 获取任务内容
+    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}`);
+            }
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: '请提供任务文件路径或描述'
+                }));
+            }
+            else {
+                console.log('❌ 请提供任务文件路径或描述');
+                console.log('   用法: openmatrix start <task.md>');
+                console.log('   或创建 TASK.md 文件');
+            }
+            return;
+        }
+    }
+    else if (taskContent.endsWith('.md')) {
+        // 读取文件
+        try {
+            taskContent = await fs.readFile(taskContent, 'utf-8');
+            if (!options.json) {
+                console.log(`📄 读取任务文件: ${input}`);
+            }
+        }
+        catch {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'error',
+                    message: `无法读取文件: ${input}`
+                }));
+            }
+            else {
+                console.log(`❌ 无法读取文件: ${input}`);
+            }
+            return;
+        }
+    }
+    // 解析任务
+    if (!options.json) {
+        console.log('\n🔍 解析任务...');
+    }
+    const parser = new task_parser_js_1.TaskParser();
+    const parsedTask = parser.parse(taskContent);
+    if (!options.json) {
+        console.log(`\n📋 任务: ${parsedTask.title}`);
+        console.log(`   目标: ${parsedTask.goals.join(', ')}`);
+    }
+    // 拆解任务
+    if (!options.json) {
+        console.log('\n🔧 拆解任务...');
+    }
+    const planner = new task_planner_js_1.TaskPlanner();
+    const subTasks = planner.breakdown(parsedTask, {});
+    // 创建任务到状态管理器
+    for (const subTask of subTasks) {
+        await stateManager.createTask({
+            title: subTask.title,
+            description: subTask.description,
+            priority: subTask.priority,
+            timeout: subTask.estimatedComplexity === 'high' ? 300000 :
+                subTask.estimatedComplexity === 'medium' ? 180000 : 120000,
+            dependencies: subTask.dependencies,
+            assignedAgent: subTask.assignedAgent
+        });
+    }
+    // 确定执行模式
+    const executionMode = options.mode || 'confirm-key';
+    let approvalPoints = [];
+    // 根据模式设置审批点
+    // auto 模式: 空数组，不暂停任何审批点
+    // confirm-key 模式: 仅在关键节点暂停
+    // confirm-all 模式: 每个阶段都暂停
+    switch (executionMode) {
+        case 'confirm-all':
+            approvalPoints = ['plan', 'phase', 'merge', 'deploy'];
+            break;
+        case 'confirm-key':
+            approvalPoints = ['plan', 'merge', 'deploy'];
+            break;
+        case 'auto':
+            approvalPoints = []; // 全自动模式：无任何审批点
+            break;
+        default:
+            approvalPoints = ['plan', 'merge'];
+    }
+    // 更新状态
+    await stateManager.updateState({
+        status: 'running',
+        currentPhase: 'execution',
+        config: {
+            ...state.config,
+            approvalPoints: approvalPoints
+        }
+    });
+    // 创建审批请求（如果有审批点）
+    const approvalManager = new approval_manager_js_1.ApprovalManager(stateManager);
+    if (approvalPoints.includes('plan')) {
+        const approval = await approvalManager.createPlanApproval('plan-approval', `# 执行计划\n\n${subTasks.map((t, i) => `${i + 1}. ${t.title}`).join('\n')}`);
+        await stateManager.updateState({ status: 'paused' });
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'waiting_approval',
+                approvalId: approval.id,
+                approvalType: 'plan',
+                message: '等待计划审批',
+                tasks: subTasks.map((t, i) => ({
+                    index: i + 1,
+                    title: t.title,
+                    priority: t.priority
+                }))
+            }));
+        }
+        else {
+            console.log(`\n📋 生成 ${subTasks.length} 个子任务:\n`);
+            subTasks.forEach((task, i) => {
+                console.log(`  ${i + 1}. ${task.title} (${task.priority})`);
+            });
+            console.log(`\n🎯 执行模式: ${executionMode}`);
+            console.log(`   审批点: ${approvalPoints.join(', ')}`);
+            console.log(`\n⏸️  等待计划审批`);
+            console.log(`   审批ID: ${approval.id}`);
+            console.log(`   使用 /om:approve ${approval.id} 审批`);
+        }
+        return;
+    }
+    // 创建执行器并获取第一批任务
+    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
+        maxConcurrent: state.config.maxConcurrentAgents,
+        taskTimeout: state.config.timeout * 1000
+    });
+    // 设置 PhaseExecutor 的自动模式
+    const phaseExecutor = executor.getPhaseExecutor();
+    if (phaseExecutor && executionMode === 'auto') {
+        phaseExecutor.setAutoMode(true);
+    }
+    const result = await executor.step();
+    if (options.json) {
+        // JSON 输出供 Skill 解析
+        console.log(JSON.stringify({
+            status: result.status,
+            message: result.message,
+            statistics: result.statistics,
+            subagentTasks: result.subagentTasks.map(t => ({
+                subagent_type: t.subagent_type,
+                description: t.description,
+                prompt: t.prompt,
+                isolation: t.isolation,
+                taskId: t.taskId,
+                agentType: t.agentType,
+                timeout: t.timeout
+            }))
+        }));
+    }
+    else {
+        console.log(`\n📋 生成 ${subTasks.length} 个子任务:\n`);
+        subTasks.forEach((task, i) => {
+            console.log(`  ${i + 1}. ${task.title} (${task.priority})`);
+        });
+        console.log(`\n🎯 执行模式: ${executionMode}`);
+        console.log(`   审批点: ${approvalPoints.length > 0 ? approvalPoints.join(', ') : '无 (全自动)'}`);
+        console.log('\n🚀 开始执行...');
+        console.log('   使用 /om:status 查看进度');
+    }
+});

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

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