Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

18.1 KB
Raw Blame
import { describe, it, expect, vi } from 'vitest';
import { render, screen, fireEvent, waitFor, within } from '@testing-library/react';

// The card's pins render a `highlightToolUse` ProviderModelSelector, which
// fetches the backends' authoritative tool-use capabilities. Park that scan
// unresolved: this suite is about the provider/model/effort pins, not the
// tool-use annotation (covered in ProviderModelSelector.test.jsx), and a scan
// that settles mid-test would land a state update outside act() in the
// synchronous cases below.
vi.mock('../../../../services/apiLocalLlm', () => ({
  getToolUseModels: vi.fn(() => new Promise(() => {})),
}));

import AppTaskCard from './AppTaskCard';

// `claude-code-*` ids carry the claude effort ladder (see effortLevelsForProvider).
const providers = [
  { id: 'claude-code', name: 'Claude Code', models: ['opus', 'sonnet'] },
  { id: 'gemini', name: 'Gemini', models: ['gemini-3-pro'] },
];

const baseConfig = {
  enabled: true,
  type: 'daily',
  enabledAppCount: 3,
  totalAppCount: 5,
  globalRunCount: 12,
  globalLastRun: '2026-06-20T10:00:00Z',
  status: { nextRunAt: '2999-01-01T00:00:00Z' },
};

function renderCard(overrides = {}, props = {}, taskType = 'code-review') {
  const onTrigger = vi.fn();
  const onConfigure = vi.fn();
  render(
    <AppTaskCard
      taskType={taskType}
      config={{ ...baseConfig, ...overrides }}
      onTrigger={onTrigger}
      onConfigure={onConfigure}
      {...props}
    />
  );
  return { onTrigger, onConfigure };
}

// Card with the inline provider/model/effort pins wired up.
function renderCardWithPins(overrides = {}, props = {}) {
  const onUpdate = props.onUpdate || vi.fn().mockResolvedValue(true);
  return { onUpdate, ...renderCard(overrides, { providers, ...props, onUpdate }) };
}

