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。

fix(desktop): 工具识别的 Worktree 同步显示到任务列表 (#4662)

Dash80aaa4bb427d
diff --git a/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsx b/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsx
index a1148f98a7..e9e4fa78e8 100644
--- a/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsx
+++ b/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsx
@@ -13,21 +13,34 @@ import {
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 {
@@ -51,15 +64,52 @@ function Probe() {
}
function ActiveProbe() {
- const info = useTaskInfoWorktree({ id: 'open', workingDir: '/repo' }, true, { observeTelemetry: true });
+ 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,
@@ -67,18 +117,34 @@ beforeEach(() => {
});
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 },
+ 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);
@@ -97,16 +163,403 @@ afterEach(() => {
});
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 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')); });
+ await act(async () => {
+ window.dispatchEvent(new Event('focus'));
+ });
expect(view.getByTestId('active').textContent).toBe('');
expect(view.getByTestId('ids').textContent).toBe('idle:/tmp/wt/idle');
@@ -128,16 +581,27 @@ describe('WorktreeContext recycle refresh', () => {
let refresh!: (sessionId: string) => Promise<void>;
function Actions() {
refresh = useRefreshWorktreeForSession();
- return <><Probe /><ActiveProbe /></>;
+ return (
+ <>
+ <Probe />
+ <ActiveProbe />
+ </>
+ );
}
- const view = render(<WorktreeProvider><Actions /></WorktreeProvider>);
+ 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'); });
+ 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 });
@@ -146,10 +610,17 @@ describe('WorktreeContext recycle refresh', () => {
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>);
+ 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')); });
+ 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');
});
@@ -163,34 +634,63 @@ describe('WorktreeContext recycle refresh', () => {
let refresh!: (sessionId: string) => Promise<void>;
function Actions() {
refresh = useRefreshWorktreeForSession();
- return <><Probe /><ActiveProbe /></>;
+ return (
+ <>
+ <Probe />
+ <ActiveProbe />
+ </>
+ );
}
- const view = render(<WorktreeProvider><Actions /></WorktreeProvider>);
+ 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')); });
+ 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'); });
+ 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 }); });
+ 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')); });
+ 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')); });
+ 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);
@@ -211,16 +711,28 @@ describe('WorktreeContext recycle refresh', () => {
refresh = useRefreshWorktreeForSession();
return <Probe />;
}
- const view = render(<WorktreeProvider><Actions /></WorktreeProvider>);
+ 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); });
+ 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); });
+ await act(async () => {
+ await refresh('open');
+ });
+ await act(async () => {
+ report(original, true);
+ });
expect(view.getByTestId('ids').textContent).toBe('');
expect(mocks.worktreeDetectCwd).not.toHaveBeenCalled();
});
@@ -397,16 +909,25 @@ describe('WorktreeContext recycle refresh', () => {
refresh = useRefreshWorktreeForSession();
return <Probe />;
}
- const view = render(<WorktreeProvider><Actions /></WorktreeProvider>);
+ 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}`,
+ sessionId: 'restored',
+ path: `/tmp/wt/restored-${i}`,
+ });
+ await act(async () => {
+ await refresh('restored');
});
- 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'); });
+ await act(async () => {
+ emitWorktreeChanged('restored');
+ });
expect(view.getByTestId('ids').textContent).toBe('');
}
expect(mocks.worktreeListAll).toHaveBeenCalledOnce();
@@ -435,11 +956,17 @@ describe('WorktreeContext recycle refresh', () => {
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>);
+ 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');
@@ -454,13 +981,20 @@ describe('WorktreeContext recycle refresh', () => {
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>);
+ 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');
@@ -507,5 +1041,4 @@ describe('WorktreeContext recycle refresh', () => {
expect(view.getByTestId('ids').textContent).toBe('only:/tmp/wt/only');
});
});
-
});
diff --git a/apps/desktop/src/renderer/contexts/WorktreeContext.tsx b/apps/desktop/src/renderer/contexts/WorktreeContext.tsx
index 2b33e2b6c9..e16a04210b 100644
--- a/apps/desktop/src/renderer/contexts/WorktreeContext.tsx
+++ b/apps/desktop/src/renderer/contexts/WorktreeContext.tsx
@@ -22,11 +22,64 @@ import {
useMemo,
useRef,
useState,
+ useSyncExternalStore,
type ReactNode,
} from 'react';
import type { WorktreeMeta } from '@/lib/worktree.types';
import { createLogger } from '@/lib/logger';
+import {
+ getDataOwnerGeneration,
+ isDataOwnerGenerationCurrent,
+ isDataOwnerIdCurrent,
+ isDataOwnerPushCurrent,
+ type DataOwnerGeneration,
+} from './dataOwnerGeneration';
+
+interface ObservedWorktree {
+ owner: DataOwnerGeneration;
+ info: { workdir: string; branch: string | null } | null;
+}
+
+// Like PrRefsContext, keep a stable store in Context; an observed update must
+// not broadcast a new provider value to every task row.
+function createObservedStore() {
+ const entries = new Map<string, ObservedWorktree>();
+ const listeners = new Map<string, Set<() => void>>();
+ return {
+ has(sessionId: string) {
+ const entry = entries.get(sessionId);
+ return Boolean(entry && isDataOwnerIdCurrent(entry.owner));
+ },
+ get(sessionId: string) {
+ const entry = entries.get(sessionId);
+ return entry && isDataOwnerIdCurrent(entry.owner) ? entry.info : null;
+ },
+ set(sessionId: string, owner: DataOwnerGeneration, info: ObservedWorktree['info'] | null) {
+ const previous = entries.get(sessionId);
+ if (
+ previous &&
+ isDataOwnerIdCurrent(previous.owner) &&
+ previous.info?.workdir === info?.workdir &&
+ previous.info?.branch === info?.branch
+ )
+ return;
+ // A completed empty backfill is also a snapshot. Tool traffic must not
+ // rescan all history just because this task has never used a worktree.
+ entries.set(sessionId, { owner, info });
+ listeners.get(sessionId)?.forEach((listener) => listener());
+ },
+ subscribe(sessionId: string, listener: () => void) {
+ const group = listeners.get(sessionId) ?? new Set<() => void>();
+ listeners.set(sessionId, group);
+ group.add(listener);
+ return () => {
+ group.delete(listener);
+ if (group.size === 0) listeners.delete(sessionId);
+ };
+ },
+ };
+}
const log = createLogger('WorktreeContext');
interface WorktreeContextValue {
@@ -35,6 +88,8 @@ interface WorktreeContextValue {
/** 保留失效目录的登记信息,供打开中的任务在聚焦/恢复时重新探测。 */
rawMetas: Record<string, WorktreeMeta>;
reportLiveness: (meta: WorktreeMeta, live: boolean) => void;
+ observed: ReturnType<typeof createObservedStore>;
+ refreshObserved: (sessionId: string, mode?: 'recent' | 'history') => Promise<void>;
/** 从 main 查询并更新单个 session 的 worktree 缓存。 */
refreshSession: (sessionId: string) => Promise<void>;
}
@@ -42,10 +97,111 @@ interface WorktreeContextValue {
const WorktreeContext = createContext<WorktreeContextValue | null>(null);
export function WorktreeProvider({ children }: { children: ReactNode }) {
+ const [observed] = useState(createObservedStore);
+ // Sidebar and composer share one in-flight query per session. A tool result arriving
+ // during discovery requires one more pass over the newly committed messages.
+ const observedRequests = useRef(
+ new Map<
+ string,
+ { owner: DataOwnerGeneration; queued: boolean; history: boolean; promise: Promise<void> }
+ >(),
+ );
+ const refreshObserved = useCallback(
+ (sessionId: string, mode: 'recent' | 'history' = 'history'): Promise<void> => {
+ const pending = observedRequests.current.get(sessionId);
+ if (pending && isDataOwnerGenerationCurrent(pending.owner)) {
+ pending.queued = true;
+ pending.history ||= mode === 'history';
+ return pending.promise;
+ }
+ const owner = getDataOwnerGeneration();
+ const request = {
+ owner,
+ queued: false,
+ history: mode === 'history',
+ promise: Promise.resolve(),
+ };
+ const isCurrent = () =>
+ observedRequests.current.get(sessionId) === request && isDataOwnerGenerationCurrent(owner);
+ observedRequests.current.set(sessionId, request);
+ request.promise = (async () => {
+ do {
+ request.queued = false;
+ try {
+ const session = await window.electronAPI.localDb.sessions.get(sessionId);
+ if (!isCurrent()) return;
+ if (!session || session.remoteHostId || session.deviceLinkDeviceId) return;
+ let found: ObservedWorktree['info'] = null;
+ if (request.history || !observed.has(sessionId)) {
+ found = await window.electronAPI.gitContext.findLinkedWorktree({ sessionId });
+ } else {
+ // The existing resolver reads only the latest bounded telemetry
+ // window and probes one candidate, rather than walking 2000 rows.
+ const recent = await window.electronAPI.gitContext.getForSession({
+ sessionId,
+ workingDir: null,
+ worktreePath: null,
+ });
+ if (!isCurrent()) return;
+ const previous = observed.get(sessionId);
+ const candidate = recent.source === 'telemetry' ? recent.workdir : null;
+ const paths = new Set(
+ [candidate, previous?.workdir].filter((p): p is string => Boolean(p)),
+ );
+ for (const cwd of paths) {
+ const detected = await window.electronAPI.worktreeDetectCwd({ cwd });
+ if (!isCurrent()) return;
+ if (detected.isInsideWorktree) {
+ found = {
+ workdir: detected.repoRoot ?? cwd,
+ branch: detected.currentBranch ?? null,
+ };
+ break;
+ }
+ }
+ // A known worktree disappeared: recover an older surviving one.
+ // Empty tasks do not repeat this full backfill on each tool call.
+ if (!found && previous) {
+ found = await window.electronAPI.gitContext.findLinkedWorktree({ sessionId });
+ }
+ }
+ if (!isCurrent()) return;
+ if (request.queued) continue;
+ observed.set(sessionId, owner, found?.workdir ? found : null);
+ } catch {
+ // Transport failure is not evidence that a previously found path vanished.
+ }
+ } while (request.queued && isCurrent());
+ })().finally(() => {
+ if (observedRequests.current.get(sessionId) === request)
+ observedRequests.current.delete(sessionId);
+ });
+ return request.promise;
+ },
+ [observed],
+ );
+ useEffect(
+ () => () => {
+ observedRequests.current.clear();
+ },
+ [],
+ );
const [snapshot, setSnapshot] = useState<{
metas: Record<string, WorktreeMeta>;
invalid: Set<string>;
}>({ metas: {}, invalid: new Set() });
+ useEffect(() => {
+ // Discovery belongs to the provider, not a visible row or display preference.
+ // Query only the task named by a durable tool-message push.
+ return window.electronAPI?.localDb?.messages?.onCreated?.(
+ ({ sessionId, message }, ownerStamp) => {
+ if (!sessionId || !isDataOwnerPushCurrent(ownerStamp)) return;
+ if (message.role !== 'tool_use' && message.role !== 'tool_result') return;
+ if (snapshot.metas[sessionId] && !snapshot.invalid.has(sessionId)) return;
+ void refreshObserved(sessionId, 'recent');
+ },
+ );
+ }, [snapshot, refreshObserved]);
// 全量刷新彼此只接收最后一次;单条事件另按 sessionId 记代次,避免连续回收时
// 一个 session 的迟到响应覆盖另一个 session 的新状态。
const fullRefreshGenerationRef = useRef(0);
@@ -59,18 +215,19 @@ export function WorktreeProvider({ children }: { children: ReactNode }) {
// 中间发生了更新的 refresh,丢弃本次结果
if (myTurn !== fullRefreshGenerationRef.current) return;
const entries = (list ?? []).filter((meta) => meta?.sessionId && meta.path);
- const mergeSnapshot = (next: Record<string, WorktreeMeta>) => setSnapshot((current) => {
- if (myTurn !== fullRefreshGenerationRef.current) return current;
- const merged = { ...next };
- // 快照读取期间若某个 session 收到更晚的权威事件,只保留该 session 当前
- // 的增量结果;未完成的增量请求随后会再落一次,不能让旧全量快照回写。
- for (const [sessionId, generation] of sessionEventGenerationsRef.current) {
- if (generation <= eventGenerationAtStart) continue;
- if (current.metas[sessionId]) merged[sessionId] = current.metas[sessionId];
- else delete merged[sessionId];
- }
- return { ...current, metas: merged };
- });
+ const mergeSnapshot = (next: Record<string, WorktreeMeta>) =>
+ setSnapshot((current) => {
+ if (myTurn !== fullRefreshGenerationRef.current) return current;
+ const merged = { ...next };
+ // 快照读取期间若某个 session 收到更晚的权威事件,只保留该 session 当前
+ // 的增量结果;未完成的增量请求随后会再落一次,不能让旧全量快照回写。
+ for (const [sessionId, generation] of sessionEventGenerationsRef.current) {
+ if (generation <= eventGenerationAtStart) continue;
+ if (current.metas[sessionId]) merged[sessionId] = current.metas[sessionId];
+ else delete merged[sessionId];
+ }
+ return { ...current, metas: merged };
+ });
mergeSnapshot(Object.fromEntries(entries.map((meta) => [meta.sessionId, meta])));
} catch (err) {
log.warn('refresh failed:', err);
@@ -89,8 +246,7 @@ export function WorktreeProvider({ children }: { children: ReactNode }) {
try {
const meta = await getForSession(sessionId);
if (!isCurrent()) return;
- const next =
- meta?.sessionId === sessionId && meta.path ? meta : null;
+ const next = meta?.sessionId === sessionId && meta.path ? meta : null;
if (!isCurrent()) return;
setSnapshot((current) => {
if (!isCurrent()) return current;
@@ -135,8 +291,11 @@ export function WorktreeProvider({ children }: { children: ReactNode }) {
return subscribe(({ sessionId }) => {
if (!sessionId) return;
void refreshSession(sessionId);
+ // An observed path may subsequently have become managed. Recycling must
+ // invalidate that old display snapshot even when its task is not open.
+ if (observed.get(sessionId)) void refreshObserved(sessionId);
});
- }, [refreshSession]);
+ }, [refreshSession, observed, refreshObserved]);
// Renderer 主动创建/恢复时调用方会直接 refreshSession;Scheduler、hook-control
// 等后台入口只会在 session 建成后广播 sessions:created。这里同样只查该 session,
@@ -152,13 +311,19 @@ export function WorktreeProvider({ children }: { children: ReactNode }) {
});
}, [refreshSession]);
- const value = useMemo<WorktreeContextValue>(() => ({
- metas: Object.fromEntries(Object.entries(snapshot.metas)
- .filter(([sessionId]) => !snapshot.invalid.has(sessionId))),
- rawMetas: snapshot.metas,
- reportLiveness,
- refreshSession,
- }), [snapshot, reportLiveness, refreshSession]);
+ const value = useMemo<WorktreeContextValue>(
+ () => ({
+ metas: Object.fromEntries(
+ Object.entries(snapshot.metas).filter(([sessionId]) => !snapshot.invalid.has(sessionId)),
+ ),
+ rawMetas: snapshot.metas,
+ reportLiveness,
+ observed,
+ refreshObserved,
+ refreshSession,
+ }),
+ [snapshot, reportLiveness, observed, refreshObserved, refreshSession],
+ );
return <WorktreeContext.Provider value={value}>{children}</WorktreeContext.Provider>;
}
@@ -191,6 +356,19 @@ export function useReportWorktreeLiveness(): WorktreeContextValue['reportLivenes
return useCtx().reportLiveness;
}
+export function useObservedWorktreeForSession(sessionId: string): ObservedWorktree['info'] | null {
+ const { observed } = useCtx();
+ const subscribe = useCallback(
+ (listener: () => void) => observed.subscribe(sessionId, listener),
+ [observed, sessionId],
+ );
+ return useSyncExternalStore(subscribe, () => observed.get(sessionId));
+}
+
+export function useRefreshObservedWorktree(): WorktreeContextValue['refreshObserved'] {
+ return useCtx().refreshObserved;
+}
+
/** 让创建/恢复等明确知道 sessionId 的调用方只刷新对应 worktree。 */
export function useRefreshWorktreeForSession(): (sessionId: string) => Promise<void> {
return useCtx().refreshSession;
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
index 669dd6b6a4..6b48da1738 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/SessionCard.visual.test.ts
@@ -113,9 +113,12 @@ vi.mock('@/components/sidebar/WorktreeBadge', () => ({
vi.mock('@/contexts/WorktreeContext', () => {
const reportLiveness = vi.fn();
+ const refreshObserved = vi.fn();
return {
useWorktreeForSession: () => null,
useReportWorktreeLiveness: () => reportLiveness,
+ useObservedWorktreeForSession: () => null,
+ useRefreshObservedWorktree: () => refreshObserved,
};
});
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
index 761b0df8b5..392fd4b12a 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionRowRenderIsolation.test.ts
@@ -97,9 +97,12 @@ vi.mock('@/components/sidebar/WorktreeBadge', () => ({
vi.mock('@/contexts/WorktreeContext', () => {
const reportLiveness = vi.fn();
+ const refreshObserved = vi.fn();
return {
useWorktreeForSession: () => null,
useReportWorktreeLiveness: () => reportLiveness,
+ useObservedWorktreeForSession: () => null,
+ useRefreshObservedWorktree: () => refreshObserved,
};
});
@@ -566,11 +569,16 @@ describe('父层 — 行级 handler 的引用稳定性', () => {
resolve(__dirname, '..', 'AutomationSessionGroupItem.tsx'),
'utf8',
);
- const navigationAdapter = readFileSync(resolve(__dirname, '..', 'sidebarNavigation.tsx'), 'utf8');
+ const navigationAdapter = readFileSync(
+ resolve(__dirname, '..', 'sidebarNavigation.tsx'),
+ 'utf8',
+ );
expect(navigationAdapter).toMatch(/const Row = memo\(Component\)/);
expect(sessionCard).toMatch(/export const SessionCard = withSidebarNavigation</);
expect(projectNode).toMatch(/export const ProjectNode = memo\(/);
- expect(automationGroup).toMatch(/export const AutomationSessionGroupItem = withSidebarNavigation</);
+ expect(automationGroup).toMatch(
+ /export const AutomationSessionGroupItem = withSidebarNavigation</,
+ );
});
it('runningSessionIds 必须 memo 化(否则每渲染 new Set 打穿整表)', () => {
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionWorktreeInfoRefresh.test.tsx b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionWorktreeInfoRefresh.test.tsx
index 012245d662..b841cb3f1a 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionWorktreeInfoRefresh.test.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/__tests__/sessionWorktreeInfoRefresh.test.tsx
@@ -16,6 +16,8 @@ const mocks = vi.hoisted(() => ({
vi.mock('@/contexts/WorktreeContext', () => ({
useWorktreeForSession: mocks.official,
useReportWorktreeLiveness: () => mocks.reportLiveness,
+ useObservedWorktreeForSession: () => null,
+ useRefreshObservedWorktree: () => mocks.findLinked,
}));
const session = { id: 'open', workingDir: '/repo', worktreePath: '/tmp/wt/open' };
@@ -28,7 +30,9 @@ function switchFocus() {
beforeEach(() => {
vi.useFakeTimers();
mocks.reportLiveness.mockReset();
- mocks.official.mockReset().mockReturnValue({ path: '/tmp/wt/open', name: 'open', branch: 'feature' });
+ mocks.official
+ .mockReset()
+ .mockReturnValue({ path: '/tmp/wt/open', name: 'open', branch: 'feature' });
mocks.detect.mockReset().mockResolvedValue({ isInsideWorktree: true });
mocks.findLinked.mockReset().mockResolvedValue(null);
mocks.listeners.clear();
@@ -52,7 +56,9 @@ afterEach(() => {
describe('opened worktree refresh', () => {
it('checks an active task again when it regains focus and hides an externally deleted worktree', async () => {
- const { result } = renderHook(() => useTaskInfoWorktree(session, true, { observeTelemetry: true }));
+ const { result } = renderHook(() =>
+ useTaskInfoWorktree(session, true, { observeTelemetry: true }),
+ );
await act(async () => {});
expect(result.current?.source).toBe('managed');
@@ -69,9 +75,16 @@ describe('opened worktree refresh', () => {
options?.includeInvalid ? official : null,
);
let finish!: (value: { isInsideWorktree: boolean }) => void;
- mocks.detect.mockImplementation(() => new Promise((resolve) => { finish = resolve; }));
+ mocks.detect.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
- const { result } = renderHook(() => useTaskInfoWorktree(session, true, { observeTelemetry: true }));
+ const { result } = renderHook(() =>
+ useTaskInfoWorktree(session, true, { observeTelemetry: true }),
+ );
expect(result.current).toBeNull();
await act(async () => finish({ isInsideWorktree: true }));
@@ -81,10 +94,12 @@ describe('opened worktree refresh', () => {
it('resets liveness from the new snapshot when switching tasks in place', async () => {
const metaA = { path: '/tmp/wt/a', name: 'a', branch: 'feature-a' };
const metaB = { path: '/tmp/wt/b', name: 'b', branch: 'feature-b' };
- mocks.official.mockImplementation((sessionId: string, options?: { includeInvalid?: boolean }) => {
- if (options?.includeInvalid) return sessionId === 'a' ? metaA : metaB;
- return sessionId === 'a' ? null : metaB;
- });
+ mocks.official.mockImplementation(
+ (sessionId: string, options?: { includeInvalid?: boolean }) => {
+ if (options?.includeInvalid) return sessionId === 'a' ? metaA : metaB;
+ return sessionId === 'a' ? null : metaB;
+ },
+ );
mocks.detect.mockResolvedValue({ isInsideWorktree: false });
const view = renderHook(
({ current }) => useTaskInfoWorktree(current, true, { observeTelemetry: true }),
@@ -114,7 +129,12 @@ describe('opened worktree refresh', () => {
expect(mocks.listeners.size).toBe(0);
let reject!: (error: Error) => void;
- mocks.detect.mockImplementationOnce(() => new Promise((_resolve, fail) => { reject = fail; }));
+ mocks.detect.mockImplementationOnce(
+ () =>
+ new Promise((_resolve, fail) => {
+ reject = fail;
+ }),
+ );
view.rerender({ enabled: true });
expect(view.result.current).toBeNull();
await act(async () => reject(new Error('[INTERNAL] Worktree directory probe failed')));
@@ -130,10 +150,12 @@ describe('opened worktree refresh', () => {
it('updates liveness after a route switch even when the previous task had the same probe result', async () => {
const metaA = { path: '/tmp/wt/a', name: 'a', branch: 'feature-a' };
const metaB = { path: '/tmp/wt/b', name: 'b', branch: 'feature-b' };
- mocks.official.mockImplementation((sessionId: string, options?: { includeInvalid?: boolean }) => {
- if (options?.includeInvalid) return sessionId === 'a' ? metaA : metaB;
- return sessionId === 'a' ? metaA : null;
- });
+ mocks.official.mockImplementation(
+ (sessionId: string, options?: { includeInvalid?: boolean }) => {
+ if (options?.includeInvalid) return sessionId === 'a' ? metaA : metaB;
+ return sessionId === 'a' ? metaA : null;
+ },
+ );
const view = renderHook(
({ id }) => useTaskInfoWorktree({ ...session, id }, true, { observeTelemetry: true }),
{ initialProps: { id: 'a' } },
@@ -142,13 +164,23 @@ describe('opened worktree refresh', () => {
expect(view.result.current?.path).toBe(metaA.path);
let finish!: (value: { isInsideWorktree: boolean }) => void;
- mocks.detect.mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
+ mocks.detect.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
view.rerender({ id: 'b' });
expect(view.result.current).toBeNull();
await act(async () => finish({ isInsideWorktree: true }));
expect(view.result.current?.path).toBe(metaB.path);
- mocks.detect.mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
+ mocks.detect.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
view.rerender({ id: 'a' });
expect(view.result.current?.path).toBe(metaA.path);
await act(async () => finish({ isInsideWorktree: false }));
@@ -156,25 +188,40 @@ describe('opened worktree refresh', () => {
});
it('applies recycle and restore events immediately', async () => {
- const { result } = renderHook(() => useTaskInfoWorktree(session, true, { observeTelemetry: true }));
+ const { result } = renderHook(() =>
+ useTaskInfoWorktree(session, true, { observeTelemetry: true }),
+ );
await act(async () => {});
mocks.detect.mockResolvedValue({ isInsideWorktree: false });
- await act(async () => { mocks.listeners.forEach((cb) => cb({ sessionId: 'open' })); });
+ await act(async () => {
+ mocks.listeners.forEach((cb) => cb({ sessionId: 'open' }));
+ });
expect(result.current).toBeNull();
mocks.detect.mockResolvedValue({ isInsideWorktree: true });
- await act(async () => { mocks.listeners.forEach((cb) => cb({ sessionId: 'open' })); });
+ await act(async () => {
+ mocks.listeners.forEach((cb) => cb({ sessionId: 'open' }));
+ });
expect(result.current?.source).toBe('managed');
expect(mocks.detect).toHaveBeenCalledTimes(3);
- await act(async () => { mocks.listeners.forEach((cb) => cb({ sessionId: 'other' })); });
+ await act(async () => {
+ mocks.listeners.forEach((cb) => cb({ sessionId: 'other' }));
+ });
expect(mocks.detect).toHaveBeenCalledTimes(3);
});
it('coalesces authoritative changes during a pending check and discards its stale result', async () => {
let finish!: (value: { isInsideWorktree: boolean }) => void;
- mocks.detect.mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
+ mocks.detect.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
mocks.detect.mockResolvedValue({ isInsideWorktree: false });
- const { result } = renderHook(() => useTaskInfoWorktree(session, true, { observeTelemetry: true }));
+ const { result } = renderHook(() =>
+ useTaskInfoWorktree(session, true, { observeTelemetry: true }),
+ );
await act(async () => {
for (let i = 0; i < 10; i++) mocks.listeners.forEach((cb) => cb({ sessionId: 'open' }));
finish({ isInsideWorktree: true });
@@ -185,9 +232,16 @@ describe('opened worktree refresh', () => {
it('does not start queued work after unmount', async () => {
let finish!: (value: { isInsideWorktree: boolean }) => void;
- mocks.detect.mockImplementationOnce(() => new Promise((resolve) => { finish = resolve; }));
+ mocks.detect.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
const view = renderHook(() => useTaskInfoWorktree(session, true, { observeTelemetry: true }));
- act(() => { mocks.listeners.forEach((cb) => cb({ sessionId: 'open' })); });
+ act(() => {
+ mocks.listeners.forEach((cb) => cb({ sessionId: 'open' }));
+ });
view.unmount();
await act(async () => {
finish({ isInsideWorktree: true });
@@ -204,7 +258,9 @@ describe('opened worktree refresh', () => {
{ enabled: true, observeTelemetry: true, remoteHostId: 'ssh' },
])('never probes disabled, sidebar or remote entries: %j', async (opts) => {
renderHook(() => useTaskInfoWorktree({ ...session, ...opts }, opts.enabled, opts));
- await act(async () => { switchFocus(); });
+ await act(async () => {
+ switchFocus();
+ });
expect(mocks.detect).not.toHaveBeenCalled();
expect(mocks.findLinked).not.toHaveBeenCalled();
});
diff --git a/apps/desktop/src/renderer/features/cc-agent/sidebar/sessionWorktreeInfo.ts b/apps/desktop/src/renderer/features/cc-agent/sidebar/sessionWorktreeInfo.ts
index 8cc488058a..cf0e033905 100644
--- a/apps/desktop/src/renderer/features/cc-agent/sidebar/sessionWorktreeInfo.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/sidebar/sessionWorktreeInfo.ts
@@ -5,7 +5,7 @@
* observed = 本机任务遥测里仍活着的 linked worktree(可回溯,不只最近一次 cwd)
*
* 本机 Desktop 专用。SSH / device-link / Mobile 第一期不显示。
- * 侧栏任务信息只读官方 store(共享快照,不每行扫 Git);打开中的任务才回溯遥测。
+ * 侧栏共享托管与遥测快照,不在挂载时逐行扫 Git;打开任务或工具消息落库后回溯。
* 不写 store、不改变回收。目录没了摘掉徽标。外部 observed 不可 reveal。
*/
@@ -13,7 +13,12 @@ import { useEffect, useState } from 'react';
import { groupingWorktreeBaseRepo } from '@cindy/maker-shared/worktree-paths';
-import { useReportWorktreeLiveness, useWorktreeForSession } from '@/contexts/WorktreeContext';
+import {
+ useObservedWorktreeForSession,
+ useRefreshObservedWorktree,
+ useReportWorktreeLiveness,
+ useWorktreeForSession,
+} from '@/contexts/WorktreeContext';
import type { Session } from '@/lib/ccAgent.types';
import type { GitContextDirSource } from '@/lib/gitContext.types';
import type { DetectCwdResp, WorktreeMeta } from '@/lib/worktree.types';
@@ -108,9 +113,20 @@ export function useTaskInfoWorktree(
const official = useWorktreeForSession(session.id, { includeInvalid: observeTelemetry });
const reportLiveness = useReportWorktreeLiveness();
const managed = resolveManagedWorktree(official);
- const [observed, setObserved] = useState<SessionWorktreeInfo | null>(null);
+ const observedMeta = useObservedWorktreeForSession(session.id);
+ const observed = observedWorktreeFromTelemetry({
+ source: 'telemetry',
+ workdir: observedMeta?.workdir ?? null,
+ branch: observedMeta?.branch ?? null,
+ isInsideWorktree: observedMeta !== null,
+ });
+ const refreshObserved = useRefreshObservedWorktree();
const initialOfficialStillLive = !observeTelemetry || liveOfficial !== null;
- const [liveness, setLiveness] = useState({ sessionId: session.id, official, live: initialOfficialStillLive });
+ const [liveness, setLiveness] = useState({
+ sessionId: session.id,
+ official,
+ live: initialOfficialStillLive,
+ });
const matchesSnapshot = liveness.sessionId === session.id && liveness.official === official;
if (!matchesSnapshot) {
// Route changes and same-path restoration both replace the snapshot that
@@ -118,15 +134,12 @@ export function useTaskInfoWorktree(
// invalid result cannot override a new authoritative row while probing.
setLiveness({ sessionId: session.id, official, live: initialOfficialStillLive });
}
- const displayedOfficialStillLive = matchesSnapshot
- ? liveness.live
- : initialOfficialStillLive;
+ const displayedOfficialStillLive = matchesSnapshot ? liveness.live : initialOfficialStillLive;
const officialPath = official?.path ?? null;
const deviceId = session.deviceLinkDeviceId ?? null;
const isRemote = Boolean(deviceId || session.remoteHostId);
useEffect(() => {
- setObserved(null);
if (!enabled || isRemote || !observeTelemetry) {
// Pausing probes says nothing about directory liveness. Preserve the last
// result until a resumed probe actually confirms deletion or restoration.
@@ -145,18 +158,12 @@ export function useTaskInfoWorktree(
setLiveness({ sessionId: session.id, official, live });
if (official) reportLiveness(official, live);
if (live) {
- setObserved(null);
return;
}
} else if (gen === generation) {
setLiveness({ sessionId: session.id, official, live: false });
}
- if (isRemote) {
- if (!cancelled && gen === generation) setObserved(null);
- return;
- }
- const next = await discoverObservedWorktree(session.id);
- if (!cancelled && gen === generation) setObserved(next);
+ await refreshObserved(session.id);
};
const refresh = () => {
if (inflight) {
@@ -186,7 +193,17 @@ export function useTaskInfoWorktree(
unsubscribe?.();
window.removeEventListener('focus', onFocus);
};
- }, [enabled, official, officialPath, deviceId, isRemote, observeTelemetry, session.id, reportLiveness]);
+ }, [
+ enabled,
+ official,
+ officialPath,
+ deviceId,
+ isRemote,
+ observeTelemetry,
+ session.id,
+ reportLiveness,
+ refreshObserved,
+ ]);
if (isRemote) return null;
if (!observeTelemetry) {
@@ -194,7 +211,7 @@ export function useTaskInfoWorktree(
enabled,
managed,
officialStillLive: true,
- observed: null,
+ observed,
});
}
return selectDisplayedWorktree({
@@ -205,7 +222,10 @@ export function useTaskInfoWorktree(
});
}
-async function probeIsInsideWorktree(cwd: string, deviceId: string | null): Promise<boolean | null> {
+async function probeIsInsideWorktree(
+ cwd: string,
+ deviceId: string | null,
+): Promise<boolean | null> {
try {
const detect: DetectCwdResp = deviceId
? ((await window.electronAPI.deviceLink.invoke(deviceId, DETECT_CWD_CHANNEL, [
@@ -217,18 +237,3 @@ async function probeIsInsideWorktree(cwd: string, deviceId: string | null): Prom
return null;
}
}
-
-async function discoverObservedWorktree(sessionId: string): Promise<SessionWorktreeInfo | null> {
- try {
- const found = await window.electronAPI.gitContext.findLinkedWorktree({ sessionId });
- if (!found?.workdir) return null;
- return observedWorktreeFromTelemetry({
- source: 'telemetry',
- workdir: found.workdir,
- branch: found.branch,
- isInsideWorktree: true,
- });
- } catch {
- return null;
- }
-}
diff --git a/docs/product-rules/sidebar-redesign-plan.md b/docs/product-rules/sidebar-redesign-plan.md
index 06707bb245..0dfcd1f805 100644
--- a/docs/product-rules/sidebar-redesign-plan.md
+++ b/docs/product-rules/sidebar-redesign-plan.md
@@ -232,7 +232,7 @@
|---|---|---|
| 最近活动时间 | **勾** | 现状行为 |
| PR 状态 | | 状态 icon + 等宽 `#号`(与顶栏 PrChip 同款,2026-08-12 用户裁决):状态颜色只上在 icon 上(形状 + 颜色双编码,四态见 `gitContextPrVisuals`;open 绿按表面取 `#2EA043` / `#3FB950`,2026-08-17);`#号` 文字用信息槽常规灰;open/draft 且有未解决 review thread 时 icon 右上角 5px `--status-bar-accent` 静点;文字状态放 hover;无 PR 的任务不显示不占位 |
-| worktree | | Folders 图标,不写短名;默认不勾。仅本机 Desktop。侧栏只认 Cindy 官方 store(共享快照);打开中的任务才回溯遥测,短名在聊天框底部 `仓库 (worktree)`。SSH / device-link / Mobile 不显示。外部 observed 不可从侧栏 reveal。目录没了摘标。 |
+| worktree | | Folders 图标,不写短名;默认不勾。仅本机 Desktop。侧栏与卡片共享 Cindy 官方登记和工具调用识别出的存活 Worktree;打开任务及工具消息落库后按需回溯遥测,不在列表挂载时逐行扫描 Git。识别结果在切换任务后保留于当前窗口,短名在聊天框底部 `仓库 (worktree)`。SSH / device-link / Mobile 不显示。外部 observed 不进入托管登记或回收,不可从侧栏 reveal。重新探测确认目录没了摘标。实现与回归见 `sessionWorktreeInfo.ts`、`worktreeContextRecycleRefresh.test.tsx`。 |
| 累计 token | | `1.4M` / `320k` 缩写,无单位 |
| 费用 | | 按 `totalCostCurrency` 显示 $/¥;无数据(如订阅模式)留空 |