vibepulse 0.2.2 → 0.3.0-beta.0

package/.next/standalone/src/components/KanbanBoard.test.tsx

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as TestingLibraryReact from '@testing-library/react';
-import { KanbanBoard } from './KanbanBoard';
+import { KanbanBoard, detectStatusTransitionSounds } from './KanbanBoard';
 import { useHostSources } from '@/hooks/useHostSources';
 
 type RenderFn = (ui: React.ReactElement) => unknown;
@@ -10,6 +10,7 @@ type Screen = {
     getByText: (text: RegExp | string) => HTMLElement;
     getAllByText: (text: RegExp | string) => HTMLElement[];
     getByTitle: (title: RegExp | string) => HTMLElement;
+    queryByTitle: (title: RegExp | string) => HTMLElement | null;
     queryAllByTitle: (title: RegExp | string) => HTMLElement[];
 };
 type FireEventFn = {
@@ -33,6 +34,7 @@ vi.mock('@tanstack/react-query', () => ({
 
 vi.mock('@/lib/notificationSound', () => ({
     playCompleteSound: vi.fn(),
+    playAttentionSound: vi.fn(),
 }));
 
 import { useQuery } from '@tanstack/react-query';
@@ -79,6 +81,21 @@ function renderBoard(filterDays = 7, hostSources = createHostSourcesState(), isN
     return render(<KanbanBoard filterDays={filterDays} hostSources={hostSources} isNodeMode={isNodeMode} />);
 }
 
+function getSessionsQueryOptions(): { refetchInterval?: (query: { state: { fetchStatus: string; data?: unknown } }) => number | false } | undefined {
+    const useQueryMock = useQuery as unknown as {
+        mock: {
+            calls: Array<[Record<string, unknown>]>;
+        };
+    };
+
+    const matchedCall = useQueryMock.mock.calls.find(([options]) => (
+        Array.isArray(options.queryKey)
+        && (options.queryKey as unknown[])[0] === 'sessions'
+    ));
+
+    return matchedCall?.[0] as { refetchInterval?: (query: { state: { fetchStatus: string; data?: unknown } }) => number | false } | undefined;
+}
+
 describe('KanbanBoard Host Filter', () => {
     let hostSourcesState: HostSourcesState;
 
@@ -292,6 +309,34 @@ describe('KanbanBoard Host Filter', () => {
     });
 });
 
+describe('KanbanBoard sounds', () => {
+    it('detects review sound transition when card moves into review', () => {
+        const previous = {
+            'session-1': 'busy',
+        } as const;
+
+        const next = {
+            'session-1': 'review',
+        } as const;
+
+        const transitions = detectStatusTransitionSounds(previous, next);
+        expect(transitions).toEqual({ shouldPlayReview: true, shouldPlayComplete: false });
+    });
+
+    it('detects completion sound transition when card moves into idle', () => {
+        const previous = {
+            'session-1': 'review',
+        } as const;
+
+        const next = {
+            'session-1': 'idle',
+        } as const;
+
+        const transitions = detectStatusTransitionSounds(previous, next);
+        expect(transitions).toEqual({ shouldPlayReview: false, shouldPlayComplete: true });
+    });
+});
+
 describe('KanbanBoard Fetch Behavior and Error UX', () => {
     let mockFetch: { mockResolvedValue: (val: unknown) => void; mockRestore: () => void; mock: { calls: unknown[][] } };
     let hostSourcesState: HostSourcesState;
@@ -551,6 +596,10 @@ describe('KanbanBoard Fetch Behavior and Error UX', () => {
         });
 
         expect(screen.getByTestId('host-filter')).toBeTruthy();
+        const openButton = screen.getByTitle('Open project') as HTMLButtonElement;
+        expect(openButton.disabled).toBe(true);
+        expect(screen.queryByTitle('Batch actions')).toBeNull();
+        expect(screen.queryAllByTitle('Actions')).toHaveLength(0);
     });
 
     it('dedupes legacy raw Local snapshot sessions against degraded namespaced Local sessions', async () => {
@@ -627,6 +676,263 @@ describe('KanbanBoard Fetch Behavior and Error UX', () => {
         });
     });
 
+    it('keeps descendant-carrying intermediate cards when child-id deduplicating board cards', async () => {
+        const now = Date.now();
+        mockUseQuery.mockReturnValue({
+            data: {
+                sessions: [
+                    {
+                        id: 'local:root-session',
+                        sourceSessionKey: 'local:root-session',
+                        rawSessionId: 'root-session',
+                        slug: 'session_root_agent',
+                        title: 'Root Session',
+                        directory: '/tmp/local',
+                        projectName: 'Shared Project',
+                        hostId: 'local',
+                        hostLabel: 'Local',
+                        hostKind: 'local',
+                        readOnly: false,
+                        time: { created: now - 3_000, updated: now - 2_000 },
+                        realTimeStatus: 'busy',
+                        waitingForUser: false,
+                        children: [
+                            {
+                                id: 'local:intermediate-session',
+                                parentID: 'local:root-session',
+                                rawSessionId: 'intermediate-session',
+                                sourceSessionKey: 'local:intermediate-session',
+                                title: 'Intermediate Child Row',
+                                realTimeStatus: 'busy',
+                                waitingForUser: false,
+                                time: { created: now - 2_000, updated: now - 1_500 },
+                            },
+                        ],
+                    },
+                    {
+                        id: 'local:intermediate-session',
+                        sourceSessionKey: 'local:intermediate-session',
+                        rawSessionId: 'intermediate-session',
+                        slug: 'session_intermediate_agent',
+                        title: 'Intermediate Top-level Session',
+                        directory: '/tmp/local',
+                        projectName: 'Shared Project',
+                        hostId: 'local',
+                        hostLabel: 'Local',
+                        hostKind: 'local',
+                        readOnly: false,
+                        time: { created: now - 2_000, updated: now - 1_000 },
+                        realTimeStatus: 'busy',
+                        waitingForUser: false,
+                        children: [
+                            {
+                                id: 'local:grandchild-session',
+                                parentID: 'local:intermediate-session',
+                                rawSessionId: 'grandchild-session',
+                                sourceSessionKey: 'local:grandchild-session',
+                                title: 'Grandchild Session',
+                                realTimeStatus: 'busy',
+                                waitingForUser: false,
+                                time: { created: now - 1_000, updated: now - 500 },
+                            },
+                        ],
+                    },
+                ],
+                processHints: [],
+                hostStatuses: [
+                    { hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true },
+                ],
+            },
+            isLoading: false,
+            error: null,
+            isFetching: false,
+            failureCount: 0,
+            dataUpdatedAt: now,
+            refetch: vi.fn(),
+        });
+
+        renderBoard(7, hostSourcesState);
+
+        await waitFor(() => {
+            expect(screen.getByText('Root Session')).toBeTruthy();
+            expect(screen.getByText('Intermediate Top-level Session')).toBeTruthy();
+            expect(screen.getByText('Grandchild Session')).toBeTruthy();
+        });
+    });
+
+    it('uses faster polling while Claude waiting sessions are present', () => {
+        mockUseQuery.mockImplementation((opts: unknown) => {
+            const options = opts as { queryKey: string[] };
+            if (options.queryKey[0] === 'opencode-config') {
+                return {
+                    data: { vibepulse: { sessionsRefreshIntervalMs: 5000 } },
+                    isLoading: false,
+                };
+            }
+
+            if (options.queryKey[0] === 'sessions') {
+                return {
+                    data: {
+                        sessions: [],
+                        processHints: [],
+                        hostStatuses: [{ hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true }],
+                    },
+                    isLoading: false,
+                    error: null,
+                    dataUpdatedAt: Date.now(),
+                    refetch: vi.fn(),
+                    isFetching: false,
+                    failureCount: 0,
+                };
+            }
+
+            return {
+                data: undefined,
+                isLoading: false,
+            };
+        });
+
+        renderBoard(7, hostSourcesState);
+
+        const queryOptions = getSessionsQueryOptions();
+        const refetchInterval = queryOptions?.refetchInterval;
+
+        expect(refetchInterval).toBeTypeOf('function');
+        expect(refetchInterval?.({
+            state: {
+                fetchStatus: 'idle',
+                data: {
+                    sessions: [{ id: 'local:claude~abc', provider: 'claude-code', waitingForUser: true }],
+                },
+            },
+        })).toBe(1500);
+        expect(refetchInterval?.({
+            state: {
+                fetchStatus: 'idle',
+                data: {
+                    sessions: [{ id: 'local:abc', provider: 'opencode', waitingForUser: true }],
+                },
+            },
+        })).toBe(5000);
+        expect(refetchInterval?.({
+            state: {
+                fetchStatus: 'fetching',
+                data: {
+                    sessions: [{ id: 'local:claude~abc', provider: 'claude-code', waitingForUser: true }],
+                },
+            },
+        })).toBe(false);
+    });
+
+    it('uses faster polling when Claude waiting appears in nested child sessions', () => {
+        mockUseQuery.mockImplementation((opts: unknown) => {
+            const options = opts as { queryKey: string[] };
+            if (options.queryKey[0] === 'opencode-config') {
+                return {
+                    data: { vibepulse: { sessionsRefreshIntervalMs: 5000 } },
+                    isLoading: false,
+                };
+            }
+
+            if (options.queryKey[0] === 'sessions') {
+                return {
+                    data: {
+                        sessions: [],
+                        processHints: [],
+                        hostStatuses: [{ hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true }],
+                    },
+                    isLoading: false,
+                    error: null,
+                    dataUpdatedAt: Date.now(),
+                    refetch: vi.fn(),
+                    isFetching: false,
+                    failureCount: 0,
+                };
+            }
+
+            return {
+                data: undefined,
+                isLoading: false,
+            };
+        });
+
+        renderBoard(7, hostSourcesState);
+
+        const queryOptions = getSessionsQueryOptions();
+        const refetchInterval = queryOptions?.refetchInterval;
+
+        expect(refetchInterval).toBeTypeOf('function');
+        expect(refetchInterval?.({
+            state: {
+                fetchStatus: 'idle',
+                data: {
+                    sessions: [
+                        {
+                            id: 'local:parent',
+                            provider: 'opencode',
+                            waitingForUser: false,
+                            children: [
+                                {
+                                    id: 'local:claude~child',
+                                    provider: 'claude-code',
+                                    waitingForUser: true,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        })).toBe(1500);
+    });
+
+    it('keeps configured fast polling when it is already faster than the Claude waiting boost', () => {
+        mockUseQuery.mockImplementation((opts: unknown) => {
+            const options = opts as { queryKey: string[] };
+            if (options.queryKey[0] === 'opencode-config') {
+                return {
+                    data: { vibepulse: { sessionsRefreshIntervalMs: 1000 } },
+                    isLoading: false,
+                };
+            }
+
+            if (options.queryKey[0] === 'sessions') {
+                return {
+                    data: {
+                        sessions: [],
+                        processHints: [],
+                        hostStatuses: [{ hostId: 'local', hostLabel: 'Local', hostKind: 'local', online: true }],
+                    },
+                    isLoading: false,
+                    error: null,
+                    dataUpdatedAt: Date.now(),
+                    refetch: vi.fn(),
+                    isFetching: false,
+                    failureCount: 0,
+                };
+            }
+
+            return {
+                data: undefined,
+                isLoading: false,
+            };
+        });
+
+        renderBoard(7, hostSourcesState);
+
+        const queryOptions = getSessionsQueryOptions();
+        const refetchInterval = queryOptions?.refetchInterval;
+
+        expect(refetchInterval).toBeTypeOf('function');
+        expect(refetchInterval?.({
+            state: {
+                fetchStatus: 'idle',
+                data: {
+                    sessions: [{ id: 'local:claude~abc', provider: 'claude-code', waitingForUser: true }],
+                },
+            },
+        })).toBe(1000);
+    });
+
     it('does not repeatedly emit unchanged host statuses but emits when status values change', () => {
         const onHostStatusesChange = vi.fn() as unknown as (statuses: import('./KanbanBoard').SessionHostStatus[]) => void;
 

package/.next/standalone/src/components/KanbanBoard.tsx

@@ -5,7 +5,7 @@ import { KanbanColumn, KanbanCard, OpencodeSession } from '@/types';
 import { ProjectCard } from './ProjectCard';
 import { transformSessions } from '@/lib/transform';
 import { LoadingState } from './LoadingState';
-import { playCompleteSound } from '@/lib/notificationSound';
+import { playAttentionSound, playCompleteSound } from '@/lib/notificationSound';
 import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 import { getSseStatusSnapshot } from '@/hooks/useOpencodeSync';
 import { useHostSources } from '@/hooks/useHostSources';
@@ -19,6 +19,7 @@ const CARD_ANIMATION_DURATION_MS = 250;
 const SESSIONS_ERROR_DISPLAY_THRESHOLD = 3;
 const DEGRADED_MERGE_MAX_SNAPSHOT_AGE_MS = 10 * 60 * 1000;
 const WAITING_PERSIST_MAX_AGE_MS = 10 * 60 * 1000;
+const CLAUDE_WAITING_FAST_REFRESH_INTERVAL_MS = 1500;
 
 const LOCAL_SOURCE = {
     hostId: 'local',
@@ -117,9 +118,30 @@ function areHostStatusesEqual(
     return true;
 }
 
+export function detectStatusTransitionSounds(
+    previous: Record<string, KanbanColumn>,
+    next: Record<string, KanbanColumn>
+): { shouldPlayReview: boolean; shouldPlayComplete: boolean } {
+    const shouldPlayReview = Object.entries(next).some(([id, currentStatus]) => {
+        const previousStatus = previous[id];
+        return !!previousStatus && previousStatus !== 'review' && currentStatus === 'review';
+    });
+
+    const shouldPlayComplete = Object.entries(next).some(([id, currentStatus]) => {
+        const previousStatus = previous[id];
+        return !!previousStatus && previousStatus !== 'idle' && currentStatus === 'idle';
+    });
+
+    return { shouldPlayReview, shouldPlayComplete };
+}
+
 function getLocalWaitingPersistenceKey(
-    session: Pick<OpencodeSession, 'id' | 'sourceSessionKey' | 'hostId' | 'hostKind'>
+    session: Pick<OpencodeSession, 'id' | 'sourceSessionKey' | 'hostId' | 'hostKind' | 'provider'>
 ): string | null {
+    if (session.provider === 'claude-code') {
+        return null;
+    }
+
     const sourceKey = session.sourceSessionKey || session.id;
     if (session.hostKind === 'local' || session.hostId === 'local' || sourceKey.startsWith('local:')) {
         return sourceKey;
@@ -150,6 +172,45 @@ function getCanonicalSessionIdentity(
     return session.id;
 }
 
+function hasWaitingClaudeSession(data: unknown): boolean {
+    if (!data || typeof data !== 'object') {
+        return false;
+    }
+
+    const maybeSessions = (data as { sessions?: unknown }).sessions;
+    if (!Array.isArray(maybeSessions) || maybeSessions.length === 0) {
+        return false;
+    }
+
+    const queue: Array<{ provider?: string; waitingForUser?: boolean; children?: unknown[] }> = [];
+    for (const session of maybeSessions) {
+        if (session && typeof session === 'object') {
+            queue.push(session as { provider?: string; waitingForUser?: boolean; children?: unknown[] });
+        }
+    }
+
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+
+        if (current.provider === 'claude-code' && current.waitingForUser === true) {
+            return true;
+        }
+
+        if (Array.isArray(current.children) && current.children.length > 0) {
+            for (const child of current.children) {
+                if (child && typeof child === 'object') {
+                    queue.push(child as { provider?: string; waitingForUser?: boolean; children?: unknown[] });
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
 export function KanbanBoard({
     filterDays,
     onProcessHintsChange,
@@ -245,7 +306,17 @@ export function KanbanBoard({
                 throw fetchError;
             }
         },
-        refetchInterval: (query) => query.state.fetchStatus === 'fetching' ? false : refreshIntervalMs,
+        refetchInterval: (query) => {
+            if (query.state.fetchStatus === 'fetching') {
+                return false;
+            }
+
+            if (hasWaitingClaudeSession(query.state.data)) {
+                return Math.min(refreshIntervalMs, CLAUDE_WAITING_FAST_REFRESH_INTERVAL_MS);
+            }
+
+            return refreshIntervalMs;
+        },
         refetchIntervalInBackground: true,
         refetchOnReconnect: true,
         retry: false,
@@ -490,7 +561,22 @@ export function KanbanBoard({
 
     const cards: KanbanCard[] = useMemo(() => {
         const allCards = transformSessions(enrichedSessions);
-        let filtered = allCards;
+        
+        const childSessionIds = new Set<string>();
+        for (const card of allCards) {
+            for (const child of card.children || []) {
+                childSessionIds.add(child.id);
+            }
+        }
+        
+        let filtered = allCards.filter((card) => {
+            if (!childSessionIds.has(card.id)) {
+                return true;
+            }
+
+            return (card.children?.length ?? 0) > 0;
+        });
+        
         if (filteredHostIds) {
             filtered = filtered.filter(card => {
                 const cardHostId = card.hostId || 'local';
@@ -529,13 +615,17 @@ export function KanbanBoard({
             return;
         }
 
-        const shouldPlayComplete = Object.entries(nextCardStatus).some(([id, currentStatus]) => {
-            const previousStatus = cardStatusStateRef.current[id];
-            return !!previousStatus && previousStatus !== 'idle' && currentStatus === 'idle';
-        });
+        const { shouldPlayReview, shouldPlayComplete } = detectStatusTransitionSounds(
+            cardStatusStateRef.current,
+            nextCardStatus
+        );
 
         cardStatusStateRef.current = nextCardStatus;
 
+        if (shouldPlayReview && !isShowingStaleData) {
+            setTimeout(() => playAttentionSound(), CARD_ANIMATION_DURATION_MS);
+        }
+
         if (shouldPlayComplete && !isShowingStaleData) {
             setTimeout(() => playCompleteSound(), CARD_ANIMATION_DURATION_MS);
         }
@@ -753,7 +843,6 @@ export function KanbanBoard({
             projectName: string;
             branch?: string;
             hostLabel?: string;
-            readOnly: boolean;
             cards: KanbanCard[];
         }>();
 
@@ -767,14 +856,12 @@ export function KanbanBoard({
                     projectName,
                     branch: card.branch,
                     hostLabel: card.hostLabel,
-                    readOnly: !!card.readOnly,
                     cards: [],
                 });
             }
 
             const group = groups.get(key)!;
             group.cards.push(card);
-            group.readOnly = group.readOnly || !!card.readOnly;
 
             if (!group.branch && card.branch) {
                 group.branch = card.branch;
@@ -832,13 +919,13 @@ export function KanbanBoard({
                                     {Array.from(projectGroups.entries()).map(([groupKey, group]) => (
                                          <ProjectCard
                                             key={groupKey}
-                                            projectName={group.projectName}
-                                            branch={group.branch}
-                                            cards={group.cards}
-                                            readOnly={isShowingStaleData || group.readOnly}
-                                             hostLabel={group.hostLabel}
-                                             multipleHostsEnabled={requestSources.length > 1}
-                                          />
+                                             projectName={group.projectName}
+                                             branch={group.branch}
+                                             cards={group.cards}
+                                            readOnly={isShowingStaleData}
+                                              hostLabel={group.hostLabel}
+                                              multipleHostsEnabled={requestSources.length > 1}
+                                           />
                                       ))}
                                 </div>
                             </div>