@polderlabs/bizar 6.3.0 → 7.0.1

package/bizar-dash/tests/views/Overview.test.tsx

@@ -0,0 +1,413 @@
+/**
+ * tests/views/Overview.test.tsx
+ *
+ * Wave 3 — Overview redesign smoke tests. Covers:
+ *   - The new Overview mounts without crashing given a populated snapshot.
+ *   - The five stat tiles render the correct labelled values.
+ *   - The activity stream renders rows from the snapshot seed.
+ *   - Per-row hide toggle POSTs to /activity/hide with the correct key.
+ *   - "Hide all" calls POST /activity/hide with the full list of keys.
+ *   - The SSE subscription is established (mock EventSource) but never actually fires.
+ *   - Clicking the submit button calls /tasks/submit.
+ *
+ * Notes:
+ *   - EventSource is mocked globally (no listener fires in jsdom).
+ *   - api is mocked so no network is attempted.
+ *   - ThemeProvider + ToastProvider + ModalProvider wrap the view so the
+ *     helpers the Overview calls (useToast / useModal) get a real context.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+
+import { Overview } from '../../src/web/views/Overview';
+import { ToastProvider } from '../../src/web/components/Toast';
+import { ModalProvider } from '../../src/web/components/Modal';
+
+import type {
+  ActivityItem,
+  Agent,
+  Artifact,
+  Mod,
+  Overview as OverviewData,
+  ProjectRecord,
+  Settings,
+  Snapshot,
+  Task,
+} from '../../src/web/lib/types';
+import { api } from '../../src/web/lib/api';
+
+// ─── Mocks ──────────────────────────────────────────────────────────────────
+
+class MockEventSource {
+  url: string;
+  readyState = 0;
+  listeners: Record<string, ((e: MessageEvent) => void)[]> = {};
+  onerror: ((e: Event) => void) | null = null;
+  constructor(url: string) {
+    this.url = url;
+    MockEventSource.instances.push(this);
+  }
+  addEventListener(name: string, cb: (e: MessageEvent) => void) {
+    (this.listeners[name] ||= []).push(cb);
+  }
+  removeEventListener() { /* noop for tests */ }
+  close() {
+    this.readyState = 2;
+  }
+  // Test helpers — manually dispatch like a real server would.
+  __dispatch(name: string, data: unknown) {
+    const ev = { data: JSON.stringify(data) } as MessageEvent;
+    this.listeners[name]?.forEach((cb) => cb(ev));
+  }
+}
+(MockEventSource as unknown as { instances: MockEventSource[] }).instances = [];
+
+vi.stubGlobal('EventSource', MockEventSource);
+
+vi.mock('../../src/web/lib/api', () => {
+  return {
+    api: {
+      get: vi.fn(),
+      post: vi.fn(),
+      put: vi.fn(),
+      patch: vi.fn(),
+      del: vi.fn(),
+      getToken: vi.fn(() => ''),
+      setToken: vi.fn(),
+      probeAuthStatus: vi.fn(),
+    },
+    ApiError: class ApiError extends Error {
+      status: number;
+      constructor(status: number, message: string) {
+        super(message);
+        this.status = status;
+      }
+    },
+  };
+});
+
+const Harness: React.FC<{ children: React.ReactNode }> = ({ children }) => (
+  <ToastProvider>
+    <ModalProvider>{children}</ModalProvider>
+  </ToastProvider>
+);
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+function makeOverview(overrides: Partial<OverviewData> = {}): OverviewData {
+  return {
+    counts: {
+      agents: 7,
+      plans: 4,
+      projects: 3,
+      sessions: 2,
+      activeProject: 'p-1',
+      ...(overrides.counts ?? {}),
+    },
+    recentActivity: overrides.recentActivity ?? [
+      {
+        ts: new Date().toISOString(),
+        kind: 'task.created',
+        title: 'Build settings page',
+      } as unknown as ActivityItem,
+      {
+        ts: new Date(Date.now() - 5 * 60_000).toISOString(),
+        kind: 'agent.delegated',
+        agent: 'thor',
+      } as unknown as ActivityItem,
+    ],
+    versions: {
+      node: 'v20.10.0',
+      platform: 'linux',
+      projectRoot: '/srv/bizar',
+      bizarRoot: '/home/user/.bizar',
+      ...(overrides.versions ?? {}),
+    },
+    generatedAt: new Date().toISOString(),
+    ...overrides,
+  } as OverviewData;
+}
+
+function makeSnapshot(overrides: Partial<Snapshot> = {}): Snapshot {
+  return {
+    overview: makeOverview(),
+    agents: [] as Agent[],
+    artifacts: [] as Artifact[],
+    projects: [
+      { id: 'p-1', name: 'Bizar', path: '/srv/bizar', status: 'active' },
+      { id: 'p-2', name: 'Spar', path: '/srv/spar', status: 'inactive' },
+    ] as ProjectRecord[],
+    activeProject: {
+      id: 'p-1',
+      name: 'Bizar',
+      path: '/srv/bizar',
+      status: 'active',
+    } as ProjectRecord,
+    config: { path: '', data: {}, raw: '', exists: true },
+    settings: { path: '', data: {} as Settings, exists: true },
+    tasks: [
+      {
+        id: 't-1',
+        title: 'Refactor parser',
+        description: '',
+        status: 'doing',
+        tags: [],
+        priority: 'normal',
+        assignee: 'thor',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      } as Task,
+      {
+        id: 't-2',
+        title: 'Add schema check',
+        description: '',
+        status: 'queued',
+        tags: [],
+        priority: 'normal',
+        assignee: 'heimdall',
+        createdAt: new Date(Date.now() - 2 * 24 * 3600_000).toISOString(),
+        updatedAt: new Date(Date.now() - 24 * 3600_000).toISOString(),
+      } as Task,
+    ],
+    mods: [
+      {
+        id: 'm-1',
+        name: 'graphify',
+        version: '1.0.0',
+        author: 'bizar',
+        description: '',
+        bizar: '',
+        type: 'tool',
+        enabled: true,
+        permissions: [],
+        entry: {},
+        files: [],
+        path: '/mods/graphify',
+        installedAt: null,
+      } as Mod,
+      {
+        id: 'm-2',
+        name: 'headroom',
+        version: '0.4.0',
+        author: 'bizar',
+        description: '',
+        bizar: '',
+        type: 'service',
+        enabled: false,
+        permissions: [],
+        entry: {},
+        files: [],
+        path: '/mods/headroom',
+        installedAt: null,
+      } as Mod,
+    ],
+    schedules: [],
+    providers: [],
+    mcps: [],
+    ...overrides,
+  };
+}
+
+const baseSettings = {
+  theme: { mode: 'system' as const, accent: '', success: '', warning: '', error: '', info: '', fontFamily: '', fontSize: 13, compactMode: false, animations: true },
+  ui: { layout: 'both' as const, showHeader: true, showStatusBar: true, defaultTab: 'overview' },
+  defaultAgent: 'odin',
+  defaultModel: 'claude-opus-4',
+  notifications: { onAgentComplete: false, onPlanApproval: false },
+  dashboard: { autoLaunchWeb: false, projectsDirectory: '/srv' },
+  service: { enabled: false, autostart: false },
+  about: { version: 'v6.5.0', homepage: '', license: '' },
+  agents: { maxParallel: 3, stuckThresholdMs: 60_000, autoRestart: false },
+  personalization: { displayName: '', role: '', team: '', aboutMe: '', preferences: '' },
+  workflow: { artifactsEnabled: true, agentsDecideAutonomously: false, chatAutonomous: false },
+} as unknown as Settings;
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('Overview (Wave 3 redesign)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    MockEventSource.instances.length = 0;
+    (api.get as ReturnType<typeof vi.fn>).mockImplementation((url: string) => {
+      if (url === '/activity/hidden') return Promise.resolve({ hidden: [] });
+      return Promise.resolve(null);
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('mounts without crashing and establishes the SSE subscription', async () => {
+    const snapshot = makeSnapshot();
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={vi.fn(async () => undefined)}
+        />
+      </Harness>,
+    );
+
+    expect(await screen.findByTestId('overview-stat-row')).toBeInTheDocument();
+    expect(MockEventSource.instances).toHaveLength(1);
+    expect(MockEventSource.instances[0].url).toBe('/api/activity/stream');
+  });
+
+  it('renders all five stat tiles with the correct values', async () => {
+    const snapshot = makeSnapshot({
+      overview: makeOverview({
+        counts: { agents: 7, plans: 4, projects: 3, sessions: 2, activeProject: 'p-1' },
+      }),
+    });
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={vi.fn(async () => undefined)}
+        />
+      </Harness>,
+    );
+
+    // StatTile doesn't forward data-testid; find tiles by their label
+    // text. Labels are sentence-cased in DOM, uppercase via CSS.
+    expect(await screen.findByText('Agents')).toBeInTheDocument();
+    expect(screen.getByText('Tasks')).toBeInTheDocument();
+    expect(screen.getByText('Projects')).toBeInTheDocument();
+    expect(screen.getByText('Mods')).toBeInTheDocument();
+    expect(screen.getByText('Background')).toBeInTheDocument();
+
+    // 7 agents, 2 tasks, 2 projects, 2 mods, 2 background
+    const row = await screen.findByTestId('overview-stat-row');
+    expect(within(row).getByText('7')).toBeInTheDocument();
+    // The number "2" appears multiple times (tasks, projects, mods, background)
+    const twos = within(row).getAllByText('2');
+    expect(twos.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it('renders activity rows from the snapshot seed', async () => {
+    const snapshot = makeSnapshot({
+      overview: makeOverview({
+        recentActivity: [
+          { ts: new Date().toISOString(), kind: 'task.created', title: 'Build settings page' } as ActivityItem,
+          { ts: new Date().toISOString(), kind: 'agent.delegated', agent: 'thor' } as ActivityItem,
+        ],
+      }),
+    });
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={vi.fn(async () => undefined)}
+        />
+      </Harness>,
+    );
+
+    const list = await screen.findByTestId('overview-activity-list');
+    expect(within(list).getByText(/Task created/i)).toBeInTheDocument();
+    expect(within(list).getByText(/Agent delegated/i)).toBeInTheDocument();
+  });
+
+  it('hides a single activity row when its icon button is clicked', async () => {
+    (api.post as ReturnType<typeof vi.fn>).mockResolvedValue({ ok: true });
+    const user = userEvent.setup();
+    const snapshot = makeSnapshot();
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={vi.fn(async () => undefined)}
+        />
+      </Harness>,
+    );
+
+    const list = await screen.findByTestId('overview-activity-list');
+    const hideButtons = within(list).getAllByRole('button', { name: /hide from overview/i });
+    expect(hideButtons.length).toBeGreaterThan(0);
+
+    await user.click(hideButtons[0]);
+
+    await waitFor(() => {
+      expect(api.post).toHaveBeenCalledWith(
+        '/activity/hide',
+        expect.objectContaining({ keys: expect.any(Array) }),
+      );
+    });
+  });
+
+  it('posts the full list of keys when "Hide all" is clicked', async () => {
+    const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+    (api.post as ReturnType<typeof vi.fn>).mockResolvedValue({ ok: true });
+    const user = userEvent.setup();
+    const snapshot = makeSnapshot();
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={vi.fn(async () => undefined)}
+        />
+      </Harness>,
+    );
+
+    await user.click(await screen.findByTestId('overview-hide-all'));
+
+    await waitFor(() => {
+      const calls = (api.post as ReturnType<typeof vi.fn>).mock.calls;
+      const hideCall = calls.find(([url]: unknown[]) => url === '/activity/hide');
+      expect(hideCall).toBeDefined();
+      const body = hideCall?.[1] as { keys: string[] };
+      expect(Array.isArray(body.keys)).toBe(true);
+      expect(body.keys.length).toBeGreaterThan(0);
+    });
+
+    confirmSpy.mockRestore();
+  });
+
+  it('calls /tasks/submit when the "Submit to Odin" button is clicked', async () => {
+    (api.post as ReturnType<typeof vi.fn>).mockResolvedValue({ subtasks: [{}, {}] });
+    const user = userEvent.setup();
+    const refresh = vi.fn(async () => undefined);
+    const snapshot = makeSnapshot();
+
+    render(
+      <Harness>
+        <Overview
+          snapshot={snapshot}
+          settings={baseSettings}
+          activeTab="overview"
+          setActiveTab={vi.fn()}
+          refreshSnapshot={refresh}
+        />
+      </Harness>,
+    );
+
+    const textarea = await screen.findByTestId('overview-prompt-input');
+    await user.type(textarea, 'Build a thing');
+    await user.click(screen.getByTestId('overview-submit'));
+
+    await waitFor(() => {
+      expect(api.post).toHaveBeenCalledWith(
+        '/tasks/submit',
+        expect.objectContaining({ title: expect.stringContaining('Build a thing') }),
+      );
+    });
+  });
+});