describe('AppTaskCard', () => {
  it('exposes held checkout evidence and recovery prerequisites independently of coordinator success', () => {
    renderCard({ perpetual: false, reconcileOutcomes: {
      example: { status: 'incomplete', reason: 'merged-branches-held-back', observedAt: '2026-10-01T00:00:00Z', nextAction: 'Resolve the listed holds and run again.', remaining: [
        { path: '/example/held', branch: 'fix/example', head: 'abc123', locked: true, lockReason: '<script>owner handoff</script>', managed: false, reason: 'worktree-locked' },
      ] },
    } }, { apps: [{ id: 'example', name: 'Example App' }] }, 'branch-reconcile');
    fireEvent.click(screen.getByText(/Example App · Incomplete/));
    expect(screen.getByText('/example/held')).toBeVisible();
    expect(screen.getByText('HEAD: abc123')).toBeVisible();
    expect(screen.getByText('Lock: <script>owner handoff</script>')).toBeVisible();
    expect(document.querySelector('script')).toBeNull();
    expect(screen.getByText('Outside managed worktree roots')).toBeVisible();
    expect(screen.getByText(/Retiring a checkout is a scoped release/)).toBeVisible();
    expect(screen.getByText('Resolve the listed holds and run again.')).toBeVisible();
    expect(screen.getByRole('button', { name: 'Archive and retire checkout…' })).toBeVisible();
  });

  it('distinguishes an unreadable inventory from a completed empty scan', () => {
    renderCard({ reconcileOutcomes: {
      example: { status: 'incomplete', remaining: null, observedAt: null },
      empty: { status: 'drained', remaining: [], observedAt: '2026-10-01T00:00:00Z' },
      unobserved: { status: 'incomplete', remaining: [], observedAt: null },
      running: { status: 'running', remaining: [], observedAt: '2026-10-01T00:00:00Z' },
    } }, {}, 'branch-reconcile');
    expect(screen.getByText(/example · Incomplete/)).toBeTruthy();
    expect(screen.getByText('Remaining work is unknown.')).toBeTruthy();
    expect(screen.getAllByText('No readable inventory yet.')).toHaveLength(2);
    expect(screen.getByText(/empty · No remaining work in last scan · 0 remaining/)).toBeTruthy();
    expect(screen.getByText(/unobserved · Incomplete · 0 remaining/)).toBeTruthy();
    expect(screen.getByText(/running · Sweep running · 0 remaining/)).toBeTruthy();
    expect(screen.queryByText(/No remaining recorded work/)).toBeNull();
  });

  it('shows empty recorded cleanup independently of stale or interrupted sweep status, retaining diagnostics', () => {
    renderCard({ reconcileOutcomes: {
      idle: { status: 'incomplete', reason: 'no-in-flight-branches', remaining: [], observedAt: '2026-10-01T00:00:00Z' },
      interrupted: { status: 'incomplete', reason: 'agent-failed', remaining: [], observedAt: '2026-10-01T00:00:00Z', nextAction: 'Run branch reconciliation again.' },
    } }, {}, 'branch-reconcile');
    expect(screen.getByText('idle · No remaining recorded work · 0 remaining')).toBeVisible();
    const interrupted = screen.getByText('interrupted · No remaining recorded work · 0 remaining');
    fireEvent.click(interrupted);
    const details = within(interrupted.closest('details'));
    expect(details.getByText('Last sweep: Incomplete')).toBeVisible();
    expect(details.getByText('Reason: agent-failed')).toBeVisible();
    expect(details.getByText('Run branch reconciliation again.')).toBeVisible();
  });

  it('shows app coverage prominently', () => {
    renderCard();
    expect(screen.getByText('3/5 apps')).toBeTruthy();
    expect(screen.getByText('App coverage')).toBeTruthy();
  });

  it('shows the shipped task summary beneath the task name', () => {
    const summary = 'Review contributor changes before they merge';
    renderCard({ description: summary });
    expect(screen.getByText(summary)).toBeInTheDocument();
  });

  it('shows a future next-run countdown for active scheduled tasks', () => {
    renderCard();
    // timeUntil for a year-2999 date returns an "in …" string.
    expect(screen.getByText(/^in /)).toBeTruthy();
  });

  it('renders a clean Scheduled badge and next-run schedule description for cron tasks', () => {
    renderCard({ type: 'cron', cronExpression: '0 6 * * 1-5' }, {}, 'layered-intelligence');
    expect(screen.getByText('Scheduled')).toBeTruthy();
    // Perpetual is an ORTHOGONAL badge, so a plain cron task never shows one.
    expect(screen.queryByText('Perpetual')).toBeNull();
    expect(screen.getAllByTitle('Weekdays at 06:00 (0 6 * * 1-5)').length).toBeGreaterThanOrEqual(1);
    expect(screen.getByText(/^in .* · Weekdays at 06:00/)).toBeTruthy();
    expect(screen.getByText('layered-intelligence')).toBeTruthy();
  });

  it('shows "Manual trigger only" for on-demand tasks', () => {
    renderCard({ type: 'on-demand' });
    expect(screen.getByText('Manual trigger only')).toBeTruthy();
  });

  it('labels on-demand perpetual tasks as automatic drains', () => {
    renderCard({ type: 'on-demand', perpetual: true });
    expect(screen.getByText('Automatic drain')).toHaveAttribute('title', expect.stringContaining('Turn automatic starts off'));
    expect(screen.queryByText('On Demand')).toBeNull();
    expect(screen.queryByText('Manual trigger only')).toBeNull();
  });

  it('labels manual perpetual tasks as on demand with no automatic next run', () => {
    renderCard({ type: 'on-demand', perpetual: true, autoStart: false });
    expect(screen.queryByText('Automatic drain')).toBeNull();
    expect(screen.getByText('On Demand')).toBeTruthy();
    expect(screen.getByText('Manual trigger only')).toBeTruthy();
  });

  it('renders BOTH badges for a scheduled task that also drains perpetually', () => {
    renderCard({ type: 'cron', cronExpression: '0 6 * * 1-5', perpetual: true });
    expect(screen.getByText('Scheduled')).toBeTruthy();
    expect(screen.getByText('Perpetual')).toBeTruthy();
  });

  it('shows "Paused" for disabled tasks', () => {
    renderCard({ enabled: false });
    expect(screen.getByText('Paused')).toBeTruthy();
  });

  it('shows the global pause state on the card', () => {
    renderCard({ enabled: false });
    const indicator = screen.getByText('Global pause active').closest('[role="status"]');
    expect(indicator).toHaveTextContent('Scheduled runs are paused for this task.');
  });

  it('does not show a global pause indicator for an enabled task', () => {
    renderCard();
    expect(screen.queryByText('Global pause active')).toBeNull();
  });

  it('marks an automation-only task and removes direct actions', () => {
    const { onTrigger, onConfigure } = renderCard({
      invocation: {
        kind: 'subsidiary',
        visibility: 'visible',
        userInvokable: false,
        label: 'Automation-only',
        description: 'Runs from a parent automation.'
      }
    });
    expect(screen.getAllByText('Automation-only').length).toBeGreaterThan(0);
    expect(screen.queryByRole('button', { name: /Run Now|Run on App/i })).not.toBeInTheDocument();
    expect(screen.queryByRole('button', { name: /Configure/i })).not.toBeInTheDocument();
    expect(onTrigger).not.toHaveBeenCalled();
    expect(onConfigure).not.toHaveBeenCalled();
  });

  it('shows the dependency wait state', () => {
    renderCard({ status: { reason: 'waiting-on-dependencies', pendingDeps: ['build'] } });
    expect(screen.getByText(/waiting on build/)).toBeTruthy();
  });

  it('fires a global on-demand run when the task has no managed apps', () => {
    const { onTrigger, onConfigure } = renderCard();
    fireEvent.click(screen.getByRole('button', { name: /Run Now/i }));
    expect(onTrigger).toHaveBeenCalledWith('code-review');
    expect(onConfigure).not.toHaveBeenCalled();
  });

  it('opens the drawer from the card body, which is the only configure control', () => {
    const { onConfigure } = renderCard();
    expect(screen.queryByRole('button', { name: /Configure/ })).not.toBeInTheDocument();
    // The body is a native button, so it stays keyboard-operable.
    fireEvent.click(screen.getByText('App coverage').closest('button'));
    expect(onConfigure).toHaveBeenCalledWith('code-review');
  });

  it('runs with app context via the app picker when the task targets apps', () => {
    const apps = [{ id: 'app-1', name: 'Widget App' }, { id: 'app-2', name: 'Archived', archived: true }];
    const { onTrigger } = renderCard({}, { apps });
    // With apps present the quick action becomes a "Run on App" picker, not a contextless run.
    fireEvent.click(screen.getByRole('button', { name: /Run on App/i }));
    fireEvent.click(screen.getByRole('button', { name: /Widget App/ }));
    expect(onTrigger).toHaveBeenCalledWith('code-review', 'app-1');
    // Archived apps are excluded from the picker.
    expect(screen.queryByText('Archived')).toBeNull();
  });

  it('does not trigger when improvement is disabled', () => {
    const { onTrigger } = renderCard({}, { improvementDisabled: true });
    fireEvent.click(screen.getByRole('button', { name: /Run Now/i }));
    expect(onTrigger).not.toHaveBeenCalled();
  });

  it('shows never-run state when no prior run', () => {
    renderCard({ globalLastRun: null });
    expect(screen.getByText('Never run')).toBeTruthy();
  });

  it("lists the last run's recommended next audits when the triage lane recorded them (#12085)", () => {
    renderCard({ recommendedAudits: { at: '2026-06-20T10:00:00Z', appId: 'app-1', items: [
      'better-structural-drift — drifted registries: server/lib/navManifest.js',
      'ux — buried primary action: client/src/pages/Apps.jsx',
    ] } }, {}, 'code-quality');
    expect(screen.getByText('Recommended next audits')).toBeTruthy();
    const items = screen.getAllByRole('listitem').map((item) => item.textContent);
    expect(items).toEqual([
      'better-structural-drift — drifted registries: server/lib/navManifest.js',
      'ux — buried primary action: client/src/pages/Apps.jsx',
    ]);
  });

  it('omits the recommendation block when the last run recorded none', () => {
    renderCard({ recommendedAudits: null }, {}, 'code-quality');
    expect(screen.queryByText('Recommended next audits')).toBeNull();
  });

  it('shows a swarm badge when swarmCount ≥ 2 and hides it otherwise', () => {
    renderCard({ taskMetadata: { swarmCount: 3 } });
    expect(screen.getByText('×3')).toBeTruthy();
    expect(screen.getByTitle(/Swarm mode/)).toBeTruthy();
  });

  it('hides the swarm badge when swarm is off (absent / 0)', () => {
    renderCard({ taskMetadata: { swarmCount: 0 } });
    expect(screen.queryByText(/^×\d/)).toBeNull();
    renderCard({});
    expect(screen.queryByText(/^×\d/)).toBeNull();
  });

  it('shows the configured branch batch badge on branch-reconcile', () => {
    renderCard({ taskMetadata: { branchesPerAgent: 4 } }, {}, 'branch-reconcile');
    expect(screen.getByText('×4')).toBeTruthy();
    expect(screen.getByTitle(/up to 4 branch/)).toBeTruthy();
  });

  it('omits the quick model pins when no onUpdate handler is supplied', () => {
    renderCard({}, { providers });
    expect(screen.queryByLabelText('Provider')).toBeNull();
  });

  describe('quick model pins', () => {
    it('persists a provider pick and clears the model + effort pins with it', async () => {
      const { onUpdate } = renderCardWithPins({ providerId: 'gemini', model: 'gemini-3-pro' });
      fireEvent.change(screen.getByLabelText('Provider'), { target: { value: 'claude-code' } });
      await waitFor(() => expect(onUpdate).toHaveBeenCalledWith('code-review', {
        providerId: 'claude-code', model: null, effort: null,
      }));
      // Model options follow the newly picked provider.
      expect(screen.getByRole('option', { name: 'opus' })).toBeTruthy();
    });

    it('persists a model pick on its own', async () => {
      const { onUpdate } = renderCardWithPins({ providerId: 'claude-code' });
      fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'sonnet' } });
      await waitFor(() => expect(onUpdate).toHaveBeenCalledWith('code-review', { model: 'sonnet' }));
    });

    it('clears a pin back to the provider default', async () => {
      const { onUpdate } = renderCardWithPins({ providerId: 'claude-code', model: 'opus' });
      fireEvent.change(screen.getByLabelText('Model'), { target: { value: '' } });
      await waitFor(() => expect(onUpdate).toHaveBeenCalledWith('code-review', { model: null }));
    });

    it('offers effort only for effort-capable providers', () => {
      renderCardWithPins({ providerId: 'claude-code' });
      expect(screen.getByLabelText('Thinking effort')).toBeTruthy();
      expect(screen.getByRole('option', { name: 'xhigh' })).toBeTruthy();
    });

    it('hides effort for a provider with no ladder', () => {
      renderCardWithPins({ providerId: 'gemini' });
      expect(screen.queryByLabelText('Thinking effort')).toBeNull();
    });

    it('resolves model + effort options against the active provider when nothing is pinned', () => {
      renderCardWithPins({}, { activeProviderId: 'claude-code' });
      // Naming what "Default" resolves to is what makes the options below it readable.
      expect(screen.getByRole('option', { name: 'Default (active: Claude Code)' })).toBeTruthy();
      expect(screen.getByRole('option', { name: 'sonnet' })).toBeTruthy();
      expect(screen.getByLabelText('Thinking effort')).toBeTruthy();
    });

    it('falls back to a bare Default when the active provider is unknown', () => {
      renderCardWithPins();
      expect(within(screen.getByLabelText('Provider')).getByRole('option', { name: 'Default (active provider)' })).toBeTruthy();
      expect(screen.queryByLabelText('Thinking effort')).toBeNull();
    });

    it('says the provider list is still loading instead of offering a lone bare Default', () => {
      // Proves the card actually threads the flag; the label/disable rule itself
      // is ProviderModelSelector's (see its own suite).
      renderCardWithPins({}, { providers: [], providersLoaded: false });
      const provider = screen.getByLabelText('Provider');
      expect(within(provider).getByRole('option', { name: 'Loading providers…' })).toBeTruthy();
      expect(provider.disabled).toBe(true);
    });

    it('hides a disabled provider from the picker unless the task is pinned to it', () => {
      const withDisabled = [...providers, { id: 'retired', name: 'Retired CLI', enabled: false }];
      renderCardWithPins({}, { providers: withDisabled });
      expect(screen.queryByRole('option', { name: 'Retired CLI' })).toBeNull();
      renderCardWithPins({ providerId: 'retired' }, { providers: withDisabled });
      expect(screen.getAllByRole('option', { name: 'Retired CLI' }).length).toBe(1);
    });

    it('keeps a pinned model the provider no longer lists selectable', () => {
      renderCardWithPins({ providerId: 'claude-code', model: 'retired-model' });
      expect(screen.getByLabelText('Model').value).toBe('retired-model');
    });

    it('blocks Run while a pin write is still in flight, then re-enables it', async () => {
      let resolveUpdate;
      const onUpdate = vi.fn(() => new Promise(resolve => { resolveUpdate = resolve; }));
      const { onTrigger } = renderCardWithPins({ providerId: 'claude-code' }, { onUpdate });

      fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'sonnet' } });
      const run = screen.getByRole('button', { name: /Run Now/i });
      await waitFor(() => expect(run.disabled).toBe(true));
      fireEvent.click(run);
      expect(onTrigger).not.toHaveBeenCalled();

      resolveUpdate(true);
      await waitFor(() => expect(run.disabled).toBe(false));
      fireEvent.click(run);
      expect(onTrigger).toHaveBeenCalledWith('code-review');
    });

    it('rolls the selection back when the write fails', async () => {
      const onUpdate = vi.fn().mockResolvedValue(false);
      renderCardWithPins({ providerId: 'claude-code', model: 'opus' }, { onUpdate });
      fireEvent.change(screen.getByLabelText('Model'), { target: { value: 'sonnet' } });
      await waitFor(() => expect(screen.getByLabelText('Model').value).toBe('opus'));
    });

    it('shows pipeline stage count as text and leaves configuring to the card body', () => {
      const { onConfigure } = renderCardWithPins({
        taskMetadata: { pipeline: { stages: [{ name: 'plan' }, { name: 'build' }] } },
      });
      expect(screen.queryByLabelText('Provider')).toBeNull();
      expect(screen.getByText('Provider/model is set per stage (2)')).toBeTruthy();
      expect(screen.queryByRole('button', { name: /per stage/ })).toBeNull();
      fireEvent.click(screen.getByText('App coverage').closest('button'));
      expect(onConfigure).toHaveBeenCalledWith('code-review');
    });
  });
});