fix(task-orchestration): hide stale failed runs from plan previews

Author: awsl233777

tests/unit/web-ui-behavior-parity.test.mjs

@@ -889,6 +889,7 @@ test('captured bundled app skeleton only exposes expected data key drift versus
         'taskOrchestrationSelectedRun',
         'taskOrchestrationSelectedRunNodes',
         'taskOrchestrationActiveQueue',
+        'taskOrchestrationWorkbenchVisible',
         'taskOrchestrationQueueStats',
         'taskOrchestrationDraftMetrics',
         'taskOrchestrationDraftChecklist',

tests/unit/web-ui-logic.test.mjs

@@ -1341,6 +1341,46 @@ test('submitTaskOrchestrationChatMessage treats /plan as chat preview command',
     assert.deepStrictEqual(previewCalls, [{ silent: false }, { silent: false }]);
 });
 
+test('submitTaskOrchestrationChatMessage clears stale failed run detail before /plan preview', async () => {
+    const methods = createTaskOrchestrationMethods({ api: async () => ({}) });
+    const context = {
+        ensureTaskOrchestrationState: methods.ensureTaskOrchestrationState,
+        appendTaskChatMessage: methods.appendTaskChatMessage,
+        previewTaskPlan(options) {
+            const state = this.ensureTaskOrchestrationState();
+            assert.strictEqual(state.selectedRunId, '');
+            assert.strictEqual(state.selectedRunDetail, null);
+            assert.strictEqual(state.selectedRunError, '');
+            assert.strictEqual(state.workspaceTab, 'queue');
+            return Promise.resolve({ ok: true, options });
+        },
+        showMessage(message, tone) {
+            throw new Error(`unexpected message: ${tone}:${message}`);
+        },
+        taskOrchestration: {
+            chatDraft: '/plan Fix the orchestration preview',
+            target: '',
+            followUpsText: '',
+            selectedEngine: 'openai-chat',
+            runMode: 'write',
+            plan: null,
+            planFingerprint: '',
+            planIssues: [],
+            planWarnings: [],
+            selectedRunId: 'run-failed',
+            selectedRunDetail: { run: { status: 'failed', summary: '前置节点失败，已阻塞' } },
+            selectedRunError: '前置节点失败，已阻塞',
+            workspaceTab: 'detail',
+            lastError: ''
+        }
+    };
+
+    const result = await methods.submitTaskOrchestrationChatMessage.call(context);
+
+    assert.deepStrictEqual(result, { ok: true, options: { silent: false } });
+    assert.strictEqual(context.taskOrchestration.target, 'Fix the orchestration preview');
+});
+
 test('previewTaskPlan sends previewOnly without mutating normal run semantics', async () => {
     const apiCalls = [];
     const methods = createTaskOrchestrationMethods({
@@ -1564,6 +1604,55 @@ test('taskOrchestrationActiveQueue hides completed and failed queue history from
     assert.deepStrictEqual(activeQueue, [queued, running, runStatusOnly]);
 });
 
+test('taskOrchestrationWorkbenchVisible ignores passive failed run history', () => {
+    const computed = createMainTabsComputed();
+    const context = {
+        taskOrchestrationActiveQueue: [],
+        taskOrchestration: {
+            runs: [
+                { runId: 'run-failed', status: 'failed', summary: '前置节点失败，已阻塞' }
+            ],
+            selectedRunId: '',
+            selectedRunError: ''
+        }
+    };
+
+    assert.strictEqual(computed.taskOrchestrationWorkbenchVisible.call(context), false);
+
+    context.taskOrchestration.selectedRunId = 'run-failed';
+    assert.strictEqual(computed.taskOrchestrationWorkbenchVisible.call(context), true);
+});
+
+test('loadTaskOrchestrationOverview does not auto-select latest failed run history', async () => {
+    const methods = createTaskOrchestrationMethods({
+        api: async (name) => {
+            assert.strictEqual(name, 'task-overview');
+            return {
+                runs: [{ runId: 'run-failed', status: 'failed', summary: '前置节点失败，已阻塞' }],
+                queue: [],
+                workflows: [],
+                warnings: []
+            };
+        }
+    });
+    const context = {
+        ensureTaskOrchestrationState: methods.ensureTaskOrchestrationState,
+        loadTaskRunDetail() {
+            throw new Error('should not load detail for passive history');
+        },
+        isTaskRunActive: () => false,
+        showMessage() {},
+        syncTaskOrchestrationPolling() {}
+    };
+    context.taskOrchestration = methods.ensureTaskOrchestrationState.call(context);
+
+    await methods.loadTaskOrchestrationOverview.call(context, { silent: true, includeDetail: false });
+
+    assert.strictEqual(context.taskOrchestration.runs.length, 1);
+    assert.strictEqual(context.taskOrchestration.selectedRunId, '');
+    assert.strictEqual(context.taskOrchestration.selectedRunDetail, null);
+});
+
 test('startTaskQueueRunner surfaces already-running queue state distinctly', async () => {
     const api = async (name) => {
         if (name === 'task-queue-start') {

web-ui/modules/app.computed.main-tabs.mjs

@@ -283,6 +283,17 @@ export function createMainTabsComputed() {
                 return status === 'queued' || status === 'running';
             });
         },
+        taskOrchestrationWorkbenchVisible() {
+            const state = this.taskOrchestration && typeof this.taskOrchestration === 'object'
+                ? this.taskOrchestration
+                : {};
+            const activeQueue = Array.isArray(this.taskOrchestrationActiveQueue)
+                ? this.taskOrchestrationActiveQueue
+                : [];
+            return activeQueue.length > 0
+                || !!String(state.selectedRunId || '').trim()
+                || !!String(state.selectedRunError || '').trim();
+        },
         taskOrchestrationQueueStats() {
             const queue = this.taskOrchestration && Array.isArray(this.taskOrchestration.queue)
                 ? this.taskOrchestration.queue

web-ui/modules/app.methods.task-orchestration.mjs

@@ -163,6 +163,17 @@ function buildRunModeFlags(runMode) {
     };
 }
 
+function clearTaskRunSelectionForDraft(state) {
+    if (!state || typeof state !== 'object') {
+        return;
+    }
+    state.selectedRunId = '';
+    state.selectedRunDetail = null;
+    state.selectedRunError = '';
+    state.selectedRunLoading = false;
+    state.workspaceTab = 'queue';
+}
+
 export function createTaskOrchestrationMethods(options = {}) {
     const { api } = options;
 
@@ -316,9 +327,6 @@ export function createTaskOrchestrationMethods(options = {}) {
                     : null;
                 state.overviewWarnings = Array.isArray(res && res.warnings) ? res.warnings : [];
                 state.lastLoadedAt = new Date().toISOString();
-                if (!state.selectedRunId && state.runs.length > 0) {
-                    state.selectedRunId = state.runs[0].runId || '';
-                }
                 const shouldRefreshSelectedDetail = !!state.selectedRunId
                     && (options.includeDetail !== false
                         || (state.selectedRunDetail && this.isTaskRunActive(state.selectedRunDetail && state.selectedRunDetail.run && state.selectedRunDetail.run.status)));
@@ -357,6 +365,7 @@ export function createTaskOrchestrationMethods(options = {}) {
             state.planIssues = [];
             state.planWarnings = [];
             state.lastError = '';
+            clearTaskRunSelectionForDraft(state);
             scrollTaskOrchestrationThreadToEnd();
             return true;
         },
@@ -391,6 +400,7 @@ export function createTaskOrchestrationMethods(options = {}) {
             if (state.planning) {
                 return null;
             }
+            clearTaskRunSelectionForDraft(state);
             state.planning = true;
             try {
                 const res = await api('task-plan', {

web-ui/partials/index/panel-orchestration.html

@@ -242,7 +242,7 @@
                                         </template>
                                     </section>
                                     <section
-                                        v-if="taskOrchestrationActiveQueue.length || taskOrchestration.runs.length || taskOrchestration.selectedRunId || taskOrchestration.selectedRunError"
+                                        v-if="taskOrchestrationWorkbenchVisible"
                                         class="selector-section task-workbench-card task-thread-message-card task-thread-workbench-card">
                                         <div class="task-thread-card-label">AI · {{ t('orchestration.workbench.title') }}</div>
                                         <div class="task-thread-run-summary">

web-ui/res/web-ui-render.precompiled.js

@@ -4446,7 +4446,7 @@ return function render(_ctx, _cache) {
                                   : _createCommentVNode("v-if", true)
                               ]))
                             : _createCommentVNode("v-if", true),
-                          (_ctx.taskOrchestrationActiveQueue.length || _ctx.taskOrchestration.runs.length || _ctx.taskOrchestration.selectedRunId || _ctx.taskOrchestration.selectedRunError)
+                          (_ctx.taskOrchestrationWorkbenchVisible)
                             ? (_openBlock(), _createElementBlock("section", {
                                 key: 4,
                                 class: "selector-section task-workbench-card task-thread-message-card task-thread-workbench-card"