@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/hooks/useFilterSort.js

@@ -25,7 +25,7 @@ import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
 import { STATUS_OPTIONS } from '../utils/constants';
 import { normalizeAssigneeOptions } from '../utils/assignees';
 import { matchesPriorityFilter, normalizeCategoryFilters, normalizePriorityFilterValues } from '../utils/taskNormalization.js';
-import { getTaskReferenceLabel } from '../utils/taskReferences';
+import { normalizeTaskSearchQuery, taskMatchesSearch } from '../utils/taskSearch';
 import { compareTasksBySortKey } from '../utils/taxonomySorting.js';
 import { getFilterVisibleTaxonomyOptions } from '../utils/taxonomyFilterOptions.js';
 import { getVisibleTaxonomiesForTasks } from '../utils/taxonomyLifecycle.js';
@@ -211,17 +211,21 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         });
     }, [assigneeFilterValues]);
     // === SECTION: Derived Collections ===
+    const normalizedSearchQuery = useMemo(() => normalizeTaskSearchQuery(searchQuery), [searchQuery]);
+    const taskSearchContext = useMemo(() => ({
+        categories: activeCategories,
+        types: activeTypes,
+        priorities,
+        assigneeOptions: resolvedAssigneeOptions,
+        taxonomies
+    }), [activeCategories, activeTypes, priorities, resolvedAssigneeOptions, taxonomies]);
     const filteredTasks = useMemo(() => {
         const isAllCategoriesSelected = isAllFilterValuesSelected(filterCategories, activeCategories.map((category) => category.value));
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         const isAllStatusesSelected = isAllFilterValuesSelected(filterStatus, STATUS_OPTIONS.map((status) => status.value));
         return tasks.filter(t => {
-            const referenceLabel = getTaskReferenceLabel(t).toLowerCase();
-            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
-                t.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                referenceLabel.includes(searchQuery.toLowerCase()));
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -245,7 +249,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchStatus && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [tasks, archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
+    }, [tasks, archivedTasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
     const searchAgnosticTasks = useMemo(() => {
         const isAllCategoriesSelected = isAllFilterValuesSelected(filterCategories, activeCategories.map((category) => category.value));
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
@@ -280,11 +284,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         const isAllTypesSelected = isAllFilterValuesSelected(filterTypes, activeTypes.map((type) => type.value));
         const isAllPrioritiesSelected = isAllFilterValuesSelected(Array.from(new Set(filterPriorities.map((value) => Number(value)).filter((value) => Number.isFinite(value)))), priorities.map((priority) => Number(priority.value)).filter((value) => Number.isFinite(value)));
         return archivedTasks.filter(t => {
-            const referenceLabel = getTaskReferenceLabel(t).toLowerCase();
-            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
-                t.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
-                referenceLabel.includes(searchQuery.toLowerCase()));
+            const matchSearch = taskMatchesSearch(t, normalizedSearchQuery, taskSearchContext);
             const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
             const matchPriority = !hasInitedFilters || isAllPrioritiesSelected || matchesPriorityFilter(t.priority, filterPriorities);
             const matchType = !hasInitedFilters || isAllTypesSelected || filterTypes.includes(t.type || DEFAULT_TYPE_VALUE);
@@ -306,7 +306,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchSearch && matchCategory && matchPriority && matchType && matchAssignee && matchTaxonomies;
         }).sort((a, b) => compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies));
-    }, [archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, isAllFilterValuesSelected, taxonomies]);
+    }, [archivedTasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, activeCategories, activeTypes, priorities, filterableTaxonomies, isAllFilterValuesSelected, taxonomies]);
     const groupedTasks = useMemo(() => {
         const groups = {};
         filteredTasks.forEach(task => {

package/dist/hooks/useFilterSort.test.js

@@ -26,7 +26,8 @@ function makeTask(overrides) {
         comments: overrides.comments || [],
         attachments: overrides.attachments || [],
         activity: overrides.activity || [],
-        taskEvents: overrides.taskEvents || []
+        taskEvents: overrides.taskEvents || [],
+        referenceLabel: overrides.referenceLabel
     };
 }
 describe('useFilterSort', () => {
@@ -107,6 +108,91 @@ describe('useFilterSort', () => {
         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('matches task reference labels when the search query has surrounding spaces or pasted formatting', async () => {
+        const matchingTask = makeTask({
+            id: 'matching-task',
+            title: 'Reference match',
+            referenceLabel: 'T-123'
+        });
+        const otherTask = makeTask({
+            id: 'other-task',
+            title: 'Other task',
+            referenceLabel: 'T-456'
+        });
+        const archivedMatch = makeTask({
+            id: 'archived-match',
+            title: 'Archived reference match',
+            referenceLabel: 'T-123',
+            isArchived: true
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [matchingTask, otherTask],
+            archivedTasks: [archivedMatch],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setSearchQuery(' T - 123 ');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
+        expect(result.current.filteredArchive.map((task) => task.id)).toEqual(['archived-match']);
+        act(() => {
+            result.current.setSearchQuery('t–123');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
+        act(() => {
+            result.current.setSearchQuery('   ');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task', 'other-task']);
+    });
+    it('matches tokenized search text and task metadata labels', async () => {
+        const matchingTask = makeTask({
+            id: 'matching-task',
+            title: 'Billing API cleanup',
+            category: 'ops',
+            priority: 3,
+            assignee: 'member-1'
+        });
+        const otherTask = makeTask({
+            id: 'other-task',
+            title: 'Marketing copy cleanup',
+            category: 'default',
+            priority: 1,
+            assignee: 'unassigned'
+        });
+        const { result } = renderHook(() => useFilterSort({
+            tasks: [matchingTask, otherTask],
+            archivedTasks: [],
+            activeCategories,
+            activeTypes,
+            priorities,
+            taxonomies: [],
+            configLoaded: true,
+            referenceDataLoaded: true,
+            assigneeOptionsLoaded: true,
+            assigneeOptions
+        }));
+        await waitFor(() => {
+            expect(result.current.hasInitedFilters).toBe(true);
+        });
+        act(() => {
+            result.current.setSearchQuery('api billing');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
+        act(() => {
+            result.current.setSearchQuery('Member One');
+        });
+        expect(result.current.filteredTasks.map((task) => task.id)).toEqual(['matching-task']);
+    });
     it('still excludes unknown values when the user selects a subset filter', async () => {
         const knownTask = makeTask({
             id: 'known-task',

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

@@ -15,7 +15,13 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surface_type: 'coding_tool',
+            seat_scope: 'cloud_metered',
             provider_metadata: { source: 'test' },
+            archived_at: '2026-03-16T18:00:00.000Z',
+            archived_by: 'owner-1',
+            archived_reason: 'manual_archive',
+            merged_into_profile_id: 'ai-profile-keeper',
+            roster_state_updated_at: '2026-03-16T18:00:00.000Z',
             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'
@@ -33,7 +39,13 @@ describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
             provider: 'OpenAI',
             model: 'gpt-5.4',
             surfaceType: 'coding_tool',
+            seatScope: 'cloud_metered',
             providerMetadata: { source: 'test' },
+            archivedAt: '2026-03-16T18:00:00.000Z',
+            archivedBy: 'owner-1',
+            archivedReason: 'manual_archive',
+            mergedIntoProfileId: 'ai-profile-keeper',
+            rosterStateUpdatedAt: '2026-03-16T18:00:00.000Z',
             createdAt: '2026-03-15T18:00:00.000Z',
             updatedAt: '2026-03-15T18:30:00.000Z',
             lastActiveAt: '2026-03-15T18:45:00.000Z'

package/dist/hooks/useSyncOrchestrator.d.ts

@@ -43,8 +43,8 @@ export interface UseSyncOrchestratorInput {
 export type WorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
 export { normalizeWorkspaceSyncAiProfileSnapshotEntry };
 export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
-    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
-    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "disconnected" | "syncing">>;
+    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
+    setUserGlobalSyncStatus: import("react").Dispatch<import("react").SetStateAction<"error" | "idle" | "syncing" | "disconnected">>;
     userGlobalSyncError: string | null;
     setUserGlobalSyncError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
     workspaceLastPullAt: string | null;
@@ -112,6 +112,13 @@ export declare function useSyncOrchestrator(input: UseSyncOrchestratorInput): {
         pendingChanges: number;
         lastErrorMessage: string | null;
         recommendedAction: string;
+        pushBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        pullBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        retryBlockedReason: import("./sync/controlPlane").WorkspaceSyncBlockedReason | null;
+        repairActive: boolean;
+        pushInFlight: boolean;
+        pullInFlight: boolean;
+        retryPending: boolean;
         documentSnapshotCount: number;
         aiProfileSnapshotCount: number;
         aiProfileSnapshotRawCount: number;