package/bizar-dash/tests/views/Tasks.test.tsx

@@ -0,0 +1,250 @@
+/**
+ * tests/views/Tasks.test.tsx
+ *
+ * Wave 3 redesign — exercises the new design-system kanban board:
+ *   1. All 5 columns (Todo / In progress / Done / Failed / Backlog) appear.
+ *   2. Each column's task count matches the snapshot.
+ *   3. Priority filter narrows the visible task set across columns.
+ *   4. Clicking a task row fires `onTaskClick` (i.e. opens the edit modal).
+ *   5. Search input filters tasks by title (case-insensitive).
+ *
+ * Stubs `api.get` via vi.mock so the view boots from a synthetic snapshot.
+ * The legacy `Modal` and `BacklogPanel` are still imported — Modal because
+ * the redesigned view still uses it for the create/edit dialogs, and
+ * BacklogPanel because the prop contract is preserved across this wave.
+ */
+import React from 'react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { ToastProvider } from '../../src/web/components/Toast';
+import { ModalProvider } from '../../src/web/components/Modal';
+import { Tasks } from '../../src/web/views/Tasks';
+import { api } from '../../src/web/lib/api';
+import type { Settings, Snapshot, Task } from '../../src/web/lib/types';
+
+vi.mock('../../src/web/lib/api', () => {
+  const get = vi.fn();
+  const post = vi.fn();
+  const put = vi.fn();
+  const patch = vi.fn();
+  const del = vi.fn();
+  return {
+    api: { get, post, put, patch, del, setToken: vi.fn(), probeAuthStatus: vi.fn() },
+    ApiError: class ApiError extends Error {
+      status: number;
+      constructor(status: number, message: string) {
+        super(message);
+        this.status = status;
+      }
+    },
+    enhancePrompt: vi.fn(async (t: string) => t),
+  };
+});
+
+const SETTINGS = {} as Settings;
+
+function makeSnapshot(tasks: Task[]): Snapshot {
+  return {
+    tasks,
+    agents: [],
+    overview: {} as Snapshot['overview'],
+    artifacts: [],
+    projects: [],
+    activeProject: null,
+    config: {} as Snapshot['config'],
+    settings: {} as Snapshot['settings'],
+    mods: [],
+    schedules: [],
+    providers: [],
+    mcps: [],
+  };
+}
+
+function mkTask(over: Partial<Task> = {}): Task {
+  return {
+    id: over.id ?? `t-${Math.random().toString(36).slice(2, 8)}`,
+    title: over.title ?? 'Untitled task',
+    description: over.description ?? '',
+    status: over.status ?? 'queued',
+    priority: over.priority ?? 'normal',
+    tags: over.tags ?? [],
+    createdAt: over.createdAt ?? '2026-07-12T10:00:00.000Z',
+    updatedAt: over.updatedAt ?? '2026-07-12T10:00:00.000Z',
+    workedBy: over.workedBy ?? null,
+    assignee: over.assignee ?? null,
+  };
+}
+
+const Harness = ({ children }: { children: React.ReactNode }) => (
+  <ToastProvider>
+    <ModalProvider>{children}</ModalProvider>
+  </ToastProvider>
+);
+
+function renderTasks(snapshot: Snapshot, props: Partial<React.ComponentProps<typeof Tasks>> = {}) {
+  const refresh = vi.fn(async () => undefined);
+  const setActiveTab = vi.fn();
+  return render(
+    <Harness>
+      <Tasks
+        snapshot={snapshot}
+        settings={SETTINGS}
+        activeTab="tasks"
+        setActiveTab={setActiveTab}
+        refreshSnapshot={refresh}
+        {...props}
+      />
+    </Harness>,
+  );
+}
+
+describe('Tasks view — Wave 3 redesign', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: api.get returns nothing (the view uses snapshot.tasks)
+    (api.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+  });
+
+  it('renders all 5 columns (Todo, In progress, Done, Failed, Backlog)', () => {
+    const tasks: Task[] = [
+      mkTask({ id: 'a', title: 'Alpha', status: 'queued' }),
+      mkTask({ id: 'b', title: 'Beta', status: 'doing' }),
+      mkTask({ id: 'c', title: 'Gamma', status: 'done' }),
+      mkTask({ id: 'd', title: 'Delta', status: 'blocked' }),
+      mkTask({ id: 'e', title: 'Epsilon', status: 'backlog' }),
+    ];
+    renderTasks(makeSnapshot(tasks));
+    // The column label appears in both the column header AND the per-row
+    // status badge. Use getAllByText so the assertion is "at least one".
+    expect(screen.getAllByText('Todo').length).toBeGreaterThan(0);
+    expect(screen.getAllByText('In progress').length).toBeGreaterThan(0);
+    expect(screen.getAllByText('Done').length).toBeGreaterThan(0);
+    expect(screen.getAllByText('Failed').length).toBeGreaterThan(0);
+    expect(screen.getAllByText('Backlog').length).toBeGreaterThan(0);
+  });
+
+  it('reports the correct task count per column', () => {
+    const tasks: Task[] = [
+      mkTask({ id: 'a', status: 'queued' }),
+      mkTask({ id: 'b', status: 'queued' }),
+      mkTask({ id: 'c', status: 'queued' }),
+      mkTask({ id: 'd', status: 'doing' }),
+      mkTask({ id: 'e', status: 'doing' }),
+      mkTask({ id: 'f', status: 'done' }),
+      mkTask({ id: 'g', status: 'blocked' }),
+    ];
+    renderTasks(makeSnapshot(tasks));
+
+    // Each of the 4 rendered columns (Todo / In progress / Done / Failed)
+    // exposes its count as a tabular-nums span with an aria-label like
+    // "3 tasks". The Backlog column is rendered separately by BacklogPanel
+    // (legacy) and is not part of this assertion.
+    const countByLabel = (label: string): number =>
+      screen.getAllByLabelText(label).length;
+    expect(countByLabel('3 tasks')).toBe(1); // Todo
+    expect(countByLabel('2 tasks')).toBe(1); // In progress
+    expect(countByLabel('1 tasks')).toBe(2); // Done + Failed (both have 1)
+  });
+
+  it('priority filter narrows results across all columns', async () => {
+    const tasks: Task[] = [
+      mkTask({ id: 'h1', title: 'Hot', status: 'queued', priority: 'high' }),
+      mkTask({ id: 'h2', title: 'Hot 2', status: 'doing', priority: 'high' }),
+      mkTask({ id: 'n1', title: 'Normal', status: 'queued', priority: 'normal' }),
+      mkTask({ id: 'l1', title: 'Low', status: 'done', priority: 'low' }),
+    ];
+    const user = userEvent.setup();
+    renderTasks(makeSnapshot(tasks));
+
+    // Initially all 4 visible.
+    expect(screen.getByText('Hot')).toBeInTheDocument();
+    expect(screen.getByText('Hot 2')).toBeInTheDocument();
+    expect(screen.getByText('Normal')).toBeInTheDocument();
+    expect(screen.getByText('Low')).toBeInTheDocument();
+
+    // The Select component wraps the native <select> in a <span>; the
+    // priority label is wired via aria-labelledby on the wrapper. Reach the
+    // inner <select> through the labelled container.
+    const priorityWrapper = screen.getByLabelText(/priority/i);
+    const prioritySelect = priorityWrapper.querySelector('select') as HTMLSelectElement;
+    expect(prioritySelect).toBeInTheDocument();
+    await user.selectOptions(prioritySelect, 'high');
+
+    await waitFor(() => {
+      expect(screen.getByText('Hot')).toBeInTheDocument();
+      expect(screen.getByText('Hot 2')).toBeInTheDocument();
+    });
+    expect(screen.queryByText('Normal')).not.toBeInTheDocument();
+    expect(screen.queryByText('Low')).not.toBeInTheDocument();
+
+    // Reset to All — Low / Normal return.
+    await user.selectOptions(prioritySelect, '');
+    await waitFor(() => {
+      expect(screen.getByText('Normal')).toBeInTheDocument();
+      expect(screen.getByText('Low')).toBeInTheDocument();
+    });
+  });
+
+  it('clicking a task row opens the edit modal (fires onTaskClick)', async () => {
+    const task = mkTask({ id: 'edit-me', title: 'Click to edit me', status: 'queued' });
+    const user = userEvent.setup();
+    renderTasks(makeSnapshot([task]));
+
+    const row = screen.getByText('Click to edit me');
+    // The title lives inside the row; click the row container.
+    const rowEl = row.closest('[data-task-id="edit-me"]');
+    expect(rowEl).not.toBeNull();
+    await user.click(rowEl as HTMLElement);
+
+    // The edit modal opens with the existing title prefilled — proves the
+    // click handler routed to openEditTaskModal.
+    await waitFor(() => {
+      expect(screen.getByRole('dialog')).toBeInTheDocument();
+    });
+    const dialog = screen.getByRole('dialog');
+    expect(within(dialog).getByDisplayValue('Click to edit me')).toBeInTheDocument();
+  });
+
+  it('search input filters tasks by title (case-insensitive)', async () => {
+    const tasks: Task[] = [
+      mkTask({ id: '1', title: 'Deploy v6.5 release', status: 'queued' }),
+      mkTask({ id: '2', title: 'Write release notes', status: 'doing' }),
+      mkTask({ id: '3', title: 'Unrelated task', status: 'queued' }),
+    ];
+    const user = userEvent.setup();
+    renderTasks(makeSnapshot(tasks));
+
+    const search = screen.getByLabelText('Search tasks');
+    await user.type(search, 'RELEASE');
+
+    await waitFor(() => {
+      expect(screen.getByText('Deploy v6.5 release')).toBeInTheDocument();
+      expect(screen.getByText('Write release notes')).toBeInTheDocument();
+    });
+    expect(screen.queryByText('Unrelated task')).not.toBeInTheDocument();
+
+    // Clear and the unrelated task returns.
+    await user.clear(search);
+    await waitFor(() => {
+      expect(screen.getByText('Unrelated task')).toBeInTheDocument();
+    });
+  });
+
+  it('renders a loading state when snapshot.tasks is undefined on first mount', () => {
+    const emptySnapshot = makeSnapshot([]);
+    // Pretend the initial snapshot has no tasks — view starts in loading mode.
+    (emptySnapshot as { tasks?: Task[] }).tasks = undefined as unknown as Task[];
+    renderTasks(emptySnapshot);
+    // The redesigned view uses LoadingState — it renders a role="status"
+    // container with aria-live="polite". The view also has a hidden live
+    // region for screen-reader status announcements, so we filter to the
+    // one that actually contains loading text.
+    const statuses = screen.getAllByRole('status');
+    const loadingStatus = statuses.find(
+      (el) => el.textContent && /loading/i.test(el.textContent),
+    );
+    expect(loadingStatus).toBeDefined();
+    expect(loadingStatus!.textContent).toMatch(/loading/i);
+  });
+});

package/bizar-dash/vitest.config.ts

@@ -7,7 +7,9 @@ export default defineConfig({
     environment: 'jsdom',
     globals: true,
     setupFiles: ['./tests/setup.ts'],
-    include: ['tests/**/*.test.{ts,tsx}'],
+    // tests/ is the canonical location; src/web/components/agents/ covers
+    // feature-scoped component tests (e.g. F-035 RoutingDecisions.test.tsx).
+    include: ['tests/**/*.test.{ts,tsx}', 'src/web/components/agents/**/*.test.{ts,tsx}'],
     exclude: ['tests/**/*.test.mjs'],
   },
 });