@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/hooks/useFilterSort.test.js

@@ -0,0 +1,333 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { useFilterSort } from './useFilterSort';
+function makeTask(overrides) {
+    return {
+        id: overrides.id || 'task-1',
+        title: overrides.title || 'Task',
+        description: overrides.description ?? null,
+        status: (overrides.status || 'task'),
+        priority: overrides.priority ?? 2,
+        complexity: overrides.complexity ?? 3,
+        type: overrides.type || 'feature',
+        category: overrides.category || 'default',
+        createdAt: overrides.createdAt || '2026-03-23T00:00:00.000Z',
+        updatedAt: overrides.updatedAt || null,
+        completedAt: overrides.completedAt || null,
+        canceledReason: overrides.canceledReason || null,
+        isArchived: overrides.isArchived || false,
+        scheduledDate: overrides.scheduledDate || null,
+        dueDate: overrides.dueDate || null,
+        scheduledWeekKey: overrides.scheduledWeekKey || null,
+        orderInDay: overrides.orderInDay || null,
+        taxonomies: overrides.taxonomies || {},
+        createdBy: overrides.createdBy,
+        assignee: overrides.assignee || 'unassigned',
+        comments: overrides.comments || [],
+        attachments: overrides.attachments || [],
+        activity: overrides.activity || [],
+        taskEvents: overrides.taskEvents || []
+    };
+}
+describe('useFilterSort', () => {
+    const activeCategories = [
+        { value: 'default', label: 'Default', disabled: false },
+        { value: 'ops', label: 'Ops', disabled: false }
+    ];
+    const activeTypes = [
+        { value: 'feature', label: 'Feature' },
+        { value: 'bug', label: 'Bug' }
+    ];
+    const priorities = [
+        { value: 1, label: 'Low' },
+        { value: 2, label: 'Medium' },
+        { value: 3, label: 'High' }
+    ];
+    const assigneeOptions = [
+        { value: 'unassigned', label: 'Unassigned', icon: 'HelpCircle', color: '#999', kind: 'unassigned' },
+        { value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member' }
+    ];
+    const taxonomies = [
+        {
+            id: 'track',
+            label: 'Track',
+            options: [{ value: 'platform', label: 'Platform' }],
+            widgetType: 'select',
+            isSystem: false,
+            multiSelect: false
+        }
+    ];
+    it('keeps tasks with unknown values visible when every filter is effectively toggle-all', async () => {
+        const knownTask = makeTask({
+            id: 'known-task',
+            title: 'Known task',
+            category: 'default',
+            type: 'feature',
+            priority: 2,
+            status: 'task',
+            assignee: 'unassigned',
+            taxonomies: { track: 'platform' }
+        });
+        const unknownTask = makeTask({
+            id: 'unknown-task',
+            title: 'Unknown task',
+            category: 'ghost-category',
+            type: 'ghost-type',
+            priority: 99,
+            status: 'ghost-status',
+            assignee: 'ghost-assignee',
+            taxonomies: { track: 'ghost-track' }
+        });
+        const unknownArchivedTask = makeTask({
+            id: 'unknown-archived-task',
+            title: 'Unknown archived task',
+            category: 'ghost-category',
+            type: 'ghost-type',
+            priority: 99,
+            assignee: 'ghost-assignee',
+            taxonomies: { track: 'ghost-track' },
+            isArchived: true
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [knownTask, unknownTask],
+            archivedTasks: [unknownArchivedTask],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies,
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['known-task', 'unknown-task']);
+        expect(result.current.searchAgnosticTasks.map((task) => task.id)).toEqual(['known-task', 'unknown-task']);
+        expect(result.current.filteredArchive.map((task) => task.id)).toEqual(['unknown-archived-task']);
+    });
+    it('still excludes unknown values when the user selects a subset filter', async () => {
+        const knownTask = makeTask({
+            id: 'known-task',
+            title: 'Known task',
+            category: 'default'
+        });
+        const unknownTask = makeTask({
+            id: 'unknown-task',
+            title: 'Unknown task',
+            category: 'ghost-category'
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [knownTask, unknownTask],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setFilterCategories(['default']);
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['known-task']);
+    });
+    it('ignores custom taxonomy filters when that taxonomy is not filter-enabled', async () => {
+        const platformTask = makeTask({
+            id: 'platform-task',
+            title: 'Platform task',
+            taxonomies: { track: 'platform' }
+        });
+        const ghostTask = makeTask({
+            id: 'ghost-task',
+            title: 'Ghost task',
+            taxonomies: { track: 'ghost-track' }
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [platformTask, ghostTask],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [{
+                    ...taxonomies[0],
+                    filterEnabled: false
+                }],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setFilterTaxonomies({ track: ['platform'] });
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['platform-task', 'ghost-task']);
+    });
+    it('does not initialize filters for retired custom taxonomies with no task usage', async () => {
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [{
+                    id: 'review-status',
+                    label: 'Review Status',
+                    status: 'retired',
+                    options: [{ value: 'pending', label: 'Pending', status: 'active' }],
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    filterEnabled: true
+                }],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        expect(result.current.filterTaxonomies).toEqual({});
+    });
+    it('sorts by enabled custom taxonomy option order and keeps missing values last', async () => {
+        const alphaTask = makeTask({
+            id: 'alpha-task',
+            title: 'Alpha task',
+            taxonomies: { track: 'alpha' }
+        });
+        const betaTask = makeTask({
+            id: 'beta-task',
+            title: 'Beta task',
+            taxonomies: { track: 'beta' }
+        });
+        const missingTask = makeTask({
+            id: 'missing-task',
+            title: 'Missing task'
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [missingTask, betaTask, alphaTask],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [{
+                    id: 'track',
+                    label: 'Track',
+                    options: [
+                        { value: 'alpha', label: 'Alpha' },
+                        { value: 'beta', label: 'Beta' }
+                    ],
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    sortEnabled: true
+                }],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setSortBy('taxonomy:track');
+            result.current.setSortOrder('asc');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['alpha-task', 'beta-task', 'missing-task']);
+    });
+    it('initializes custom taxonomy filters with active and in-use retired options only', async () => {
+        const activeTask = makeTask({
+            id: 'active-task',
+            taxonomies: { track: 'platform' }
+        });
+        const legacyTask = makeTask({
+            id: 'legacy-task',
+            taxonomies: { track: 'legacy' }
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [activeTask, legacyTask],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [{
+                    id: 'track',
+                    label: 'Track',
+                    options: [
+                        { value: 'platform', label: 'Platform', status: 'active' },
+                        { value: 'legacy', label: 'Legacy', status: 'retired' },
+                        { value: 'unused-legacy', label: 'Unused Legacy', status: 'retired' }
+                    ],
+                    widgetType: 'select',
+                    isSystem: false,
+                    multiSelect: false,
+                    filterEnabled: true
+                }],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        expect(result.current.filterTaxonomies.track).toEqual(['platform', 'legacy']);
+    });
+    it('normalizes restored type filters when they do not exist in the active workspace', async () => {
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [makeTask({ id: 'task-1', type: 'feature' })],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setFilterTypes(['legacy-type']);
+        });
+        await waitFor(() => {
+            expect(result.current.filterTypes).toEqual(['feature', 'bug']);
+        });
+    });
+    it('normalizes restored taxonomy filters when they do not exist in the active workspace', async () => {
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [makeTask({ id: 'task-1', taxonomies: { track: 'platform' } })],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies,
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setFilterTaxonomies({ track: ['legacy-track'] });
+        });
+        await waitFor(() => {
+            expect(result.current.filterTaxonomies.track).toEqual(['platform']);
+        });
+    });
+});

package/dist/hooks/useRealtimeSync.d.ts

@@ -16,6 +16,7 @@ export interface UseRealtimeSyncInput {
     replayLimit?: number;
     onSignal?: (signal: RealtimeSyncSignal) => void;
     onTelemetry?: (telemetry: RealtimeReconcileTelemetry) => void;
+    userId?: string;
 }
 export declare function useRealtimeSync(input: UseRealtimeSyncInput): {
     connectionState: RealtimeConnectionState;

package/dist/hooks/useRealtimeSync.js

@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { RealtimeReconcileTracker } from '../sync/realtimeReconcile';
 export function useRealtimeSync(input) {
-    const { enabled, workspaceId, websocketUrl, reconnectBaseMs = 400, reconnectMaxMs = 10_000, degradeAfterAttempts = 5, replayLimit = 200, onSignal, onTelemetry } = input;
+    const { enabled, workspaceId, websocketUrl, reconnectBaseMs = 400, reconnectMaxMs = 10_000, degradeAfterAttempts = 5, replayLimit = 200, onSignal, onTelemetry, userId } = input;
     const [connectionState, setConnectionState] = useState('degraded-fallback');
     const wsRef = useRef(null);
     const reconnectTimerRef = useRef(null);
@@ -11,6 +11,14 @@ export function useRealtimeSync(input) {
     const signalDebounceTimerRef = useRef(null);
     const signalQueueRef = useRef(null);
     const reconcileRef = useRef(new RealtimeReconcileTracker());
+    const onSignalRef = useRef(onSignal);
+    const onTelemetryRef = useRef(onTelemetry);
+    useEffect(() => {
+        onSignalRef.current = onSignal;
+    }, [onSignal]);
+    useEffect(() => {
+        onTelemetryRef.current = onTelemetry;
+    }, [onTelemetry]);
     const [telemetry, setTelemetry] = useState({
         accepted: 0,
         duplicateDiscarded: 0,
@@ -63,11 +71,12 @@ export function useRealtimeSync(input) {
             }
             signalDebounceTimerRef.current = window.setTimeout(() => {
                 signalDebounceTimerRef.current = null;
-                if (!signalQueueRef.current || typeof onSignal !== 'function')
+                const callback = onSignalRef.current;
+                if (!signalQueueRef.current || typeof callback !== 'function')
                     return;
                 const queued = signalQueueRef.current;
                 signalQueueRef.current = null;
-                onSignal(queued);
+                callback(queued);
             }, 80);
         };
         const parseEvent = (raw) => {
@@ -92,8 +101,9 @@ export function useRealtimeSync(input) {
         const syncTelemetry = () => {
             const next = reconcileRef.current.getTelemetry();
             setTelemetry(next);
-            if (typeof onTelemetry === 'function')
-                onTelemetry(next);
+            const callback = onTelemetryRef.current;
+            if (typeof callback === 'function')
+                callback(next);
         };
         const sendReplayRequest = (socket) => {
             const payload = {
@@ -141,7 +151,8 @@ export function useRealtimeSync(input) {
                 setConnectionState('connected');
                 socket.send(JSON.stringify({
                     type: 'taskforce:subscribe',
-                    workspaceId: normalizedWorkspaceId
+                    workspaceId: normalizedWorkspaceId,
+                    userId: userId || undefined
                 }));
                 sendReplayRequest(socket);
             });
@@ -225,9 +236,14 @@ export function useRealtimeSync(input) {
                     });
                 }
             });
-            socket.addEventListener('close', () => {
+            socket.addEventListener('close', (event) => {
                 if (wsRef.current === socket)
                     wsRef.current = null;
+                if (!disposed && enabled) {
+                    const code = Number(event?.code || 0);
+                    const reason = String(event?.reason || '').trim();
+                    console.warn(`[Taskforce] Realtime socket closed workspace=${normalizedWorkspaceId} user=${String(userId || 'anonymous').trim() || 'anonymous'} code=${code}${reason ? ` reason=${reason}` : ''}`);
+                }
                 scheduleReconnect();
             });
             socket.addEventListener('error', () => {
@@ -268,8 +284,7 @@ export function useRealtimeSync(input) {
         reconnectMaxMs,
         degradeAfterAttempts,
         replayLimit,
-        onSignal,
-        onTelemetry
+        userId
     ]);
     return { connectionState, telemetry };
 }

package/dist/hooks/useRealtimeSync.test.js

@@ -73,9 +73,34 @@ describe('useRealtimeSync', () => {
         expect(outboundTypes).toContain('taskforce:subscribe');
         expect(outboundTypes).toContain('taskforce:replay');
     });
+    it('includes the resolved authenticated userId in subscribe payloads', async () => {
+        vi.stubGlobal('WebSocket', MockWebSocket);
+        renderHook(() => useRealtimeSync({
+            enabled: true,
+            workspaceId: 'ws-1',
+            websocketUrl: 'wss://example.com/taskforce-ws',
+            userId: 'user-42'
+        }));
+        const socket = MockWebSocket.instances[0];
+        act(() => {
+            socket.open();
+        });
+        await waitFor(() => {
+            expect(socket.sent.length).toBeGreaterThan(0);
+        });
+        const subscribePayload = socket.sent
+            .map((entry) => JSON.parse(entry))
+            .find((entry) => entry.type === 'taskforce:subscribe');
+        expect(subscribePayload).toMatchObject({
+            type: 'taskforce:subscribe',
+            workspaceId: 'ws-1',
+            userId: 'user-42'
+        });
+    });
     it('reconnects with backoff and degrades after threshold', async () => {
         vi.useFakeTimers();
         vi.stubGlobal('WebSocket', MockWebSocket);
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
         const { result } = renderHook(() => useRealtimeSync({
             enabled: true,
             workspaceId: 'ws-1',
@@ -87,9 +112,11 @@ describe('useRealtimeSync', () => {
         const first = MockWebSocket.instances[0];
         act(() => {
             first.open();
-            first.close();
+            first.emit('close', { code: 1006, reason: 'transport-lost' });
         });
         expect(result.current.connectionState).toBe('reconnecting');
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Realtime socket closed workspace=ws-1'));
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('code=1006'));
         act(() => {
             vi.advanceTimersByTime(100);
         });

package/dist/hooks/useSyncOrchestrator.aiProfiles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useSyncOrchestrator.aiProfiles.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeWorkspaceSyncAiProfileSnapshotEntry } from './useSyncOrchestrator';
+describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
+    it('accepts snake_case ai profile payloads from sync snapshot routes', () => {
+        const entry = normalizeWorkspaceSyncAiProfileSnapshotEntry({
+            id: 'ai-profile-codex',
+            workspace_id: 'workspace-local-active',
+            profile_token: 'token-codex',
+            name: 'Codex',
+            username: 'codex',
+            icon: 'Bot',
+            color: '#0ea5e9',
+            surface_type: 'coding_tool',
+            provider_metadata: { source: 'test' },
+            created_at: '2026-03-15T18:00:00.000Z',
+            updated_at: '2026-03-15T18:30:00.000Z',
+            last_active_at: '2026-03-15T18:45:00.000Z'
+        });
+        expect(entry).toEqual({
+            id: 'ai-profile-codex',
+            workspaceId: 'workspace-local-active',
+            profileToken: 'token-codex',
+            name: 'Codex',
+            username: 'codex',
+            icon: 'Bot',
+            color: '#0ea5e9',
+            surfaceType: 'coding_tool',
+            providerMetadata: { source: 'test' },
+            createdAt: '2026-03-15T18:00:00.000Z',
+            updatedAt: '2026-03-15T18:30:00.000Z',
+            lastActiveAt: '2026-03-15T18:45:00.000Z'
+        });
+    });
+});