@sleep2agi/agent-network-dashboard 0.6.3-preview.50 → 0.6.3-preview.52

package/tests/e2e-stage-a-node-list.spec.ts

@@ -40,16 +40,23 @@ const HUB_HEALTH = {
   },
 };
 
+// Login rate limit is 10/15min/IP (app/lib/rate-limit.ts): with 4 spec
+// files in one combined run, per-test logins blow the budget and late
+// tests land on the sign-in page (false red). Login once per worker.
+let cachedSessionCookie: string | null = null;
 async function login(context: Page['context'] extends () => infer C ? C : never) {
-  const res = await context.request.post(`${BASE}/api/auth/login`, {
-    data: { password: process.env.ANET_DASHBOARD_PASSWORD || 'admin123' },
-  });
-  const setCookie = res.headers()['set-cookie'] || '';
-  const m = setCookie.match(/anet_dashboard_session=([^;]+)/);
-  if (m) {
+  if (!cachedSessionCookie) {
+    const res = await context.request.post(`${BASE}/api/auth/login`, {
+      data: { password: process.env.ANET_DASHBOARD_PASSWORD || 'admin123' },
+    });
+    const setCookie = res.headers()['set-cookie'] || '';
+    const m = setCookie.match(/anet_dashboard_session=([^;]+)/);
+    if (m) cachedSessionCookie = decodeURIComponent(m[1]);
+  }
+  if (cachedSessionCookie) {
     await context.addCookies([{
       name: 'anet_dashboard_session',
-      value: decodeURIComponent(m[1]),
+      value: cachedSessionCookie,
       domain: new URL(BASE).hostname,
       path: '/',
     }]);
@@ -57,6 +64,10 @@ async function login(context: Page['context'] extends () => infer C ? C : never)
 }
 
 async function mockCommon(page: Page) {
+  // #Vincent auto-select (07-31): these suites exercise the table/filter
+  // (manage) view — opt into it explicitly now that /nodes defaults to
+  // conversation-first with auto-select.
+  await page.addInitScript(() => window.localStorage.setItem('anet-nodes-manage-view', '1'));
   await page.route('**/api/hub/status**', r =>
     r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(HUB_STATUS) }));
   await page.route('**/api/hub/nodes**', r =>

package/tests/e2e-stage-b-chat-pane.spec.ts

@@ -84,6 +84,15 @@ async function mockCommon(page: Page) {
     r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ messages: [] }) }));
 }
 
+
+// #Vincent auto-select (07-31): desktop /nodes now auto-selects the first
+// conversation. Tests that exercise the UNSELECTED table-on-entry state
+// opt into the persisted manage-view mode — the product's explicit doorway
+// to that state — instead of weakening assertions.
+async function manageMode(page: Page) {
+  await page.addInitScript(() => window.localStorage.setItem('anet-nodes-manage-view', '1'));
+}
+
 const pane = (page: Page) => page.locator('[data-testid="chat-pane"]');
 const card = (page: Page, alias: string) => page.locator(`[data-node-card][data-node-alias="${alias}"]`);
 
