feat: add task orchestration and usage insights

tests/e2e/run.js

@@ -23,6 +23,7 @@ const testHealthSpeed = require('./test-health-speed');
 const testMessages = require('./test-messages');
 const testMcp = require('./test-mcp');
 const testWorkflow = require('./test-workflow');
+const testTaskOrchestration = require('./test-task-orchestration');
 const testInvalidConfig = require('./test-invalid-config');
 const testWebUiAssets = require('./test-web-ui-assets');
 const testWebUiSessionBrowser = require('./test-web-ui-session-browser');
@@ -134,6 +135,7 @@ async function main() {
         await testMessages(ctx);
         await testMcp(ctx);
         await testWorkflow(ctx);
+        await testTaskOrchestration(ctx);
         await testWebUiAssets(ctx);
         await testWebUiSessionBrowser(ctx);
 

tests/e2e/test-task-orchestration.js

@@ -0,0 +1,221 @@
+const { assert, runSync, fs, path } = require('./helpers');
+
+function parseJsonOutput(rawText) {
+    const text = String(rawText || '').trim();
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    } catch (_) {
+        const start = text.indexOf('{');
+        const end = text.lastIndexOf('}');
+        if (start >= 0 && end > start) {
+            return JSON.parse(text.slice(start, end + 1));
+        }
+        throw new Error(`invalid json output: ${text.slice(0, 200)}`);
+    }
+}
+
+module.exports = async function testTaskOrchestration(ctx) {
+    const { api, node, cliPath, env, tmpHome } = ctx;
+
+    const planResult = runSync(node, [
+        cliPath,
+        'task',
+        'plan',
+        '--target',
+        '检查当前配置并输出摘要',
+        '--follow-up',
+        '整理结论',
+        '--json'
+    ], { env });
+    assert(planResult.status === 0, `task plan failed: ${planResult.stderr || planResult.stdout}`);
+    const planPayload = parseJsonOutput(planResult.stdout);
+    assert(planPayload.ok === true, 'task plan should validate');
+    assert(planPayload.plan && Array.isArray(planPayload.plan.nodes), 'task plan should include nodes');
+    assert(planPayload.plan.nodes.length >= 2, 'task plan should include multiple nodes');
+
+    const invalidWorkflowPlanResult = runSync(node, [
+        cliPath,
+        'task',
+        'plan',
+        '--target',
+        'plain target',
+        '--workflow-id',
+        'missing-workflow',
+        '--engine',
+        'workflow',
+        '--json'
+    ], { env });
+    assert(invalidWorkflowPlanResult.status !== 0, 'task plan should fail for unknown workflow ids');
+    const invalidWorkflowPlanPayload = parseJsonOutput(invalidWorkflowPlanResult.stdout);
+    assert(invalidWorkflowPlanPayload.ok === false, 'invalid workflow plan should be rejected');
+    assert(Array.isArray(invalidWorkflowPlanPayload.issues), 'invalid workflow plan should include issues');
+    assert(invalidWorkflowPlanPayload.issues.some((item) => String(item.message || '').includes('unknown workflow')), 'invalid workflow plan should mention unknown workflow');
+
+    const runResult = runSync(node, [
+        cliPath,
+        'task',
+        'run',
+        '--target',
+        '诊断当前配置',
+        '--workflow-id',
+        'diagnose-config',
+        '--engine',
+        'workflow',
+        '--json'
+    ], { env });
+    assert(runResult.status === 0, `task run failed: ${runResult.stderr || runResult.stdout}`);
+    const runPayload = parseJsonOutput(runResult.stdout);
+    assert(runPayload.run && runPayload.run.status === 'success', 'task run should succeed with diagnose-config workflow');
+    assert(typeof runPayload.runId === 'string' && runPayload.runId, 'task run should return runId');
+    assert(typeof runPayload.taskId === 'string' && runPayload.taskId, 'task run should return taskId');
+
+    const runsResult = runSync(node, [cliPath, 'task', 'runs', '--limit', '10', '--json'], { env });
+    assert(runsResult.status === 0, `task runs failed: ${runsResult.stderr || runsResult.stdout}`);
+    const runsPayload = parseJsonOutput(runsResult.stdout);
+    assert(Array.isArray(runsPayload.runs), 'task runs should return runs array');
+    assert(runsPayload.runs.some((item) => item.runId === runPayload.runId), 'task runs should include latest run');
+
+    const queueAddResult = runSync(node, [
+        cliPath,
+        'task',
+        'queue',
+        'add',
+        '--target',
+        '再次诊断当前配置',
+        '--workflow-id',
+        'diagnose-config',
+        '--engine',
+        'workflow',
+        '--json'
+    ], { env });
+    assert(queueAddResult.status === 0, `task queue add failed: ${queueAddResult.stderr || queueAddResult.stdout}`);
+    const queueAddPayload = parseJsonOutput(queueAddResult.stdout);
+    assert(queueAddPayload.ok === true, 'task queue add should succeed');
+    assert(queueAddPayload.task && queueAddPayload.task.taskId, 'queue add should return task');
+
+    const queueShowResult = runSync(node, [
+        cliPath,
+        'task',
+        'queue',
+        'show',
+        queueAddPayload.task.taskId
+    ], { env });
+    assert(queueShowResult.status === 0, `task queue show failed: ${queueShowResult.stderr || queueShowResult.stdout}`);
+    const queueShowPayload = parseJsonOutput(queueShowResult.stdout);
+    assert(queueShowPayload.taskId === queueAddPayload.task.taskId, 'task queue show should resolve task');
+
+    const queueStartResult = runSync(node, [
+        cliPath,
+        'task',
+        'queue',
+        'start',
+        queueAddPayload.task.taskId,
+        '--json'
+    ], { env });
+    assert(queueStartResult.status === 0, `task queue start failed: ${queueStartResult.stderr || queueStartResult.stdout}`);
+    const queueStartPayload = parseJsonOutput(queueStartResult.stdout);
+    assert(queueStartPayload.ok === true, 'task queue start should succeed');
+    assert(queueStartPayload.detail && queueStartPayload.detail.run && queueStartPayload.detail.run.status === 'success', 'queued task should complete successfully');
+
+    const logsResult = runSync(node, [
+        cliPath,
+        'task',
+        'logs',
+        queueStartPayload.detail.runId,
+        '--json'
+    ], { env });
+    assert(logsResult.status === 0, `task logs failed: ${logsResult.stderr || logsResult.stdout}`);
+    const logsPayload = parseJsonOutput(logsResult.stdout);
+    assert(typeof logsPayload.logs === 'string', 'task logs should return log text');
+    assert(logsPayload.logs.includes('# workflow-01') || logsPayload.logs.includes('# diagnose-config') || logsPayload.logs.includes('# workflow'), 'task logs should include node heading');
+
+    const queueListResult = runSync(node, [cliPath, 'task', 'queue', 'list', '--json'], { env });
+    assert(queueListResult.status === 0, `task queue list failed: ${queueListResult.stderr || queueListResult.stdout}`);
+    const queueListPayload = parseJsonOutput(queueListResult.stdout);
+    assert(Array.isArray(queueListPayload.tasks), 'task queue list should return tasks array');
+    assert(queueListPayload.tasks.some((item) => item.taskId === queueAddPayload.task.taskId), 'task queue list should include queued task record');
+
+    const taskRunsFile = path.join(tmpHome, '.codex', 'codexmate-task-runs.jsonl');
+    const taskQueueFile = path.join(tmpHome, '.codex', 'codexmate-task-queue.json');
+    assert(fs.existsSync(taskRunsFile), 'task runs file should be created');
+    assert(fs.existsSync(taskQueueFile), 'task queue file should be created');
+
+    const apiOverview = await api('task-overview');
+    assert(Array.isArray(apiOverview.queue), 'task-overview API should return queue');
+    assert(Array.isArray(apiOverview.runs), 'task-overview API should return runs');
+
+    const apiPlan = await api('task-plan', {
+        target: '检查配置后输出摘要',
+        followUps: ['整理结果']
+    });
+    assert(apiPlan.ok === true, 'task-plan API should validate');
+    assert(apiPlan.plan && Array.isArray(apiPlan.plan.waves), 'task-plan API should return waves');
+
+    const apiQueueAdd = await api('task-queue-add', {
+        target: '排队执行配置诊断',
+        workflowIds: ['diagnose-config'],
+        engine: 'workflow'
+    });
+    assert(apiQueueAdd.ok === true, 'task-queue-add API should succeed');
+
+    const apiQueueStart = await api('task-queue-start', {
+        taskId: apiQueueAdd.task.taskId,
+        detach: false
+    });
+    assert(apiQueueStart.ok === true, 'task-queue-start API should succeed');
+    assert(apiQueueStart.detail && apiQueueStart.detail.run && apiQueueStart.detail.run.status === 'success', 'API queue start should execute task');
+
+    const apiRunDetail = await api('task-run-detail', { runId: apiQueueStart.detail.runId });
+    assert(apiRunDetail && apiRunDetail.runId === apiQueueStart.detail.runId, 'task-run-detail API should return detail');
+
+    const missingQueueStartResult = runSync(node, [
+        cliPath,
+        'task',
+        'queue',
+        'start',
+        'missing-task',
+        '--json'
+    ], { env });
+    assert(missingQueueStartResult.status !== 0, 'task queue start should fail for missing task');
+    const missingQueueStartPayload = parseJsonOutput(missingQueueStartResult.stdout);
+    assert(typeof missingQueueStartPayload.error === 'string' && missingQueueStartPayload.error.includes('task not found'), 'missing task queue start should report not found');
+
+    const invalidRunIdResult = runSync(node, [
+        cliPath,
+        'task',
+        'run',
+        '--target',
+        '诊断当前配置',
+        '--workflow-id',
+        'diagnose-config',
+        '--engine',
+        'workflow',
+        '--run-id',
+        '../escaped-run',
+        '--json'
+    ], { env });
+    assert(invalidRunIdResult.status !== 0, 'task run should reject unsafe run ids');
+    const invalidRunIdPayload = parseJsonOutput(invalidRunIdResult.stdout);
+    assert(typeof invalidRunIdPayload.error === 'string' && invalidRunIdPayload.error.includes('unsupported characters'), 'unsafe run id should report validation error');
+
+    const apiRetry = await api('task-retry', {
+        runId: apiQueueStart.detail.runId,
+        detach: false
+    });
+    assert(apiRetry && apiRetry.run && apiRetry.run.status === 'success', 'task-retry API should rerun task');
+
+    const apiLogs = await api('task-logs', { runId: apiRetry.runId });
+    assert(typeof apiLogs.logs === 'string', 'task-logs API should return logs');
+
+    const apiCancelQueued = await api('task-queue-add', {
+        target: '待取消任务',
+        workflowIds: ['diagnose-config'],
+        engine: 'workflow'
+    });
+    assert(apiCancelQueued.ok === true, 'second task-queue-add API should succeed');
+    const apiCancel = await api('task-cancel', { taskId: apiCancelQueued.task.taskId });
+    assert(apiCancel.ok === true, 'task-cancel API should cancel queued task');
+};

