@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/hooks/ui/useWorkflowTemplates.d.ts

@@ -0,0 +1,37 @@
+export interface InitiativeTemplate {
+    id: string;
+    name: string;
+    description: string;
+    checklistBlocks: {
+        definitionOfDone: string[];
+        rollbackPlan: string[];
+    };
+    milestones: Array<{
+        title: string;
+        description: string;
+        priority?: number;
+        approach?: string;
+        category?: string;
+    }>;
+}
+interface UseWorkflowTemplatesInput {
+    shouldDeferProtectedApiCalls: boolean;
+    shouldBlockProtectedApiCalls: boolean;
+}
+export declare function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }: UseWorkflowTemplatesInput): {
+    availableWorkflows: string[];
+    initiativeTemplates: InitiativeTemplate[];
+    fetchWorkflows: () => Promise<void>;
+    fetchInitiativeTemplates: () => Promise<any>;
+    fetchWorkflowTemplate: (name: string) => Promise<any>;
+    fetchWorkflowOverrideNames: () => Promise<string[]>;
+    saveWorkflowTemplateDraft: (name: string, draft: any) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    resetWorkflowTemplateDraft: (name: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+};
+export {};

package/dist/hooks/ui/useWorkflowTemplates.js

@@ -0,0 +1,111 @@
+import { useCallback, useState } from 'react';
+export function useWorkflowTemplates({ shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }) {
+    const [availableWorkflows, setAvailableWorkflows] = useState([]);
+    const [initiativeTemplates, setInitiativeTemplates] = useState([]);
+    const fetchWorkflows = useCallback(async () => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        try {
+            const res = await fetch('/api/taskforce/workflow-templates');
+            if (res.ok) {
+                const data = await res.json();
+                setAvailableWorkflows(data.templates || []);
+            }
+        }
+        catch {
+            // Ignore error
+        }
+    }, [shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    const fetchInitiativeTemplates = useCallback(async () => {
+        try {
+            const res = await fetch('/api/taskforce/initiative-templates');
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            const templates = Array.isArray(data?.templates) ? data.templates : [];
+            setInitiativeTemplates(templates);
+            return templates;
+        }
+        catch {
+            return [];
+        }
+    }, []);
+    const fetchWorkflowTemplate = useCallback(async (name) => {
+        if (!name)
+            return null;
+        const paths = [
+            `/api/taskforce/workflow-template/${encodeURIComponent(name)}`,
+            `/api/taskforce/workflow-templates/${encodeURIComponent(name)}`
+        ];
+        try {
+            for (const url of paths) {
+                const res = await fetch(url);
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                if (data?.template)
+                    return data.template;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }, []);
+    const fetchWorkflowOverrideNames = useCallback(async () => {
+        try {
+            const res = await fetch('/api/taskforce/workflow-editor/overrides');
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            return Array.isArray(data?.names) ? data.names : [];
+        }
+        catch {
+            return [];
+        }
+    }, []);
+    const saveWorkflowTemplateDraft = useCallback(async (name, draft) => {
+        try {
+            const res = await fetch('/api/taskforce/workflow-editor/save', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name, draft })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data.success) {
+                return { success: false, error: data.error || `Save failed (${res.status})` };
+            }
+            fetchWorkflows();
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [fetchWorkflows]);
+    const resetWorkflowTemplateDraft = useCallback(async (name) => {
+        try {
+            const res = await fetch(`/api/taskforce/workflow-editor/reset/${encodeURIComponent(name)}`, {
+                method: 'POST'
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data.success) {
+                return { success: false, error: data.error || `Reset failed (${res.status})` };
+            }
+            fetchWorkflows();
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [fetchWorkflows]);
+    return {
+        availableWorkflows,
+        initiativeTemplates,
+        fetchWorkflows,
+        fetchInitiativeTemplates,
+        fetchWorkflowTemplate,
+        fetchWorkflowOverrideNames,
+        saveWorkflowTemplateDraft,
+        resetWorkflowTemplateDraft
+    };
+}

package/dist/hooks/ui/useZenMode.d.ts

@@ -0,0 +1,5 @@
+export declare function useZenMode(): {
+    zenMode: boolean;
+    setZenModeState: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    toggleZenMode: () => Promise<void>;
+};

package/dist/hooks/ui/useZenMode.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect, useState } from 'react';
+export function useZenMode() {
+    const [zenMode, setZenModeState] = useState(false);
+    const toggleZenMode = useCallback(async () => {
+        if (!document.fullscreenElement) {
+            try {
+                await document.documentElement.requestFullscreen();
+                setZenModeState(true);
+            }
+            catch (err) {
+                console.error(`Error attempting to enable full-screen mode: ${err}`);
+            }
+            return;
+        }
+        if (document.exitFullscreen) {
+            await document.exitFullscreen();
+            setZenModeState(false);
+        }
+    }, []);
+    useEffect(() => {
+        const handleFullscreenChange = () => {
+            setZenModeState(!!document.fullscreenElement);
+        };
+        document.addEventListener('fullscreenchange', handleFullscreenChange);
+        return () => document.removeEventListener('fullscreenchange', handleFullscreenChange);
+    }, []);
+    return {
+        zenMode,
+        setZenModeState,
+        toggleZenMode
+    };
+}

package/dist/hooks/useFilterSort.d.ts

@@ -0,0 +1,60 @@
+import type { TaskItem, CategoryConfig, TaxonomyDefinition, TaskAssignee } from '../types';
+import type { TaskAssigneeOption } from '../utils/assignees';
+import { type TaskSortKey } from '../utils/taxonomySorting.js';
+interface UseFilterSortProps {
+    tasks: TaskItem[];
+    archivedTasks: TaskItem[];
+    activeCategories: CategoryConfig[];
+    activeTypes: Array<{
+        value: string;
+        label: string;
+    }>;
+    priorities: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>;
+    taxonomies: TaxonomyDefinition[];
+    configLoaded: boolean;
+    referenceDataLoaded: boolean;
+    assigneeOptionsLoaded: boolean;
+    assigneeOptions?: TaskAssigneeOption[];
+}
+export declare function useFilterSort({ tasks, archivedTasks, activeCategories, activeTypes, priorities, taxonomies, configLoaded, referenceDataLoaded, assigneeOptionsLoaded, assigneeOptions }: UseFilterSortProps): {
+    searchQuery: string;
+    setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    filterCategories: string[];
+    setFilterCategories: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    filterPriorities: (string | number)[];
+    setFilterPriorities: import("react").Dispatch<import("react").SetStateAction<(string | number)[]>>;
+    filterTypes: string[];
+    setFilterTypes: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    filterStatus: (string | number)[];
+    setFilterStatus: import("react").Dispatch<import("react").SetStateAction<(string | number)[]>>;
+    filterAssignees: string[];
+    setFilterAssignees: (nextValues: TaskAssignee[] | ((prev: TaskAssignee[]) => TaskAssignee[])) => void;
+    filterAssigneesAllSelected: boolean;
+    setFilterAssigneesAllSelected: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    filterTaxonomies: Record<string, (string | number)[]>;
+    setFilterTaxonomies: import("react").Dispatch<import("react").SetStateAction<Record<string, (string | number)[]>>>;
+    hasInitedFilters: boolean;
+    setHasInitedFilters: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    sortBy: TaskSortKey;
+    setSortBy: import("react").Dispatch<import("react").SetStateAction<TaskSortKey>>;
+    sortOrder: "asc" | "desc";
+    setSortOrder: import("react").Dispatch<import("react").SetStateAction<"asc" | "desc">>;
+    toggleSortOrder: () => void;
+    groupBy: "category" | "type" | "priority" | "status" | "complexity" | "approach" | "assignee" | "schedule";
+    setGroupBy: import("react").Dispatch<import("react").SetStateAction<"category" | "type" | "priority" | "status" | "complexity" | "approach" | "assignee" | "schedule">>;
+    emptyColumnMode: "show" | "collapse" | "hide";
+    setEmptyColumnMode: import("react").Dispatch<import("react").SetStateAction<"show" | "collapse" | "hide">>;
+    collapsedCategories: Record<string, boolean>;
+    setCollapsedCategories: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
+    clearFilters: () => void;
+    filteredTasks: TaskItem[];
+    searchAgnosticTasks: TaskItem[];
+    filteredArchive: TaskItem[];
+    groupedTasks: Record<string, TaskItem[]>;
+};
+export {};

package/dist/hooks/useFilterSort.js

@@ -0,0 +1,362 @@
+/**
+ * useFilterSort
+ *
+ * Manages all filter, sort, and search state for the Taskforce task list.
+ * Produces derived filtered/sorted task collections from raw task arrays.
+ *
+ * === SECTION MAP ===
+ *   === SECTION: Filter State ===          — searchQuery, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterTaxonomies, hasInitedFilters
+ *   === SECTION: Sort State ===            — sortBy, sortOrder, toggleSortOrder
+ *   === SECTION: View State ===            — groupBy, emptyColumnMode, collapsedCategories
+ *   === SECTION: Filter Init Effects ===   — effects that seed filter state once config is loaded
+ *   === SECTION: Derived Collections ===   — filteredTasks, searchAgnosticTasks, filteredArchive, groupedTasks
+ *   === SECTION: Clear / Helpers ===       — clearFilters
+ *
+ * Key return values:
+ *   - filteredTasks: TaskItem[] — active tasks matching all current filters + search
+ *   - searchAgnosticTasks: TaskItem[] — active tasks matching filters (no search term)
+ *   - filteredArchive: TaskItem[] — archived tasks matching filters
+ *   - groupedTasks: Record<string, TaskItem[]> — filteredTasks grouped by category label
+ *   - All filter/sort state and their setters
+ *   - clearFilters() — resets all filters to "show everything" defaults
+ */
+import { useState, useEffect, useCallback, useMemo } from 'react';
+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 { compareTasksBySortKey } from '../utils/taxonomySorting.js';
+import { getFilterVisibleTaxonomyOptions } from '../utils/taxonomyFilterOptions.js';
+import { getVisibleTaxonomiesForTasks } from '../utils/taxonomyLifecycle.js';
+// === SECTION: Filter State ===
+export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTypes, priorities, taxonomies, configLoaded, referenceDataLoaded, assigneeOptionsLoaded, assigneeOptions }) {
+    const resolvedAssigneeOptions = useMemo(() => normalizeAssigneeOptions(assigneeOptions), [assigneeOptions]);
+    const filterableTaxonomies = useMemo(() => getVisibleTaxonomiesForTasks(taxonomies, [...tasks, ...archivedTasks])
+        .filter((taxonomy) => taxonomy.filterEnabled !== false)
+        .map((taxonomy) => ({
+        ...taxonomy,
+        options: getFilterVisibleTaxonomyOptions(taxonomy, [...tasks, ...archivedTasks])
+    })), [archivedTasks, tasks, taxonomies]);
+    const assigneeFilterValues = useMemo(() => resolvedAssigneeOptions.map((opt) => opt.value), [resolvedAssigneeOptions]);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [filterCategories, setFilterCategories] = useState([]);
+    const [filterPriorities, setFilterPriorities] = useState([]);
+    const [filterTypes, setFilterTypes] = useState([]);
+    const [hasInitedFilters, setHasInitedFilters] = useState(false);
+    const [filterStatus, setFilterStatus] = useState(STATUS_OPTIONS.map(s => s.value));
+    const [filterAssignees, setFilterAssignees] = useState(assigneeFilterValues);
+    const [filterAssigneesAllSelected, setFilterAssigneesAllSelected] = useState(true);
+    const [filterTaxonomies, setFilterTaxonomies] = useState({});
+    // === SECTION: Sort State ===
+    const [sortBy, setSortBy] = useState('created');
+    const [sortOrder, setSortOrder] = useState('desc');
+    const toggleSortOrder = useCallback(() => {
+        setSortOrder(prev => prev === 'asc' ? 'desc' : 'asc');
+    }, []);
+    // === SECTION: View State ===
+    const [groupBy, setGroupBy] = useState('category');
+    const [emptyColumnMode, setEmptyColumnMode] = useState('show');
+    const [collapsedCategories, setCollapsedCategories] = useState({});
+    const isAllFilterValuesSelected = useCallback((selected, available) => {
+        if (available.length === 0)
+            return true;
+        return available.every((value) => selected.includes(value));
+    }, []);
+    const haveSamePrimitiveValues = useCallback((left, right) => {
+        return left.length === right.length && left.every((value, index) => value === right[index]);
+    }, []);
+    useEffect(() => {
+        if (groupBy === 'approach') {
+            setGroupBy('status');
+        }
+    }, [groupBy]);
+    // === SECTION: Filter Init Effects ===
+    // Initialize filters once config is loaded
+    useEffect(() => {
+        if (!configLoaded || !referenceDataLoaded)
+            return;
+        if (!assigneeOptionsLoaded)
+            return;
+        if (!hasInitedFilters && activeCategories.length > 0 && activeTypes.length > 0 && priorities.length > 0) {
+            setFilterCategories(activeCategories.map(c => c.value));
+            setFilterPriorities(priorities.map(p => p.value));
+            setFilterTypes(activeTypes.map(t => t.value));
+            setFilterAssignees(assigneeFilterValues);
+            setFilterAssigneesAllSelected(true);
+            const initialTaxFilters = {};
+            filterableTaxonomies.forEach(tax => {
+                initialTaxFilters[tax.id] = tax.options.map(o => o.value);
+            });
+            setFilterTaxonomies(initialTaxFilters);
+            setHasInitedFilters(true);
+        }
+    }, [configLoaded, referenceDataLoaded, assigneeOptionsLoaded, activeCategories, activeTypes, priorities, filterableTaxonomies, hasInitedFilters, assigneeFilterValues]);
+    useEffect(() => {
+        if (!hasInitedFilters)
+            return;
+        if (!assigneeOptionsLoaded)
+            return;
+        const validOptions = new Set(assigneeFilterValues);
+        const normalized = filterAssignees.filter((value) => validOptions.has(value));
+        const next = filterAssigneesAllSelected
+            ? assigneeFilterValues
+            : (normalized.length > 0 || filterAssignees.length === 0 ? normalized : assigneeFilterValues);
+        const changed = next.length !== filterAssignees.length || next.some((value, index) => value !== filterAssignees[index]);
+        if (changed) {
+            setFilterAssignees(next);
+        }
+    }, [assigneeFilterValues, filterAssignees, filterAssigneesAllSelected, hasInitedFilters, assigneeOptionsLoaded]);
+    useEffect(() => {
+        if (!hasInitedFilters)
+            return;
+        if (!assigneeOptionsLoaded)
+            return;
+        const selectedValidValues = filterAssignees.filter((value) => assigneeFilterValues.includes(value));
+        const isAllSelected = assigneeFilterValues.length > 0
+            && assigneeFilterValues.every((value) => selectedValidValues.includes(value));
+        if (isAllSelected !== filterAssigneesAllSelected) {
+            setFilterAssigneesAllSelected(isAllSelected);
+        }
+    }, [assigneeFilterValues, filterAssignees, filterAssigneesAllSelected, hasInitedFilters, assigneeOptionsLoaded]);
+    useEffect(() => {
+        if (!configLoaded || !referenceDataLoaded || !hasInitedFilters || activeCategories.length === 0)
+            return;
+        const normalized = normalizeCategoryFilters(filterCategories, activeCategories);
+        const changed = normalized.length !== filterCategories.length
+            || normalized.some((value, index) => value !== filterCategories[index]);
+        if (changed) {
+            setFilterCategories(normalized);
+        }
+    }, [configLoaded, referenceDataLoaded, activeCategories, hasInitedFilters, filterCategories]);
+    useEffect(() => {
+        if (!configLoaded || !referenceDataLoaded || !hasInitedFilters || priorities.length === 0 || filterPriorities.length === 0)
+            return;
+        const normalized = normalizePriorityFilterValues(filterPriorities, priorities);
+        const current = Array.from(new Set(filterPriorities
+            .map(p => Number(p))
+            .filter(n => Number.isFinite(n))));
+        const changed = normalized.length !== current.length ||
+            normalized.some((v, idx) => v !== current[idx]);
+        if (changed) {
+            setFilterPriorities(normalized);
+        }
+    }, [configLoaded, referenceDataLoaded, hasInitedFilters, priorities, filterPriorities]);
+    useEffect(() => {
+        if (!configLoaded || !referenceDataLoaded || !hasInitedFilters || activeTypes.length === 0)
+            return;
+        const validValues = new Set(activeTypes.map((type) => type.value));
+        const normalized = filterTypes.filter((value) => validValues.has(value));
+        const next = normalized.length > 0 || filterTypes.length === 0
+            ? normalized
+            : activeTypes.map((type) => type.value);
+        if (!haveSamePrimitiveValues(next, filterTypes)) {
+            setFilterTypes(next);
+        }
+    }, [activeTypes, configLoaded, filterTypes, hasInitedFilters, haveSamePrimitiveValues, referenceDataLoaded]);
+    useEffect(() => {
+        if (!configLoaded || !referenceDataLoaded || !hasInitedFilters)
+            return;
+        const nextFilterTaxonomies = {};
+        filterableTaxonomies.forEach((taxonomy) => {
+            const availableValues = taxonomy.options.map((option) => option.value);
+            if (availableValues.length === 0)
+                return;
+            const currentValues = Array.isArray(filterTaxonomies[taxonomy.id])
+                ? filterTaxonomies[taxonomy.id]
+                : [];
+            const normalized = currentValues.filter((value) => availableValues.includes(value));
+            nextFilterTaxonomies[taxonomy.id] = normalized.length > 0 || currentValues.length === 0
+                ? normalized
+                : availableValues;
+        });
+        const currentKeys = Object.keys(filterTaxonomies).sort();
+        const nextKeys = Object.keys(nextFilterTaxonomies).sort();
+        const keysChanged = currentKeys.length !== nextKeys.length
+            || currentKeys.some((key, index) => key !== nextKeys[index]);
+        const valuesChanged = nextKeys.some((key) => {
+            return !haveSamePrimitiveValues(filterTaxonomies[key] || [], nextFilterTaxonomies[key] || []);
+        });
+        if (keysChanged || valuesChanged) {
+            setFilterTaxonomies(nextFilterTaxonomies);
+        }
+    }, [configLoaded, filterTaxonomies, filterableTaxonomies, hasInitedFilters, haveSamePrimitiveValues, referenceDataLoaded]);
+    // === SECTION: Clear / Helpers ===
+    const clearFilters = useCallback(() => {
+        setSearchQuery('');
+        setFilterCategories(activeCategories.map(c => c.value));
+        setFilterPriorities(priorities.map(p => p.value));
+        setFilterTypes(activeTypes.map(t => t.value));
+        setFilterStatus(STATUS_OPTIONS.map(s => s.value));
+        setFilterAssignees(assigneeFilterValues);
+        setFilterAssigneesAllSelected(true);
+        const initialTaxFilters = {};
+        filterableTaxonomies.forEach(tax => {
+            initialTaxFilters[tax.id] = tax.options.map(o => o.value);
+        });
+        setFilterTaxonomies(initialTaxFilters);
+        setSortBy('created');
+        setSortOrder('desc');
+    }, [activeCategories, priorities, activeTypes, filterableTaxonomies, assigneeFilterValues]);
+    const updateFilterAssignees = useCallback((nextValues) => {
+        setFilterAssignees((prev) => {
+            const resolved = typeof nextValues === 'function'
+                ? nextValues(prev)
+                : nextValues;
+            const next = Array.from(new Set(resolved.filter((value) => typeof value === 'string' && value.trim().length > 0)));
+            const isAllSelected = assigneeFilterValues.length > 0
+                && assigneeFilterValues.every((value) => next.includes(value));
+            setFilterAssigneesAllSelected(isAllSelected);
+            return next;
+        });
+    }, [assigneeFilterValues]);
+    // === SECTION: Derived Collections ===
+    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 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);
+            const matchStatus = !hasInitedFilters || isAllStatusesSelected || filterStatus.includes(t.status);
+            const matchAssignee = !hasInitedFilters || filterAssigneesAllSelected || filterAssignees.includes((t.assignee || 'unassigned'));
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taxDef = filterableTaxonomies.find(tax => tax.id === taxId);
+                if (!taxDef)
+                    return true;
+                const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                if (isAllSelected)
+                    return true;
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    return isAllSelected || selectedValues.includes('');
+                }
+                if (Array.isArray(taskValue)) {
+                    return taskValue.some(v => selectedValues.includes(v));
+                }
+                return selectedValues.includes(taskValue);
+            });
+            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]);
+    const searchAgnosticTasks = 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 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);
+            const matchStatus = !hasInitedFilters || isAllStatusesSelected || filterStatus.includes(t.status);
+            const matchAssignee = !hasInitedFilters || filterAssigneesAllSelected || filterAssignees.includes((t.assignee || 'unassigned'));
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taxDef = filterableTaxonomies.find(tax => tax.id === taxId);
+                if (!taxDef)
+                    return true;
+                const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                if (isAllSelected)
+                    return true;
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    return isAllSelected || selectedValues.includes('');
+                }
+                if (Array.isArray(taskValue))
+                    return taskValue.some(v => selectedValues.includes(v));
+                return selectedValues.includes(taskValue);
+            });
+            return matchCategory && matchPriority && matchType && matchStatus && matchAssignee && matchTaxonomies;
+        });
+    }, [tasks, archivedTasks, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected]);
+    const filteredArchive = useMemo(() => {
+        const isAllCategoriesSelected = activeCategories.every(c => filterCategories.includes(c.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)));
+        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 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);
+            const matchAssignee = !hasInitedFilters || filterAssigneesAllSelected || filterAssignees.includes((t.assignee || 'unassigned'));
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taxDef = filterableTaxonomies.find(tax => tax.id === taxId);
+                if (!taxDef)
+                    return true;
+                const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                if (isAllSelected)
+                    return true;
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    return isAllSelected || selectedValues.includes('');
+                }
+                if (Array.isArray(taskValue))
+                    return taskValue.some(v => selectedValues.includes(v));
+                return selectedValues.includes(taskValue);
+            });
+            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]);
+    const groupedTasks = useMemo(() => {
+        const groups = {};
+        filteredTasks.forEach(task => {
+            const catConfig = activeCategories.find(c => c.value === task.category);
+            const catLabel = catConfig ? catConfig.label : (task.category || 'General');
+            if (!groups[catLabel])
+                groups[catLabel] = [];
+            groups[catLabel].push(task);
+        });
+        return groups;
+    }, [filteredTasks, activeCategories]);
+    return {
+        // Filter state
+        searchQuery,
+        setSearchQuery,
+        filterCategories,
+        setFilterCategories,
+        filterPriorities,
+        setFilterPriorities,
+        filterTypes,
+        setFilterTypes,
+        filterStatus,
+        setFilterStatus,
+        filterAssignees,
+        setFilterAssignees: updateFilterAssignees,
+        filterAssigneesAllSelected,
+        setFilterAssigneesAllSelected,
+        filterTaxonomies,
+        setFilterTaxonomies,
+        hasInitedFilters,
+        setHasInitedFilters,
+        // Sort state
+        sortBy,
+        setSortBy,
+        sortOrder,
+        setSortOrder,
+        toggleSortOrder,
+        // View state
+        groupBy,
+        setGroupBy,
+        emptyColumnMode,
+        setEmptyColumnMode,
+        collapsedCategories,
+        setCollapsedCategories,
+        // Actions
+        clearFilters,
+        // Derived collections
+        filteredTasks,
+        searchAgnosticTasks,
+        filteredArchive,
+        groupedTasks
+    };
+}

package/dist/hooks/useFilterSort.test.d.ts

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