Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(desktop): 工具识别的 Worktree 同步显示到任务列表 (#4662)
Dash80aaa4bb427d
diff --git a/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsx b/apps/desktop/src/renderer/__tests__/worktreeContextRecycleRefresh.test.tsxindex 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.tsxindex 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['reportLivenesreturn 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.tsindex 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.tsindex 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.tsxindex 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.tsindex 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): Promreturn 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.mdindex 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` 显示 $/¥;无数据(如订阅模式)留空 |