tests/unit/config-tabs-ui.test.mjs

@@ -14,8 +14,10 @@ test('config template keeps expected config tabs in top and side navigation', ()
     const openclawModal = readProjectFile('web-ui/partials/index/modal-openclaw-config.html');
     const sessionsPanel = readProjectFile('web-ui/partials/index/panel-sessions.html');
     const usagePanel = readProjectFile('web-ui/partials/index/panel-usage.html');
+    const orchestrationPanel = readProjectFile('web-ui/partials/index/panel-orchestration.html');
     const baseTheme = readProjectFile('web-ui/styles/base-theme.css');
     const controlsForms = readProjectFile('web-ui/styles/controls-forms.css');
+    const taskOrchestrationStyles = readProjectFile('web-ui/styles/task-orchestration.css');
     const sideRail = html.match(/<aside class="side-rail"[\s\S]*?<\/aside>/)?.[0] || '';
     const topTabModes = [...html.matchAll(/id="tab-config-([a-z]+)"/g)]
         .map((match) => match[1]);
@@ -57,6 +59,38 @@ test('config template keeps expected config tabs in top and side navigation', ()
     assert.match(html, /settingsTab === 'trash'/);
     assert.match(html, /settingsTab === 'device'/);
     assert.match(html, /sessionTrashCount/);
+    assert.match(html, /id="side-tab-orchestration"/);
+    assert.match(html, /id="tab-orchestration"/);
+    assert.match(html, /data-main-tab="orchestration"/);
+    assert.match(html, /onMainTabPointerDown\('orchestration', \$event\)/);
+    assert.match(html, /onMainTabClick\('orchestration', \$event\)/);
+    assert.match(html, /aria-controls="panel-orchestration"/);
+    assert.match(html, /:aria-selected="mainTab === 'orchestration'"/);
+    assert.match(html, /id="panel-orchestration"/);
+    assert.match(html, /v-show="mainTab === 'orchestration'"/);
+    assert.match(orchestrationPanel, /<span class="selector-title">任务编排<\/span>/);
+    assert.match(orchestrationPanel, /@click="previewTaskPlan\(\)"/);
+    assert.match(orchestrationPanel, /@click="runTaskOrchestration\(\)"/);
+    assert.match(orchestrationPanel, /@click="addTaskOrchestrationToQueue\(\)"/);
+    assert.match(orchestrationPanel, /@click="startTaskQueueRunner\(\)"/);
+    assert.match(orchestrationPanel, /@click="retryTaskRunFromUi\(taskOrchestration.selectedRunId\)"/);
+    assert.match(orchestrationPanel, /class="settings-tab-actions task-header-actions"/);
+    assert.match(orchestrationPanel, /class="task-onboarding-card"/);
+    assert.match(orchestrationPanel, /class="task-template-chip-group"/);
+    assert.match(orchestrationPanel, /class="task-config-strip"/);
+    assert.match(orchestrationPanel, /class="task-action-help"/);
+    assert.match(orchestrationPanel, /class="btn-tool task-action-preview" @click="previewTaskPlan\(\)"/);
+    assert.match(orchestrationPanel, /class="task-action-row-right"/);
+    assert.match(orchestrationPanel, /class="task-empty-state"/);
+    assert.match(orchestrationPanel, /taskOrchestrationSelectedRunNodes/);
+    assert.match(taskOrchestrationStyles, /\.task-section-header\s*\{[\s\S]*align-items:\s*center;[\s\S]*justify-content:\s*space-between;/);
+    assert.match(taskOrchestrationStyles, /\.task-onboarding-card,[\s\S]*\.task-empty-state\s*\{[\s\S]*border:\s*1px solid/);
+    assert.match(taskOrchestrationStyles, /\.task-onboarding-steps\s*\{[\s\S]*grid-template-columns:\s*repeat\(3, minmax\(0, 1fr\)\);/);
+    assert.match(taskOrchestrationStyles, /\.task-template-chip-group\s*\{[\s\S]*display:\s*flex;[\s\S]*flex-wrap:\s*wrap;/);
+    assert.match(taskOrchestrationStyles, /\.task-section-header \.settings-tab-actions\s*\{[\s\S]*flex-wrap:\s*nowrap;[\s\S]*margin-left:\s*auto;/);
+    assert.match(taskOrchestrationStyles, /\.task-action-row\s*\{[\s\S]*align-items:\s*center;[\s\S]*justify-content:\s*flex-start;[\s\S]*flex-wrap:\s*wrap;/);
+    assert.match(taskOrchestrationStyles, /\.task-action-row-right\s*\{[\s\S]*display:\s*flex;[\s\S]*justify-content:\s*flex-start;[\s\S]*flex-wrap:\s*nowrap;/);
+    assert.match(taskOrchestrationStyles, /\.task-runtime-item-actions\s*\{[\s\S]*flex-direction:\s*row;[\s\S]*align-items:\s*center;/);
     assert.match(html, /id="side-tab-market"/);
     assert.match(html, /id="tab-market"/);
     assert.match(html, /id="side-tab-docs"/);
@@ -119,6 +153,7 @@ test('config template keeps expected config tabs in top and side navigation', ()
     assert.doesNotMatch(html, /class="market-target-switch market-target-switch-compact" role="tablist" aria-label="选择 Skills 管理目标"/);
     assert.match(html, /class="side-section" role="navigation" aria-label="配置管理"/);
     assert.match(html, /class="side-section" role="navigation" aria-label="会话管理"/);
+    assert.match(html, /class="side-section" role="navigation" aria-label="任务编排"/);
     assert.match(html, /class="side-section" role="navigation" aria-label="技能市场"/);
     assert.match(html, /class="side-section" role="navigation" aria-label="文档"/);
     assert.match(html, /class="side-section" role="navigation" aria-label="设置"/);
@@ -217,10 +252,15 @@ test('config template keeps expected config tabs in top and side navigation', ()
     assert.doesNotMatch(sessionsPanel, /sessionUsageSummaryCards/);
     assert.match(usagePanel, /sessionsUsageTimeRange === '7d'/);
     assert.match(usagePanel, /sessionsUsageTimeRange === '30d'/);
+    assert.match(usagePanel, /sessionsUsageTimeRange === 'all'/);
+    assert.match(usagePanel, />全部<\/button>/);
     assert.match(usagePanel, /sessionsUsageList\.length/);
     assert.match(usagePanel, /loadSessionsUsage\(\{ forceRefresh: true \}\)/);
     assert.match(usagePanel, /sessionUsageSummaryCards/);
     assert.match(usagePanel, /class="usage-summary-value" :title="card\.title \|\| null"/);
+    assert.match(usagePanel, /v-if="card\.note" class="usage-summary-note"/);
+    assert.match(usagePanel, /sessionUsageCharts\.usedModels/);
+    assert.match(usagePanel, /class="usage-model-list"/);
     assert.match(usagePanel, /sessionUsageCharts\.buckets/);
     assert.doesNotMatch(usagePanel, /sessionUsageCharts\.topPaths\[0\]\?\.count/);
     assert.doesNotMatch(html, /sessionUsageSummaryCards\[0\]\?\.value/);

tests/unit/provider-share-command.test.mjs

@@ -1182,7 +1182,21 @@ test('buildMcpProviderListPayload keeps regular providers editable', () => {
                     model_providers: {
                         openai: {
                             base_url: 'https://api.openai.com/v1',
-                            preferred_auth_method: 'sk-live'
+                            preferred_auth_method: 'sk-live',
+                            models: [
+                                {
+                                    id: 'gpt-5.3-codex',
+                                    name: 'GPT-5.3 Codex',
+                                    cost: {
+                                        input: 2,
+                                        output: 8,
+                                        cacheRead: 0.5,
+                                        cacheWrite: 0
+                                    },
+                                    contextWindow: 256000,
+                                    maxTokens: 8192
+                                }
+                            ]
                         }
                     }
                 }
@@ -1202,6 +1216,20 @@ test('buildMcpProviderListPayload keeps regular providers editable', () => {
     assert.strictEqual(openai.nonEditable, false);
     assert.strictEqual(openai.nonDeletable, false);
     assert.strictEqual(openai.current, true);
+    assert.deepStrictEqual(openai.models, [
+        {
+            id: 'gpt-5.3-codex',
+            name: 'GPT-5.3 Codex',
+            cost: {
+                input: 2,
+                output: 8,
+                cacheRead: 0.5,
+                cacheWrite: 0
+            },
+            contextWindow: 256000,
+            maxTokens: 8192
+        }
+    ]);
 });
 
 test('applyCodexConfigDirect applies provider config without local proxy indirection', async () => {

tests/unit/run.mjs

@@ -14,6 +14,7 @@ await import(pathToFileURL(path.join(__dirname, 'reset-main.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'session-query.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'mcp-stdio.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'workflow-engine.test.mjs')));
+await import(pathToFileURL(path.join(__dirname, 'task-orchestrator.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'skills-modal-ui.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'skills-market-runtime.test.mjs')));
 await import(pathToFileURL(path.join(__dirname, 'readme-docs-consistency.test.mjs')));