Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

38.4 KB
Raw Blame
// @vitest-environment jsdom

/** WorktreeContext 只共享快照与 active 任务的探测结果;创建/回收按 sessionId 增量更新。 */

import { act, cleanup, render, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

import {
  WorktreeProvider,
  useWorktrees,
  useRefreshWorktreeForSession,
  useReportWorktreeLiveness,
  useWorktreeForSession,
} from '@/contexts/WorktreeContext';
import { useTaskInfoWorktree } from '@/features/cc-agent/sidebar/sessionWorktreeInfo';
import { SessionInfoMeta } from '@/features/cc-agent/sidebar/SessionInfoMeta';
import { setDataOwnerGeneration, __testing as ownerTesting } from '@/contexts/dataOwnerGeneration';
import { emitRefresh } from '@/lib/sessionsBus';

vi.mock('react-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
vi.mock('@/contexts/PrRefsContext', () => ({
  usePrActions: () => ({ fetchStatusesForSession: vi.fn() }),
  usePrStatus: () => undefined,
}));

vi.mock('@/lib/logger', () => ({
  createLogger: () => ({ warn: vi.fn(), error: vi.fn(), debug: vi.fn(), info: vi.fn() }),
}));

const mocks = {
  getSession: vi.fn(),
  worktreeListAll: vi.fn(),
  worktreeGetForSession: vi.fn(),
  worktreeDetectCwd: vi.fn(),
  findLinkedWorktree: vi.fn(),
  recentGitDir: vi.fn(),
  listeners: new Set<(payload: { sessionId: string }) => void>(),
  sessionCreatedListeners: new Set<
    (payload: { sessionId: string }, ownerStamp?: unknown) => void
  >(),
  messageListeners: new Set<
    (payload: { sessionId: string; message: { role: string } }, ownerStamp?: unknown) => void
  >(),
};

function emitWorktreeChanged(sessionId: string): void {
  mocks.listeners.forEach((cb) => cb({ sessionId }));
}

function emitSessionCreated(sessionId: string, ownerStamp?: unknown): void {
  mocks.sessionCreatedListeners.forEach((cb) => cb({ sessionId }, ownerStamp));
}

function Probe() {
  const metas = useWorktrees();
  return (
    <span data-testid="ids">
      {Object.values(metas)
        .sort((a, b) => a.sessionId.localeCompare(b.sessionId))
        .map((meta) => `${meta.sessionId}:${meta.path}`)
        .join(',')}
    </span>
  );
}

function ActiveProbe() {
  const info = useTaskInfoWorktree({ id: 'open', workingDir: '/repo' }, true, {
    observeTelemetry: true,
  });
  return <span data-testid="active">{info?.path ?? ''}</span>;
}

function SidebarProbe({
  id = 'open',
  remoteHostId,
  deviceLinkDeviceId,
  enabled = true,
  onRender,
}: {
  id?: string;
  remoteHostId?: string;
  deviceLinkDeviceId?: string;
  enabled?: boolean;
  onRender?: () => void;
}) {
  const info = useTaskInfoWorktree(
    { id, workingDir: '/repo', remoteHostId, deviceLinkDeviceId },
    enabled,
  );
  onRender?.();
  return (
    <div data-testid={`sidebar-${id}`} data-path={info?.path ?? ''}>
      <SessionInfoMeta
        pieces={info ? [{ key: 'worktree', text: '' }] : []}
        worktree={info ?? undefined}
      />
    </div>
  );
}

function emitToolMessage(sessionId = 'open', role = 'tool_result', ownerStamp?: unknown) {
  mocks.messageListeners.forEach((cb) => cb({ sessionId, message: { role } }, ownerStamp));
}

beforeEach(() => {
  ownerTesting.reset();
  mocks.worktreeListAll.mockReset();
  mocks.worktreeGetForSession.mockReset();
  mocks.worktreeDetectCwd.mockReset();
  mocks.findLinkedWorktree.mockReset().mockResolvedValue(null);
  mocks.recentGitDir.mockReset().mockResolvedValue({ source: null, workdir: null, head: null });
  mocks.getSession.mockReset().mockImplementation(async (id: string) => ({ id }));
  mocks.worktreeDetectCwd.mockResolvedValue({
    isInsideWorktree: true,
    isGitRepo: true,
    gitInstalled: true,
  });
  mocks.listeners.clear();
  mocks.sessionCreatedListeners.clear();
  mocks.messageListeners.clear();
  Object.defineProperty(window, 'electronAPI', {
    configurable: true,
    value: {
      worktreeListAll: mocks.worktreeListAll,
      worktreeGetForSession: mocks.worktreeGetForSession,
      worktreeDetectCwd: mocks.worktreeDetectCwd,
      gitContext: {
        findLinkedWorktree: mocks.findLinkedWorktree,
        getForSession: mocks.recentGitDir,
      },
      onWorktreeChanged: (cb: (payload: { sessionId: string }) => void) => {
        mocks.listeners.add(cb);
        return () => mocks.listeners.delete(cb);
      },
      localDb: {
        sessions: { get: mocks.getSession },
        messages: {
          onCreated: (
            cb: (
              payload: { sessionId: string; message: { role: string } },
              ownerStamp?: unknown,
            ) => void,
          ) => {
            mocks.messageListeners.add(cb);
            return () => mocks.messageListeners.delete(cb);
          },
        },
        sessionsPush: {
          onCreated: (cb: (payload: { sessionId: string }, ownerStamp?: unknown) => void) => {
            mocks.sessionCreatedListeners.add(cb);
            return () => mocks.sessionCreatedListeners.delete(cb);
          },
        },
      },
    },
  });
});

afterEach(() => {
  cleanup();
  vi.useRealTimers();
  vi.restoreAllMocks();
});

describe('WorktreeContext recycle refresh', () => {
  it('shows the real sidebar icon after a persisted tool result, shares it with the composer, and keeps it after switching tasks', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    const content = (active: boolean) => (
      <WorktreeProvider>
        <Probe />
        <SidebarProbe />
        {active && <ActiveProbe />}
      </WorktreeProvider>
    );
    const view = render(content(true));
    await act(async () => {});
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();
    await act(async () => emitToolMessage('open', 'tool_use'));
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();

    mocks.recentGitDir.mockResolvedValue({
      source: 'telemetry',
      workdir: '/tmp/observed/open',
      head: { branch: 'feature' },
    });
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').querySelector('svg.lucide-folders')).not.toBeNull();
    expect(view.getByTestId('sidebar-open').querySelector('button')).toBeNull();
    expect(view.getByTestId('active').textContent).toBe('/tmp/observed/open');
    expect(view.getByTestId('ids').textContent).toBe(''); // never added to managed registry
    view.rerender(content(false));
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/observed/open');

    mocks.findLinkedWorktree.mockResolvedValue(null);
    view.rerender(content(true));
    await act(async () => {});
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();
    expect(view.getByTestId('active').textContent).toBe('');
  });

  it('updates a background list entry without opening it or scanning other rows', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/background', branch: null });
    const idleRender = vi.fn();
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
        <SidebarProbe id="idle" onRender={idleRender} />
      </WorktreeProvider>,
    );
    await act(async () => {});
    expect(mocks.findLinkedWorktree).not.toHaveBeenCalled();
    expect(mocks.messageListeners.size).toBe(1);
    idleRender.mockClear();
    await act(async () => emitToolMessage());
    expect(mocks.findLinkedWorktree).toHaveBeenCalledExactlyOnceWith({ sessionId: 'open' });
    expect(view.getByTestId('sidebar-open').querySelector('svg')).not.toBeNull();
    expect(view.getByTestId('sidebar-idle').querySelector('svg')).toBeNull();
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
    expect(idleRender).not.toHaveBeenCalled();
    view.unmount();
    expect(mocks.messageListeners.size).toBe(0);
  });

  it('accepts current-owner messages, ignores stale-owner and non-tool pushes', async () => {
    setDataOwnerGeneration('owner', 3);
    mocks.worktreeListAll.mockResolvedValue([]);
    render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => {});
    await act(async () => {
      emitToolMessage('open', 'tool_result', { dataOwnerId: 'owner', ownerGeneration: 2 });
      emitToolMessage('open', 'assistant');
    });
    expect(mocks.findLinkedWorktree).not.toHaveBeenCalled();
    await act(async () =>
      emitToolMessage('open', 'tool_use', { dataOwnerId: 'owner', ownerGeneration: 3 }),
    );
    expect(mocks.findLinkedWorktree).toHaveBeenCalledOnce();
  });

  it('keeps managed entries cheap and removes an old observed fallback when that worktree is recycled', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/open', branch: null });
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/open');
    mocks.worktreeGetForSession.mockResolvedValue({ sessionId: 'open', path: '/tmp/open' });
    await act(async () => emitSessionCreated('open'));
    mocks.findLinkedWorktree.mockClear();
    await act(async () => emitToolMessage());
    expect(mocks.findLinkedWorktree).not.toHaveBeenCalled();
    mocks.worktreeGetForSession.mockResolvedValue(null);
    mocks.findLinkedWorktree.mockResolvedValue(null);
    await act(async () => emitWorktreeChanged('open'));
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();
    expect(mocks.findLinkedWorktree).toHaveBeenCalledExactlyOnceWith({ sessionId: 'open' });
  });

  it.each([{ remoteHostId: 'ssh' }, { deviceLinkDeviceId: 'remote' }])(
    'does not probe remote list entries: %j',
    async (remote) => {
      mocks.worktreeListAll.mockResolvedValue([]);
      mocks.getSession.mockResolvedValue({ id: 'open', ...remote });
      render(
        <WorktreeProvider>
          <SidebarProbe {...remote} />
        </WorktreeProvider>,
      );
      await act(async () => emitToolMessage());
      expect(mocks.findLinkedWorktree).not.toHaveBeenCalled();
    },
  );

  it('coalesces a burst during discovery and applies only the result after the newest tool write', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    let finish!: (value: unknown) => void;
    mocks.findLinkedWorktree
      .mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            finish = resolve;
          }),
      )
      .mockResolvedValue({ workdir: '/tmp/newest', branch: null });
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => {
      emitToolMessage();
      for (let i = 0; i < 10; i++) emitToolMessage();
      await Promise.resolve();
      finish({ workdir: '/tmp/stale', branch: null });
    });
    expect(mocks.findLinkedWorktree).toHaveBeenCalledTimes(2);
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/newest');
    mocks.recentGitDir.mockRejectedValue(new Error('IPC unavailable'));
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/newest');
  });

  it('discovers with no mounted rows and while the field is disabled, then shows the cached icon', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/background', branch: null });
    const content = (visible: boolean, enabled = false) => (
      <WorktreeProvider>{visible && <SidebarProbe enabled={enabled} />}</WorktreeProvider>
    );
    const view = render(content(false));
    await act(async () => emitToolMessage());
    view.rerender(content(true));
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();
    mocks.recentGitDir.mockResolvedValue({
      source: 'telemetry',
      workdir: '/tmp/new-path',
      head: null,
    });
    await act(async () => emitToolMessage());
    view.rerender(content(true, true));
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/new-path');
    expect(view.getByTestId('sidebar-open').querySelector('svg.lucide-folders')).not.toBeNull();
    expect(mocks.findLinkedWorktree).toHaveBeenCalledOnce();
    expect(mocks.recentGitDir).toHaveBeenCalledOnce();
    expect(mocks.messageListeners.size).toBe(1);
  });

  it('bounds sequential tool refreshes for empty and observed tasks, follows new roots, and backfills only after invalidation', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    for (let i = 0; i < 40; i++) await act(async () => emitToolMessage());
    expect(mocks.findLinkedWorktree).toHaveBeenCalledOnce();
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();

    // A fallback workingDir is never telemetry evidence.
    mocks.recentGitDir.mockResolvedValue({ source: 'workingDir', workdir: '/repo', head: null });
    await act(async () => emitToolMessage());
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
    mocks.recentGitDir.mockResolvedValue({
      source: 'telemetry',
      workdir: '/tmp/new/src',
      head: null,
    });
    mocks.worktreeDetectCwd.mockResolvedValue({
      isInsideWorktree: true,
      repoRoot: '/tmp/new',
      currentBranch: 'new',
    });
    for (let i = 0; i < 40; i++) await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/new');
    expect(mocks.findLinkedWorktree).toHaveBeenCalledOnce();
    expect(mocks.worktreeDetectCwd).toHaveBeenCalledTimes(40);

    // Returning to main does not forget an earlier live observed worktree.
    mocks.recentGitDir.mockResolvedValue({ source: 'telemetry', workdir: '/repo', head: null });
    mocks.worktreeDetectCwd.mockImplementation(async ({ cwd }) => ({
      isInsideWorktree: cwd === '/tmp/new',
    }));
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/new');
    expect(mocks.findLinkedWorktree).toHaveBeenCalledOnce();
    mocks.worktreeDetectCwd.mockResolvedValue({ isInsideWorktree: false });
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/older', branch: null });
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/older');
    expect(mocks.findLinkedWorktree).toHaveBeenCalledTimes(2);
  });

  it('keeps a full-history invalidation queued behind a recent query and rejects probes after unmount', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/old', branch: null });
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => emitToolMessage());
    let finish!: (value: unknown) => void;
    mocks.recentGitDir.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finish = resolve;
        }),
    );
    await act(async () => emitToolMessage());
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/older', branch: null });
    await act(async () => {
      emitWorktreeChanged('open');
      finish({ source: 'telemetry', workdir: '/tmp/recent', head: null });
    });
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/older');
    expect(mocks.findLinkedWorktree).toHaveBeenCalledTimes(2);
    mocks.recentGitDir.mockResolvedValue({
      source: 'telemetry',
      workdir: '/tmp/pending',
      head: null,
    });
    mocks.worktreeDetectCwd.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finish = resolve;
        }),
    );
    await act(async () => emitToolMessage());
    view.unmount();
    await act(async () => finish({ isInsideWorktree: false }));
    expect(mocks.findLinkedWorktree).toHaveBeenCalledTimes(2);
  });

  it('starts a new history backfill for a different owner even after an empty snapshot', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => emitToolMessage());
    setDataOwnerGeneration('next-owner');
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/next-owner', branch: null });
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/next-owner');
    expect(mocks.findLinkedWorktree).toHaveBeenCalledTimes(2);
  });

  it('retains accepted snapshots across same-owner recommits but rejects old-generation pending results', async () => {
    setDataOwnerGeneration('owner', 1);
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/accepted', branch: null });
    const content = () => (
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>
    );
    const view = render(content());
    await act(async () => emitToolMessage());
    let finish!: (value: unknown) => void;
    mocks.recentGitDir.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finish = resolve;
        }),
    );
    await act(async () => emitToolMessage());
    setDataOwnerGeneration('owner', 2);
    view.rerender(content());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/accepted');
    await act(async () => finish({ source: 'telemetry', workdir: '/tmp/stale', head: null }));
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/accepted');
    mocks.findLinkedWorktree.mockResolvedValue(null);
    await act(async () => emitWorktreeChanged('open'));
    expect(view.getByTestId('sidebar-open').querySelector('svg')).toBeNull();
  });

  it('does not probe a missing session or continue a session lookup after owner change or unmount', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.getSession.mockResolvedValueOnce(null);
    const view = render(
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>,
    );
    await act(async () => emitToolMessage());
    let finish!: (value: unknown) => void;
    mocks.getSession.mockImplementation(
      () =>
        new Promise((resolve) => {
          finish = resolve;
        }),
    );
    await act(async () => emitToolMessage());
    setDataOwnerGeneration('different-owner');
    await act(async () => finish({ id: 'open' }));
    await act(async () => emitToolMessage());
    view.unmount();
    await act(async () => finish({ id: 'open' }));
    expect(mocks.findLinkedWorktree).not.toHaveBeenCalled();
  });

  it('does not attach a late discovery to a different task or owner', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    let finish!: (value: unknown) => void;
    mocks.findLinkedWorktree.mockImplementation(
      () =>
        new Promise((resolve) => {
          finish = resolve;
        }),
    );
    const content = (id: string) => (
      <WorktreeProvider>
        <SidebarProbe id={id} />
      </WorktreeProvider>
    );
    const view = render(content('open'));
    await act(async () => emitToolMessage());
    view.rerender(content('other'));
    await act(async () => finish({ workdir: '/tmp/open', branch: null }));
    expect(view.getByTestId('sidebar-other').getAttribute('data-path')).toBe('');
    await act(async () => emitToolMessage('other'));
    setDataOwnerGeneration('replacement-owner');
    await act(async () => finish({ workdir: '/tmp/old-owner', branch: null }));
    expect(view.getByTestId('sidebar-other').getAttribute('data-path')).toBe('');
  });

  it('hides the previous owner snapshot and lets the new owner refresh while an old request is pending', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/owner-a', branch: null });
    const content = () => (
      <WorktreeProvider>
        <SidebarProbe />
      </WorktreeProvider>
    );
    const view = render(content());
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/owner-a');
    let finishOld!: (value: unknown) => void;
    mocks.recentGitDir.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finishOld = resolve;
        }),
    );
    await act(async () => emitToolMessage());
    setDataOwnerGeneration('owner-b');
    view.rerender(content());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('');
    mocks.findLinkedWorktree.mockResolvedValue({ workdir: '/tmp/owner-b', branch: null });
    await act(async () => emitToolMessage());
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/owner-b');
    await act(async () =>
      finishOld({ source: 'telemetry', workdir: '/tmp/old-owner-late', head: null }),
    );
    expect(view.getByTestId('sidebar-open').getAttribute('data-path')).toBe('/tmp/owner-b');
  });

  it('shares external deletion with sidebar badges, retains metadata for reopening and detects external restoration', async () => {
    const meta = { sessionId: 'open', path: '/tmp/wt/open' };
    mocks.worktreeListAll.mockResolvedValue([meta, { sessionId: 'idle', path: '/tmp/wt/idle' }]);
    const content = (active: boolean) => (
      <WorktreeProvider>
        <Probe />
        {active && <ActiveProbe />}
      </WorktreeProvider>
    );
    const view = render(content(true));
    await act(async () => {});
    expect(view.getByTestId('active').textContent).toBe(meta.path);

    mocks.worktreeDetectCwd.mockResolvedValue({ isInsideWorktree: false });
    await act(async () => {
      window.dispatchEvent(new Event('focus'));
    });
    expect(view.getByTestId('active').textContent).toBe('');
    expect(view.getByTestId('ids').textContent).toBe('idle:/tmp/wt/idle');

    view.rerender(content(false));
    mocks.worktreeDetectCwd.mockClear().mockResolvedValue({ isInsideWorktree: true });
    view.rerender(content(true));
    await act(async () => {});
    expect(view.getByTestId('active').textContent).toBe(meta.path);
    expect(view.getByTestId('ids').textContent).toContain('open:/tmp/wt/open');
    expect(mocks.worktreeDetectCwd).toHaveBeenCalledExactlyOnceWith({ cwd: meta.path });
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
    expect(mocks.worktreeGetForSession).not.toHaveBeenCalled();
  });

  it('rechecks same-path restoration through refreshSession without requiring a changed push or focus', async () => {
    const meta = { sessionId: 'open', path: '/tmp/wt/open' };
    mocks.worktreeListAll.mockResolvedValue([meta]);
    mocks.worktreeDetectCwd.mockResolvedValue({ isInsideWorktree: false });
    let refresh!: (sessionId: string) => Promise<void>;
    function Actions() {
      refresh = useRefreshWorktreeForSession();
      return (
        <>
          <Probe />
          <ActiveProbe />
        </>
      );
    }
    const view = render(
      <WorktreeProvider>
        <Actions />
      </WorktreeProvider>,
    );
    await act(async () => {});
    expect(view.getByTestId('active').textContent).toBe('');
    expect(view.getByTestId('ids').textContent).toBe('');

    mocks.worktreeGetForSession.mockResolvedValue({ ...meta });
    mocks.worktreeDetectCwd.mockClear().mockResolvedValue({ isInsideWorktree: true });
    await act(async () => {
      await refresh('open');
    });
    expect(view.getByTestId('active').textContent).toBe(meta.path);
    expect(view.getByTestId('ids').textContent).toBe(`open:${meta.path}`);
    expect(mocks.worktreeDetectCwd).toHaveBeenCalledExactlyOnceWith({ cwd: meta.path });
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
  });

  it('does not hide a live worktree when its probe rejects', async () => {
    mocks.worktreeListAll.mockResolvedValue([{ sessionId: 'open', path: '/tmp/wt/open' }]);
    const view = render(
      <WorktreeProvider>
        <Probe />
        <ActiveProbe />
      </WorktreeProvider>,
    );
    await act(async () => {});
    mocks.worktreeDetectCwd.mockRejectedValue(new Error('probe timeout'));
    await act(async () => {
      window.dispatchEvent(new Event('focus'));
    });
    expect(view.getByTestId('active').textContent).toBe('/tmp/wt/open');
    expect(view.getByTestId('ids').textContent).toBe('open:/tmp/wt/open');
  });

  it.each(['/tmp/wt/open', '/tmp/wt/restored'])(
    'uses replacement metadata at %s while its probe is pending or fails, ignoring old results',
    async (restoredPath) => {
      const meta = { sessionId: 'open', path: '/tmp/wt/open' };
      mocks.worktreeListAll.mockResolvedValue([meta]);
      mocks.worktreeDetectCwd.mockResolvedValue({ isInsideWorktree: false });
      let refresh!: (sessionId: string) => Promise<void>;
      function Actions() {
        refresh = useRefreshWorktreeForSession();
        return (
          <>
            <Probe />
            <ActiveProbe />
          </>
        );
      }
      const view = render(
        <WorktreeProvider>
          <Actions />
        </WorktreeProvider>,
      );
      await act(async () => {});
      expect(view.getByTestId('active').textContent).toBe('');
      expect(view.getByTestId('ids').textContent).toBe('');

      let finishOld!: (value: { isInsideWorktree: boolean }) => void;
      mocks.worktreeDetectCwd.mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            finishOld = resolve;
          }),
      );
      await act(async () => {
        window.dispatchEvent(new Event('focus'));
      });

      let rejectNew!: (reason: Error) => void;
      mocks.worktreeGetForSession.mockResolvedValue({ ...meta, path: restoredPath });
      mocks.worktreeDetectCwd.mockImplementationOnce(
        () =>
          new Promise((_resolve, reject) => {
            rejectNew = reject;
          }),
      );
      await act(async () => {
        await refresh('open');
      });
      expect(view.getByTestId('ids').textContent).toBe(`open:${restoredPath}`);
      expect(view.getByTestId('active').textContent).toBe(restoredPath);
      expect(mocks.worktreeDetectCwd).toHaveBeenLastCalledWith({ cwd: restoredPath });

      await act(async () => {
        finishOld({ isInsideWorktree: false });
      });
      expect(view.getByTestId('active').textContent).toBe(restoredPath);
      expect(view.getByTestId('ids').textContent).toBe(`open:${restoredPath}`);
      await act(async () => {
        rejectNew(new Error('[INTERNAL] Worktree directory probe failed'));
      });
      expect(view.getByTestId('active').textContent).toBe(restoredPath);
      expect(view.getByTestId('ids').textContent).toBe(`open:${restoredPath}`);

      // A conclusive result for the new metadata must still update both views.
      await act(async () => {
        window.dispatchEvent(new Event('focus'));
      });
      expect(view.getByTestId('active').textContent).toBe('');
      expect(view.getByTestId('ids').textContent).toBe('');
      expect(mocks.worktreeDetectCwd).toHaveBeenCalledTimes(4);
      expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
      expect(mocks.worktreeGetForSession).toHaveBeenCalledExactlyOnceWith('open');
    },
  );

  it('ignores liveness reports captured before same-path restoration or recycling', async () => {
    const meta = { sessionId: 'open', path: '/tmp/wt/open' };
    mocks.worktreeListAll.mockResolvedValue([meta]);
    let report!: ReturnType<typeof useReportWorktreeLiveness>;
    let original!: NonNullable<ReturnType<typeof useWorktreeForSession>>;
    let refresh!: (sessionId: string) => Promise<void>;
    function Actions() {
      report = useReportWorktreeLiveness();
      original = useWorktreeForSession('open') ?? original;
      refresh = useRefreshWorktreeForSession();
      return <Probe />;
    }
    const view = render(
      <WorktreeProvider>
        <Actions />
      </WorktreeProvider>,
    );
    await act(async () => {});
    const oldMeta = original;
    mocks.worktreeGetForSession.mockResolvedValue({ ...meta });
    await act(async () => {
      await refresh('open');
    });
    await act(async () => {
      report(oldMeta, false);
    });
    expect(view.getByTestId('ids').textContent).toBe('open:/tmp/wt/open');
    mocks.worktreeGetForSession.mockResolvedValue(null);
    await act(async () => {
      await refresh('open');
    });
    await act(async () => {
      report(original, true);
    });
    expect(view.getByTestId('ids').textContent).toBe('');
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
  });

  it('removes only the reported session without reloading the full snapshot', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([
      { sessionId: 'archived-one', path: '/tmp/wt/archived-one' },
      { sessionId: 'other', path: '/tmp/wt/other' },
    ]);
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => {
      expect(view.getByTestId('ids').textContent).toContain('archived-one:/tmp/wt/archived-one');
    });

    mocks.worktreeGetForSession.mockResolvedValueOnce(null);
    await act(async () => {
      emitWorktreeChanged('archived-one');
    });

    await waitFor(() => {
      expect(view.getByTestId('ids').textContent).toBe('other:/tmp/wt/other');
    });
    expect(mocks.worktreeGetForSession).toHaveBeenCalledWith('archived-one');
    expect(mocks.worktreeListAll).toHaveBeenCalledTimes(1);
  });

  it('updates only the reported worktree', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([
      { sessionId: 'changed', path: '/tmp/wt/old' },
      { sessionId: 'other', path: '/tmp/wt/other' },
    ]);
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    mocks.worktreeGetForSession.mockResolvedValueOnce({
      sessionId: 'changed',
      path: '/tmp/wt/new',
    });

    act(() => emitWorktreeChanged('changed'));

    await waitFor(() => {
      expect(view.getByTestId('ids').textContent).toContain('changed:/tmp/wt/new');
    });
    expect(mocks.worktreeListAll).toHaveBeenCalledTimes(1);
  });

  it('keeps the newest response when the same session changes twice', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([{ sessionId: 'same', path: '/tmp/wt/start' }]);
    let resolveFirst!: (value: { sessionId: string; path: string }) => void;
    mocks.worktreeGetForSession
      .mockImplementationOnce(
        () =>
          new Promise((resolve) => {
            resolveFirst = resolve;
          }),
      )
      .mockResolvedValueOnce({ sessionId: 'same', path: '/tmp/wt/newest' });
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(view.getByTestId('ids').textContent).toContain('/tmp/wt/start'));

    act(() => {
      emitWorktreeChanged('same');
      emitWorktreeChanged('same');
    });
    await waitFor(() => expect(view.getByTestId('ids').textContent).toContain('/tmp/wt/newest'));

    await act(async () => {
      resolveFirst({ sessionId: 'same', path: '/tmp/wt/stale' });
    });
    expect(view.getByTestId('ids').textContent).toBe('same:/tmp/wt/newest');
  });

  it('applies concurrent events for different sessions independently', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([]);
    let resolveFirst!: (value: { sessionId: string; path: string }) => void;
    mocks.worktreeGetForSession.mockImplementation((sessionId: string) => {
      if (sessionId === 'first') {
        return new Promise((resolve) => {
          resolveFirst = resolve;
        });
      }
      return Promise.resolve({ sessionId, path: `/tmp/wt/${sessionId}` });
    });
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledOnce());

    act(() => {
      emitWorktreeChanged('first');
      emitWorktreeChanged('second');
    });
    await waitFor(() => expect(view.getByTestId('ids').textContent).toContain('second'));
    await act(async () => {
      resolveFirst({ sessionId: 'first', path: '/tmp/wt/first' });
    });

    expect(view.getByTestId('ids').textContent).toBe('first:/tmp/wt/first,second:/tmp/wt/second');
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
  });

  it('does not turn a sessions refresh into a worktree scan', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([]);
    render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledOnce());

    act(() => emitRefresh());

    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
  });

  it('discovers a worktree created by a local background session without scanning all worktrees', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([]);
    mocks.worktreeGetForSession.mockResolvedValueOnce({
      sessionId: 'background',
      path: '/tmp/wt/background',
    });
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledOnce());

    act(() => emitSessionCreated('background'));

    await waitFor(() => {
      expect(view.getByTestId('ids').textContent).toBe('background:/tmp/wt/background');
    });
    expect(mocks.worktreeGetForSession).toHaveBeenCalledWith('background');
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
  });

  it('does not run Git validation for a local background session without a worktree', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([]);
    mocks.worktreeGetForSession.mockResolvedValueOnce(null);
    render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledOnce());

    act(() => emitSessionCreated('notification-only'));

    await waitFor(() => {
      expect(mocks.worktreeGetForSession).toHaveBeenCalledWith('notification-only');
    });
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
  });

  it('refreshes explicit creation, recycling and restoration repeatedly without a full scan', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    let refresh!: (sessionId: string) => Promise<void>;
    function Actions() {
      refresh = useRefreshWorktreeForSession();
      return <Probe />;
    }
    const view = render(
      <WorktreeProvider>
        <Actions />
      </WorktreeProvider>,
    );
    await act(async () => {});
    for (let i = 0; i < 3; i++) {
      mocks.worktreeGetForSession.mockResolvedValueOnce({
        sessionId: 'restored',
        path: `/tmp/wt/restored-${i}`,
      });
      await act(async () => {
        await refresh('restored');
      });
      expect(view.getByTestId('ids').textContent).toBe(`restored:/tmp/wt/restored-${i}`);
      mocks.worktreeGetForSession.mockResolvedValueOnce(null);
      await act(async () => {
        emitWorktreeChanged('restored');
      });
      expect(view.getByTestId('ids').textContent).toBe('');
    }
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
    expect(mocks.worktreeGetForSession).toHaveBeenCalledTimes(6);
  });

  it('ignores remote session creation pushes for the local worktree cache', async () => {
    mocks.worktreeListAll.mockResolvedValueOnce([]);
    render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledOnce());

    act(() => {
      emitSessionCreated('remote-collision', {
        dataOwnerId: 'owner',
        ownerGeneration: 1,
      });
    });

    expect(mocks.worktreeGetForSession).not.toHaveBeenCalled();
    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
  });

  it('loads idle worktree metadata without Git probes or a periodic full scan', async () => {
    vi.useFakeTimers();
    mocks.worktreeListAll.mockResolvedValue(
      Array.from({ length: 69 }, (_, i) => ({
        sessionId: `session-${i}`,
        path: `/tmp/wt/${i}`,
      })),
    );
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );

    await act(async () => {});
    expect(view.getByTestId('ids').textContent).toContain('session-68:/tmp/wt/68');
    await act(async () => {
      window.dispatchEvent(new Event('focus'));
      await vi.advanceTimersByTimeAsync(15 * 60_000);
    });

    expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
    expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
  });

  it('keeps creation and recycling events newer than a pending metadata snapshot', async () => {
    let finishList!: (value: Array<{ sessionId: string; path: string }>) => void;
    mocks.worktreeListAll.mockImplementation(
      () =>
        new Promise((resolve) => {
          finishList = resolve;
        }),
    );
    mocks.worktreeGetForSession.mockImplementation(async (sessionId: string) =>
      sessionId === 'new' ? { sessionId, path: '/tmp/wt/new' } : null,
    );
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await act(async () => {
      emitSessionCreated('new');
      emitWorktreeChanged('recycled');
    });
    await act(async () => {
      finishList([{ sessionId: 'recycled', path: '/tmp/wt/recycled' }]);
    });
    expect(view.getByTestId('ids').textContent).toBe('new:/tmp/wt/new');
  });

  it('unsubscribes on unmount so a later push cannot refresh a dead tree', async () => {
    mocks.worktreeListAll.mockResolvedValue([]);
    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );
    await waitFor(() => expect(mocks.worktreeListAll).toHaveBeenCalledTimes(1));

    view.unmount();
    expect(mocks.listeners.size).toBe(0);
    expect(mocks.sessionCreatedListeners.size).toBe(0);

    emitWorktreeChanged('archived-one');
    expect(mocks.worktreeListAll).toHaveBeenCalledTimes(1);
    expect(mocks.worktreeGetForSession).not.toHaveBeenCalled();
  });

  it('still mounts when the push channel is unavailable', async () => {
    // 老 preload / 非 Electron 宿主下 onWorktreeChanged 可能缺失,不能让 Provider 崩。
    Object.defineProperty(window, 'electronAPI', {
      configurable: true,
      value: { worktreeListAll: mocks.worktreeListAll },
    });
    mocks.worktreeListAll.mockResolvedValue([{ sessionId: 'only', path: '/tmp/wt/only' }]);

    const view = render(
      <WorktreeProvider>
        <Probe />
      </WorktreeProvider>,
    );

    await waitFor(() => {
      expect(view.getByTestId('ids').textContent).toBe('only:/tmp/wt/only');
    });
  });
});