@@ -91,6 +100,7 @@ test.describe('Stage B — persistent chat pane + /nodes/[alias] routing', () =>
   test('clicking a node renders chat inline in the right pane and rewrites the URL', async ({ page, context }) => {
     await login(context);
     await mockCommon(page);
+    await manageMode(page);
     await page.goto(`${BASE}/nodes`);
     await expect(card(page, 'stage-b-1')).toBeVisible({ timeout: 15000 });
 
@@ -108,6 +118,7 @@ test.describe('Stage B — persistent chat pane + /nodes/[alias] routing', () =>
   test('clicking another node swaps the SAME pane in place (still exactly one)', async ({ page, context }) => {
     await login(context);
     await mockCommon(page);
+    await manageMode(page);
     await page.goto(`${BASE}/nodes`);
     await expect(card(page, 'stage-b-1')).toBeVisible({ timeout: 15000 });
 
@@ -142,22 +153,86 @@ test.describe('Stage B — persistent chat pane + /nodes/[alias] routing', () =>
     await expect(page).toHaveURL(`${BASE}/nodes`);
   });
 
-  test('< 768px: no right pane — chat opens as the full-screen overlay push', async ({ page, context }) => {
+  test('< 768px: two-level nav — list fullscreen, tap opens chat as a PAGE (no overlay), URL-addressable', async ({ page, context }) => {
     await login(context);
     await mockCommon(page);
+    await page.addInitScript(() => window.localStorage.setItem('anet-nodes-manage-view', '0'));
     await page.setViewportSize({ width: 390, height: 844 });
     await page.goto(`${BASE}/nodes`);
-    await expect(card(page, 'stage-b-1')).toBeVisible({ timeout: 15000 });
+    // Level 1: conversation list fullscreen; the table does NOT render;
+    // and mobile does NOT auto-select (desktop-only behavior — 通信龙:
+    // two correct behaviors, don't test one shape with the other's
+    // assertions). URL must stay /nodes.
+    const rail = page.locator('[data-testid="node-list-rail"]');
+    await expect(rail).toBeVisible({ timeout: 15000 });
+    await page.waitForTimeout(900);
+    await expect(page).toHaveURL(`${BASE}/nodes`);
+    const railBox = await rail.boundingBox();
+    expect(Math.abs(railBox!.width - 390)).toBeLessThanOrEqual(2);
+    await expect(page.locator('[data-node-card]')).toHaveCount(0);
+    await expect(page.locator('[data-node-list-item]')).toHaveCount(3);
 
-    await card(page, 'stage-b-1').click();
-    // Overlay shell (fixed drawer) mounts; persistent pane does not.
-    await expect(page.locator('.animate-slide-in')).toHaveCount(1);
-    await expect(pane(page)).toHaveCount(0);
-    // #Stage C only reshapes DESKTOP: the mobile middle column (with its
-    // node rows) keeps rendering under the overlay.
-    await expect(page.locator('[data-node-card]')).toHaveCount(3);
-    // Still URL-addressable on mobile.
+    // Level 2: tap → chat page (not overlay), back arrow present.
+    await page.locator('[data-node-list-item][data-node-list-alias="stage-b-1"]').click();
+    await expect(pane(page)).toBeVisible();
+    await expect(page.locator('.animate-slide-in')).toHaveCount(0);
+    const paneBox = await pane(page).boundingBox();
+    expect(Math.abs(paneBox!.width - 390)).toBeLessThanOrEqual(2);
+    await expect(rail).toHaveCount(0); // one level at a time
+    await expect(page.locator('[data-testid="chat-back"]')).toBeVisible();
     await expect(page).toHaveURL(`${BASE}/nodes/stage-b-1`);
+
+    // Back arrow returns to the list.
+    await page.locator('[data-testid="chat-back"]').click();
+    await expect(rail).toBeVisible();
+    await expect(page).toHaveURL(`${BASE}/nodes`);
+  });
+
+  test('< 768px: back (arrow AND browser) restores list scroll position within 200px', async ({ page, context }) => {
+    await login(context);
+    await mockWide(page); // 60 nodes — enough to have a real scroll offset
+    await page.addInitScript(() => window.localStorage.setItem('anet-nodes-manage-view', '0'));
+    await page.setViewportSize({ width: 390, height: 844 });
+    await page.goto(`${BASE}/nodes`);
+    const scroll = page.locator('[data-testid="node-list-scroll"]');
+    await expect(page.locator('[data-node-list-item]')).toHaveCount(60, { timeout: 15000 });
+
+    const target = page.locator('[data-node-list-item][data-node-list-alias="stage-d-50"]');
+    await target.scrollIntoViewIfNeeded();
+    const before = await scroll.evaluate(el => el.scrollTop);
+    expect(before).toBeGreaterThan(500); // sanity: we really are deep in the list
+
+    await target.click();
+    await expect(pane(page)).toBeVisible();
+    await page.locator('[data-testid="chat-back"]').click();
+    await expect(scroll).toBeVisible();
+    const afterArrow = await scroll.evaluate(el => el.scrollTop);
+    expect(Math.abs(afterArrow - before)).toBeLessThanOrEqual(200);
+
+    // Browser back behaves the same (判据: 行为一致).
+    await target.click();
+    await expect(pane(page)).toBeVisible();
+    await page.goBack();
+    await expect(scroll).toBeVisible();
+    const afterBack = await scroll.evaluate(el => el.scrollTop);
+    expect(Math.abs(afterBack - before)).toBeLessThanOrEqual(200);
+  });
+
+  test('< 768px: manage mode still reaches the table, with a way back to conversations', async ({ page, context }) => {
+    await login(context);
+    await mockCommon(page);
+    await page.addInitScript(() => window.localStorage.setItem('anet-nodes-manage-view', '1'));
+    await page.setViewportSize({ width: 390, height: 844 });
+    await page.goto(`${BASE}/nodes`);
+    // Fact-side positive: the table is genuinely there in manage mode
+    // (guards against "mobile hides table" being green because the table
+    // broke everywhere).
+    await expect(page.locator('[data-node-card]')).toHaveCount(3, { timeout: 15000 });
+    await expect(page.locator('[data-testid="manage-view-toggle-mobile"]')).toBeVisible();
+
+    await page.locator('[data-testid="manage-view-toggle-mobile"]').click();
+    await expect(page.locator('[data-testid="node-list-rail"]')).toBeVisible();
+    await expect(page.locator('[data-node-card]')).toHaveCount(0);
   });
 
   test('slow-load regression: 1.5s-delayed first /api/hub/status on a deep link → no crash page', async ({ page, context }) => {
@@ -188,6 +263,7 @@ test.describe('Stage B — persistent chat pane + /nodes/[alias] routing', () =>
   test('#Stage C: selected = list+chat (table gone), unselected = table back — BOTH directions asserted', async ({ page, context }) => {
     await login(context);
     await mockCommon(page);
+    await manageMode(page);
     await page.goto(`${BASE}/nodes`);
     // Direction 1 (positive, same source): unselected /nodes renders the table.
     await expect(card(page, 'stage-b-1')).toBeVisible({ timeout: 15000 });
@@ -209,6 +285,7 @@ test.describe('Stage B — persistent chat pane + /nodes/[alias] routing', () =>
   test('#Stage C: dense-view user (rail hidden) selecting a node force-shows the rail', async ({ page, context }) => {
     await login(context);
     await mockCommon(page);
+    await manageMode(page);
     await page.addInitScript(() => window.localStorage.setItem('anet-nodes-rail', '0'));
     await page.goto(`${BASE}/nodes`);
     await expect(card(page, 'stage-b-1')).toBeVisible({ timeout: 15000 });
@@ -314,6 +391,7 @@ test.describe('Stage D — per-column scrolling, page never scrolls', () => {
   test('unselected + 60 nodes: document still does not scroll; the MIDDLE column scrolls to the last card', async ({ page, context }) => {
     await login(context);
     await mockWide(page);
+    await manageMode(page);
     await page.goto(`${BASE}/nodes`);
     await expect(page.locator('[data-node-card]')).toHaveCount(WIDE_N, { timeout: 15000 });
 
@@ -436,6 +514,7 @@ test.describe('Stage D ③ — rail-top node search', () => {
   test('unselected state: rail search filters rail AND table together (Stage A invariant holds)', async ({ page, context }) => {
     await login(context);
     await mockSearch(page);
+    await manageMode(page);
     await page.goto(`${BASE}/nodes`);
     await expect(page.locator('[data-node-card]')).toHaveCount(3, { timeout: 15000 });
 
@@ -507,3 +586,91 @@ test.describe('Stage D — chat column fixed, message area scrolls inside', () =
     expect(box!.y + box!.height).toBeLessThanOrEqual(innerH);
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────
+// Vincent 插单 (07-31): desktop /nodes opens INTO a conversation.
+// Traps pinned: ① replace-not-push (back must LEAVE /nodes, not bounce),
+// ② the manage table keeps an explicit doorway, ③ an explicit ✕ is not
+// answered by an immediate re-select, plus empty-list safety.
+// ─────────────────────────────────────────────────────────────────────
+test.describe('auto-select first conversation on /nodes (desktop)', () => {
+  test('entering /nodes lands in the first conversation: URL rewritten, table yields', async ({ page, context }) => {
+    await login(context);
+    await mockCommon(page);
+    await page.goto(`${BASE}/nodes`);
+    await expect(pane(page)).toBeVisible({ timeout: 15000 });
+    await expect(page).toHaveURL(/\/nodes\/[^/]+$/);
+    await expect(page.locator('[data-node-card]')).toHaveCount(0);
+    // deterministic first pick under this fixture's sort
+    await expect(pane(page)).toHaveAttribute('data-chat-alias', 'stage-b-1');
+  });
+
+  test('browser back LEAVES /nodes (auto-select uses replace, not push)', async ({ page, context }) => {
+    await login(context);
+    await mockCommon(page);
+    await page.goto(`${BASE}/tasks`);
+    await page.goto(`${BASE}/nodes`);
+    await expect(pane(page)).toBeVisible({ timeout: 15000 });
+    await expect(page).toHaveURL(/\/nodes\/[^/]+$/);
+
+    await page.goBack();
+    // With push instead of replace this bounces straight back into
+    // /nodes/<alias> — the assertion below goes red (sabotage-verified).
+    await expect(page).toHaveURL(`${BASE}/tasks`, { timeout: 10000 });
+  });
+
+  test('explicit ✕ close sticks: no immediate re-select', async ({ page, context }) => {
+    await login(context);
+    await mockCommon(page);
+    await page.goto(`${BASE}/nodes`);
+    await expect(pane(page)).toBeVisible({ timeout: 15000 });
+
+    await page.locator('[data-testid="chat-pane-close"]').click();
+    await expect(pane(page)).toHaveCount(0);
+    await expect(page).toHaveURL(`${BASE}/nodes`);
+    await expect(page.locator('[data-node-card]')).toHaveCount(3);
+    await page.waitForTimeout(900);
+    await expect(pane(page)).toHaveCount(0); // still closed — ✕ won
+  });
+
+  test('manage-view doorway: toggle to table, persists across reload, toggles back to conversation', async ({ page, context }) => {
+    await login(context);
+    await mockCommon(page);
+    await page.goto(`${BASE}/nodes`);
+    await expect(pane(page)).toBeVisible({ timeout: 15000 });
+
+    await page.locator('[data-testid="manage-view-toggle"]').click();
+    await expect(pane(page)).toHaveCount(0);
+    await expect(page.locator('[data-node-card]')).toHaveCount(3);
+
+    await page.goto(`${BASE}/nodes`); // persisted preference: table default, no auto-select
+    await expect(page.locator('[data-node-card]')).toHaveCount(3, { timeout: 15000 });
+    await page.waitForTimeout(900);
+    await expect(pane(page)).toHaveCount(0);
+
+    await page.locator('[data-testid="manage-view-toggle"]').click(); // 对话视图
+    await expect(pane(page)).toBeVisible();
+    await expect(page).toHaveURL(/\/nodes\/[^/]+$/);
+  });
+
+  test('empty list: no crash, no loop, URL stays /nodes', async ({ page, context }) => {
+    await login(context);
+    await page.route('**/api/hub/status**', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ sessions: [] }) }));
+    await page.route('**/api/hub/nodes**', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ nodes: [] }) }));
+    await page.route('**/api/hub/health', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ ok: true, sse_sessions: {} }) }));
+    await page.route('**/api/hub/tasks**', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ tasks: [] }) }));
+    await page.route('**/api/hub/stats**', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) }));
+    await page.route('**/api/hub/messages**', r =>
+      r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ messages: [] }) }));
+    await page.goto(`${BASE}/nodes`);
+    await page.waitForTimeout(2500);
+    await expect(page).toHaveURL(`${BASE}/nodes`);
+    await expect(pane(page)).toHaveCount(0);
+    await expect(page.locator("text=This page couldn’t load")).toHaveCount(0);
+  });
+});

package/tests/e2e-status-labels.spec.ts

@@ -0,0 +1,218 @@
+import { test, expect, Page } from '@playwright/test';
+
+const BASE = process.env.TEST_URL || 'http://localhost:3100';
+
+// 通信龙 07-31 GAP 2nd tier: message status → human labels.
+//
+// This spec asserts BOTH:
+//   (A) each known status renders the exact expected Chinese label,
+//       NOT the raw English word ("已推送", not "delivered")
+//   (B) an unknown status (hub adds a new one; front-end hasn't caught
+//       up) is rendered fail-loudly — the raw string is visible AND a
+//       "未知状态" banner appears in the hover text
+//   (C) failed with `result` renders inline reason (first 40 chars);
+//       failed without `result` renders "节点未提供原因". Both branches
+//       — because a test that only covers "with reason" would let an
+//       empty-result bug fall back to "未知错误" silently.
+//
+// Injection strategy: /api/hub/tasks?to_name=... is the message-list
+// endpoint (grepped from TaskChatPanel.tsx:686). We stub it with an
+// array of tasks, one per status, and read the rendered labels off
+// data-status-key / data-status-label attributes. NO mock of the
+// component itself — the render is the wire under test.
+//
+// Note on `chat-pane` gate: TaskChatPanel is inside the ChatPane
+// column, which mounts on /nodes/<alias>. We goto /nodes/node-a to
+// force ChatPane mount, then feed all the varying-status tasks as
+// to_name=node-a so they all render in that chat.
+
+let cachedCookie: string | undefined;
+
+async function login(context: Page['context'] extends () => infer C ? C : never) {
+  if (cachedCookie) {
+    await context.addCookies([{
+      name: 'anet_dashboard_session',
+      value: cachedCookie,
+      domain: new URL(BASE).hostname,
+      path: '/',
+    }]);
+    return;
+  }
+  const res = await context.request.post(`${BASE}/api/auth/login`, {
+    data: { password: process.env.ANET_DASHBOARD_PASSWORD || 'admin123' },
+  });
+  const setCookie = res.headers()['set-cookie'] || '';
+  const m = setCookie.match(/anet_dashboard_session=([^;]+)/);
+  if (m) {
+    cachedCookie = decodeURIComponent(m[1]);
+    await context.addCookies([{
+      name: 'anet_dashboard_session',
+      value: cachedCookie,
+      domain: new URL(BASE).hostname,
+      path: '/',
+    }]);
+  }
+}
+
+// One-line-per-status expectation table. Duplicated deliberately from
+// the component — a test that reads the label out of STATUS_INFO would
+// prove nothing (it'd assert the map equals itself). These strings ARE
+// the contract 通信龙 signed off on; if they change, this test reds.
+const CASES: Array<{ status: string; label: string; hoverContains: string; known: boolean }> = [
+  { status: 'queued',    label: '排队中', hoverContains: '已入队，尚未推给节点',       known: true },
+  { status: 'delivered', label: '已推送', hoverContains: 'hub 侧已标记推送',            known: true },
+  { status: 'acked',     label: '已接收', hoverContains: '未必已处理',                  known: true },
+  { status: 'replied',   label: '已回复', hoverContains: '对方已针对此消息回复',        known: true },
+  { status: 'failed',    label: '失败',   hoverContains: '发送失败',                    known: true },
+  { status: 'created',   label: '发送中', hoverContains: '客户端已建消息',              known: true },
+  { status: 'closed',    label: '已关闭', hoverContains: '会话已被关闭',                known: true },
+  { status: 'expired',   label: '已超时', hoverContains: '在期限内未收到回复',          known: true },
+  { status: 'cancelled', label: '已取消', hoverContains: '任务被主动取消',              known: true },
+  { status: 'nonsense_hub_added_a_new_code', label: 'nonsense_hub_added_a_new_code', hoverContains: '未知状态', known: false },
+];
+
+function makeFixtureTasks() {
+  return CASES.map((c, i) => ({
+    task_id: `t_${c.status}_${i}`,
+    from_node_id: 'n_a',
+    from_name: 'node-a',
+    to_node_id: 'n_a',
+    to_name: 'node-a',
+    priority: 'normal',
+    status: c.status,
+    content: `case-${c.status}`,
+    result: '',
+    in_reply_to: null,
+    requires_response: 0,
+    scope: 'inbox',
+    created_at: `2026-07-31T10:0${i}:00`,
+    delivered_at: `2026-07-31T10:0${i}:00`,
+    started_at: null,
+    completed_at: null,
+    expires_at: null,
+    meta_json: null,
+  }));
+}
+
+async function stubHub(page: Page, tasks: object[]) {
+  await page.route('**/api/hub/status**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json',
+      body: JSON.stringify({ sessions: [{ alias: 'node-a', status: 'idle', network_id: 'net_x' }] }) }));
+  await page.route('**/api/hub/nodes**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json',
+      body: JSON.stringify({ nodes: [{ alias: 'node-a', node_id: 'n_a', team: null, tags: [], attrs_revision: 0 }] }) }));
+  await page.route('**/api/hub/networks**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json',
+      body: JSON.stringify({ networks: [{ network_id: 'net_x', network_name: 'net_x' }] }) }));
+  await page.route('**/api/hub/health', r =>
+    r.fulfill({ status: 200, contentType: 'application/json',
+      body: JSON.stringify({ ok: true, version: '0.9.0-test', sse_connections: 1, sse_sessions: { 'net_x:node-a': 1 } }) }));
+  await page.route('**/api/hub/stats**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) }));
+  await page.route('**/api/hub/messages**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ messages: [] }) }));
+  await page.route('**/api/hub/events**', r =>
+    r.fulfill({ status: 200, contentType: 'text/event-stream', body: '' }));
+  // /api/hub/tasks — TaskChatPanel:686 uses this for the message list.
+  // Return our fixture regardless of query args (to_name, task_id, etc).
+  await page.route('**/api/hub/tasks**', r =>
+    r.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ tasks }) }));
+}
+
+test.describe('Status labels — per-status render + unknown fail-loudly + failed both branches', () => {
+  test('every known status renders its exact Chinese label with matching hover text', async ({ page, context }) => {
+    await login(context);
+    await stubHub(page, makeFixtureTasks());
+    await page.goto(`${BASE}/nodes/node-a`);
+    await expect(page.locator('[data-testid="chat-pane"]').first()).toBeVisible({ timeout: 15000 });
+
+    // Premise: at least CASES.length StatusBars rendered — else we'd
+    // be asserting into an empty page (see feedback_checker_scope_bug_vacuous_pass).
+    const anyStatusBar = page.locator('[data-status-key]');
+    await expect(anyStatusBar.first()).toBeVisible({ timeout: 10000 });
+    const rendered = await anyStatusBar.count();
+    expect(rendered, `expected at least ${CASES.length} StatusBar renders (one per case), got ${rendered}`)
+      .toBeGreaterThanOrEqual(CASES.length);
+
+    // Now assert each case individually. Locate by data-status-key
+    // (unique per status in our fixture).
+    for (const c of CASES) {
+      const bar = page.locator(`[data-status-key="${c.status}"]`).first();
+      await expect(bar).toBeVisible();
+
+      // (A) label text is the exact Chinese string (or raw for unknown).
+      const labelAttr = await bar.getAttribute('data-status-label');
+      expect(labelAttr, `${c.status} label attr`).toBe(c.label);
+
+      const visibleText = await bar.locator('span').first().textContent();
+      expect(visibleText?.trim(), `${c.status} rendered text`).toContain(c.label);
+
+      // (A cont.) known/unknown attr matches expectation.
+      const knownAttr = await bar.getAttribute('data-status-known');
+      expect(knownAttr, `${c.status} known attr`).toBe(c.known ? 'true' : 'false');
+
+      // (B) hover title contains the semantic-specific string.
+      const titleAttr = await bar.locator('span[title]').first().getAttribute('title');
+      expect(titleAttr ?? '', `${c.status} hover text`).toContain(c.hoverContains);
+    }
+  });
+
+  test('failed WITH result renders inline reason (first 40 chars)', async ({ page, context }) => {
+    await login(context);
+    const REASON = 'codex-sdk 返回空响应 (in=15806 out=19) — 疑似 vendor 静默限流/配额';
+    const tasks = [{
+      task_id: 't_failed_with_reason', from_node_id: 'n_a', from_name: 'node-a',
+      to_node_id: 'n_a', to_name: 'node-a', priority: 'normal', status: 'failed',
+      content: 'failed case', result: REASON, in_reply_to: null,
+      requires_response: 0, scope: 'inbox',
+      created_at: '2026-07-31T10:00:00', delivered_at: '2026-07-31T10:00:00',
+      started_at: null, completed_at: null, expires_at: null, meta_json: null,
+    }];
+    await stubHub(page, tasks);
+    await page.goto(`${BASE}/nodes/node-a`);
+    await expect(page.locator('[data-testid="chat-pane"]').first()).toBeVisible({ timeout: 15000 });
+
+    const bar = page.locator('[data-status-key="failed"]').first();
+    await expect(bar).toBeVisible({ timeout: 10000 });
+
+    // Premise: `result` on the fixture is a specific non-empty string.
+    // If our stub fails to reach the component, the reason element
+    // would still exist with '节点未提供原因' — that'd look like a
+    // "wrong branch chosen" bug rather than "fixture never landed".
+    // Asserting the exact first-40 slice catches both.
+    const reason = bar.locator('[data-status-reason]');
+    await expect(reason).toBeVisible();
+    const reasonAttr = await reason.getAttribute('data-status-reason');
+    const expected40 = REASON.slice(0, 40);
+    expect(reasonAttr, `first-40 slice of "${REASON}"`).toBe(expected40);
+    // Visible text mirrors the attribute (truncated via CSS if wider).
+    expect(await reason.textContent()).toContain(expected40);
+  });
+
+  test('failed WITHOUT result renders "节点未提供原因" (not silently blank, not "未知错误")', async ({ page, context }) => {
+    await login(context);
+    const tasks = [{
+      task_id: 't_failed_no_reason', from_node_id: 'n_a', from_name: 'node-a',
+      to_node_id: 'n_a', to_name: 'node-a', priority: 'normal', status: 'failed',
+      content: 'failed no reason', result: '',  // ← explicit empty
+      in_reply_to: null, requires_response: 0, scope: 'inbox',
+      created_at: '2026-07-31T10:00:00', delivered_at: '2026-07-31T10:00:00',
+      started_at: null, completed_at: null, expires_at: null, meta_json: null,
+    }];
+    await stubHub(page, tasks);
+    await page.goto(`${BASE}/nodes/node-a`);
+    await expect(page.locator('[data-testid="chat-pane"]').first()).toBeVisible({ timeout: 15000 });
+
+    const bar = page.locator('[data-status-key="failed"]').first();
+    await expect(bar).toBeVisible({ timeout: 10000 });
+
+    const reason = bar.locator('[data-status-reason]');
+    await expect(reason).toBeVisible();
+    const reasonAttr = await reason.getAttribute('data-status-reason');
+    expect(reasonAttr).toBe('节点未提供原因');
+    // Specifically NOT the "未知错误" placeholder — that would obscure
+    // the distinction between "hub has no reason field" and "reason
+    // exists but was bad", which is the whole point of separating them.
+    expect(reasonAttr).not.toContain('未知错误');
+  });
+});