@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/hooks/tasks/useTaskRelationships.js

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 export function useTaskRelationships(input) {
-    const { editingTaskId, fetchTasks, mergeTaskFromServer, workstreamInput, pushNotice, queueWorkspaceSyncFromAuthoritativeTaskState, relationshipTasks, resolveWorkstreamIdInput, setError } = input;
+    const { editingTaskId, workstreamInput, pushNotice, relationshipTasks, resolveWorkstreamIdInput, setError, updateTask } = input;
     const handleSetWorkstreamForCurrentTask = useCallback(async (workstreamIdOverride) => {
         if (!editingTaskId)
             return;
@@ -19,29 +19,11 @@ export function useTaskRelationships(input) {
             return;
         }
         try {
-            const res = await fetch(`/api/taskforce/task/${editingTaskId}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ workstreamId: normalizedWorkstreamId })
-            });
-            if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
-                const message = data.error || 'Failed to set workstream.';
-                setError(message);
-                pushNotice(message, 'error');
+            const saved = await updateTask(editingTaskId, { workstreamId: normalizedWorkstreamId });
+            if (saved === false)
                 return;
-            }
             setError('');
             pushNotice(normalizedWorkstreamId ? 'Workstream set' : 'Workstream removed', 'info');
-            const updatedTask = await res.json().catch(() => null);
-            if (updatedTask) {
-                mergeTaskFromServer(updatedTask);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
-            }
-            else {
-                await fetchTasks(true);
-                queueWorkspaceSyncFromAuthoritativeTaskState();
-            }
         }
         catch {
             setError('Failed to set workstream.');
@@ -49,14 +31,12 @@ export function useTaskRelationships(input) {
         }
     }, [
         editingTaskId,
-        fetchTasks,
-        mergeTaskFromServer,
         workstreamInput,
         pushNotice,
-        queueWorkspaceSyncFromAuthoritativeTaskState,
         relationshipTasks,
         resolveWorkstreamIdInput,
-        setError
+        setError,
+        updateTask
     ]);
     return {
         handleSetWorkstreamForCurrentTask

package/dist/hooks/tasks/useTrashSelection.d.ts

@@ -0,0 +1,12 @@
+import type { DeletedTaskRecord } from '../../types';
+export declare function useTrashSelection(deletedTasks: DeletedTaskRecord[], matchingTaskIds: string[], active: boolean): {
+    selectedIds: Set<string>;
+    selectedRecords: DeletedTaskRecord[];
+    matchingRecords: DeletedTaskRecord[];
+    selectedCount: number;
+    allMatchingSelected: boolean;
+    someMatchingSelected: boolean;
+    toggle: (recordId: string, selected: boolean) => void;
+    selectAllMatching: () => void;
+    clear: () => void;
+};

package/dist/hooks/tasks/useTrashSelection.js

@@ -0,0 +1,49 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+export function useTrashSelection(deletedTasks, matchingTaskIds, active) {
+    const [selectedIds, setSelectedIds] = useState(() => new Set());
+    const recordByTaskId = useMemo(() => new Map(deletedTasks.map((record) => [record.taskId, record])), [deletedTasks]);
+    const matchingRecords = useMemo(() => matchingTaskIds
+        .map((taskId) => recordByTaskId.get(taskId))
+        .filter((record) => Boolean(record)), [matchingTaskIds, recordByTaskId]);
+    const matchingIdSet = useMemo(() => new Set(matchingRecords.map((record) => record.id)), [matchingRecords]);
+    useEffect(() => {
+        setSelectedIds((current) => {
+            const next = active
+                ? new Set(Array.from(current).filter((id) => matchingIdSet.has(id)))
+                : new Set();
+            if (next.size === current.size
+                && Array.from(next).every((id) => current.has(id))) {
+                return current;
+            }
+            return next;
+        });
+    }, [active, matchingIdSet]);
+    const selectedRecords = useMemo(() => matchingRecords.filter((record) => selectedIds.has(record.id)), [matchingRecords, selectedIds]);
+    const toggle = useCallback((recordId, selected) => {
+        setSelectedIds((current) => {
+            const next = new Set(current);
+            if (selected)
+                next.add(recordId);
+            else
+                next.delete(recordId);
+            return next;
+        });
+    }, []);
+    const selectAllMatching = useCallback(() => {
+        setSelectedIds(new Set(matchingRecords.map((record) => record.id)));
+    }, [matchingRecords]);
+    const clear = useCallback(() => setSelectedIds(new Set()), []);
+    return {
+        selectedIds,
+        selectedRecords,
+        matchingRecords,
+        selectedCount: selectedRecords.length,
+        allMatchingSelected: matchingRecords.length > 0
+            && selectedRecords.length === matchingRecords.length,
+        someMatchingSelected: selectedRecords.length > 0
+            && selectedRecords.length < matchingRecords.length,
+        toggle,
+        selectAllMatching,
+        clear,
+    };
+}

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

@@ -0,0 +1,24 @@
+export interface InitiativeTemplate {
+    id: string;
+    name: string;
+    description: string;
+    checklistBlocks: {
+        definitionOfDone: string[];
+        rollbackPlan: string[];
+    };
+    milestones: Array<{
+        title: string;
+        description: string;
+        priority?: number;
+        category?: string;
+    }>;
+}
+interface UseInitiativeTemplatesInput {
+    shouldDeferProtectedApiCalls: boolean;
+    shouldBlockProtectedApiCalls: boolean;
+}
+export declare function useInitiativeTemplates({ shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }: UseInitiativeTemplatesInput): {
+    initiativeTemplates: InitiativeTemplate[];
+    fetchInitiativeTemplates: () => Promise<any>;
+};
+export {};

package/dist/hooks/ui/useInitiativeTemplates.js

@@ -0,0 +1,22 @@
+import { useCallback, useState } from 'react';
+export function useInitiativeTemplates({ shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls }) {
+    const [initiativeTemplates, setInitiativeTemplates] = useState([]);
+    const shouldSkipProtectedApiCalls = shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls;
+    const fetchInitiativeTemplates = useCallback(async () => {
+        if (shouldSkipProtectedApiCalls)
+            return [];
+        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 [];
+        }
+    }, [shouldSkipProtectedApiCalls]);
+    return { initiativeTemplates, fetchInitiativeTemplates };
+}

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

@@ -1,5 +1,7 @@
+import type { LocalCliHealthResult } from '../../mcp/localCliHealth.js';
+import type { UiUpdateOverview } from '../../update/uiUpdateService.js';
 type WorkspaceRole = 'owner' | 'admin' | 'member' | 'read-only';
-type SettingsSection = 'categories' | 'types' | 'general' | 'appearance-application' | 'appearance-task-cards' | 'appearance-task-forms' | 'documents' | 'commands' | 'workflow-editor' | 'agents' | 'taxonomy' | 'mcp' | 'integrations' | 'resources' | 'priorities' | 'initiatives' | null;
+type SettingsSection = 'categories' | 'types' | 'general' | 'appearance-application' | 'appearance-task-cards' | 'appearance-task-forms' | 'documents' | 'agents' | 'taxonomy' | 'mcp' | 'integrations' | 'priorities' | 'initiatives' | null;
 type UseSettingsModelInput = {
     resolveCloudAuthUrl: (path: string) => string;
     currentWorkspaceId: string;
@@ -27,12 +29,8 @@ type UseSettingsModelInput = {
     manualComplexityEnabled: boolean;
     checklistDropdownEnabled: boolean;
     showTaskCardStatusLabel: boolean;
-    exportWorkflowsPath: string;
-    exportingResource: any;
-    exportResult: any;
     pathSaved: boolean;
     settingsSection: SettingsSection;
-    exportEnvironment: string;
     setupState: any;
     buildInfo: any;
     saveSetupMode: (...args: any[]) => any;
@@ -50,19 +48,9 @@ type UseSettingsModelInput = {
     handleShowTaskCardStatusLabelChange: (...args: any[]) => any;
     handleResetProjectToGlobal: (...args: any[]) => any;
     handleSaveSettings: (...args: any[]) => any;
-    setExportWorkflowsPath: (value: string) => void;
-    setExportEnvironment: (value: string) => void;
-    availableWorkflows: any[];
     initiativeTemplates: any[];
-    availableEnvironments: any[];
-    fetchWorkflows: (...args: any[]) => any;
     fetchInitiativeTemplates: (...args: any[]) => any;
     createInitiativeFromTemplate: (...args: any[]) => any;
-    fetchWorkflowTemplate: (...args: any[]) => any;
-    fetchWorkflowOverrideNames: (...args: any[]) => any;
-    saveWorkflowTemplateDraft: (...args: any[]) => any;
-    resetWorkflowTemplateDraft: (...args: any[]) => any;
-    handleExportWorkflows: (...args: any[]) => any;
     setShowFolderBrowser: (value: boolean) => void;
     setBrowserTarget: (value: any) => void;
     fetchFolders: (...args: any[]) => any;
@@ -105,6 +93,8 @@ type UseSettingsModelInput = {
 };
 export declare function useSettingsModel(input: UseSettingsModelInput): {
     fetchCloudAuthApi: (path: string, init?: RequestInit) => Promise<Response>;
+    checkLocalMcpCliHealth: () => Promise<LocalCliHealthResult>;
+    getLocalUpdateStatus: () => Promise<UiUpdateOverview>;
     currentTheme: any;
     configLoaded: boolean;
     globalTheme: any;
@@ -119,12 +109,8 @@ export declare function useSettingsModel(input: UseSettingsModelInput): {
     manualComplexityEnabled: boolean;
     checklistDropdownEnabled: boolean;
     showTaskCardStatusLabel: boolean;
-    exportWorkflowsPath: string;
-    exportingResource: any;
-    exportResult: any;
     pathSaved: boolean;
     initialSection: SettingsSection;
-    exportEnvironment: string;
     setupState: any;
     buildInfo: any;
     onSaveSetupMode: (...args: any[]) => any;
@@ -142,19 +128,9 @@ export declare function useSettingsModel(input: UseSettingsModelInput): {
     onShowTaskCardStatusLabelChange: (...args: any[]) => any;
     onResetProjectToGlobal: (...args: any[]) => any;
     onSaveSettings: (...args: any[]) => any;
-    onExportWorkflowsPathChange: (value: string) => void;
-    onExportEnvironmentChange: (value: string) => void;
-    availableWorkflows: any[];
     initiativeTemplates: any[];
-    availableEnvironments: any[];
-    onRefreshWorkflows: (...args: any[]) => any;
     onRefreshInitiativeTemplates: (...args: any[]) => any;
     onCreateInitiativeFromTemplate: (...args: any[]) => any;
-    onFetchWorkflowTemplate: (...args: any[]) => any;
-    onFetchWorkflowOverrideNames: (...args: any[]) => any;
-    onSaveWorkflowTemplateDraft: (...args: any[]) => any;
-    onResetWorkflowTemplateDraft: (...args: any[]) => any;
-    onExportWorkflows: (...args: any[]) => any;
     onShowFolderBrowserChange: (value: boolean) => void;
     onBrowserTargetChange: (value: any) => void;
     onFetchFolders: (...args: any[]) => any;

package/dist/hooks/ui/useSettingsModel.js

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 export function useSettingsModel(input) {
-    const { resolveCloudAuthUrl, currentWorkspaceId, normalizedCloudAuthBaseUrl, normalizedCloudMcpBaseUrl, mergedConfig, availableWorkspaces, currentTheme, configLoaded, globalTheme, themeUseGlobalDefault, keyShortcut, jsonBackupEnabled, globalJsonBackupEnabled, globalWeekStartsOn, locale, supportedLocales, jsonBackupUseGlobalDefault, manualComplexityEnabled, checklistDropdownEnabled, showTaskCardStatusLabel, exportWorkflowsPath, exportingResource, exportResult, pathSaved, settingsSection, exportEnvironment, setupState, buildInfo, saveSetupMode, saveWorkspaceProfile, setCurrentTheme, handleSaveTheme, handleSaveGlobalTheme, setKeyShortcut, handleJsonBackupEnabledChange, handleSaveGlobalJsonBackupEnabled, handleSaveGlobalWeekStartsOn, handleSaveLocale, handleManualComplexityEnabledChange, handleChecklistDropdownEnabledChange, handleShowTaskCardStatusLabelChange, handleResetProjectToGlobal, handleSaveSettings, setExportWorkflowsPath, setExportEnvironment, availableWorkflows, initiativeTemplates, availableEnvironments, fetchWorkflows, fetchInitiativeTemplates, createInitiativeFromTemplate, fetchWorkflowTemplate, fetchWorkflowOverrideNames, saveWorkflowTemplateDraft, resetWorkflowTemplateDraft, handleExportWorkflows, setShowFolderBrowser, setBrowserTarget, fetchFolders, activeCategories, pathValidation, taxonomyDisplayLabels, handleUpdateCategory, handleRemoveCategory, handleSaveCategory, handleAddPath, handleRemovePath, handleUpdateCategoryIcon, handleUpdateCategoryColor, activeTypes, handleSaveType, handleRemoveType, handleUpdateType, taxonomies, handleUpdateTaxonomies, priorities, handleUpdatePriorities, analyzeSystemTaxonomyPack, handleApplySystemTaxonomyPack, handleUpdateTaxonomyDisplayLabels, projectRoot, projectName, mcpHostRoot, serverHostRoot, mcpScriptPath, tenantId, runtimeMode, workspaceSwitchingEnabled, deleteWorkspace, setMcpHostRoot, isAuthenticated } = input;
+    const { resolveCloudAuthUrl, currentWorkspaceId, normalizedCloudAuthBaseUrl, normalizedCloudMcpBaseUrl, mergedConfig, availableWorkspaces, currentTheme, configLoaded, globalTheme, themeUseGlobalDefault, keyShortcut, jsonBackupEnabled, globalJsonBackupEnabled, globalWeekStartsOn, locale, supportedLocales, jsonBackupUseGlobalDefault, manualComplexityEnabled, checklistDropdownEnabled, showTaskCardStatusLabel, pathSaved, settingsSection, setupState, buildInfo, saveSetupMode, saveWorkspaceProfile, setCurrentTheme, handleSaveTheme, handleSaveGlobalTheme, setKeyShortcut, handleJsonBackupEnabledChange, handleSaveGlobalJsonBackupEnabled, handleSaveGlobalWeekStartsOn, handleSaveLocale, handleManualComplexityEnabledChange, handleChecklistDropdownEnabledChange, handleShowTaskCardStatusLabelChange, handleResetProjectToGlobal, handleSaveSettings, initiativeTemplates, fetchInitiativeTemplates, createInitiativeFromTemplate, setShowFolderBrowser, setBrowserTarget, fetchFolders, activeCategories, pathValidation, taxonomyDisplayLabels, handleUpdateCategory, handleRemoveCategory, handleSaveCategory, handleAddPath, handleRemovePath, handleUpdateCategoryIcon, handleUpdateCategoryColor, activeTypes, handleSaveType, handleRemoveType, handleUpdateType, taxonomies, handleUpdateTaxonomies, priorities, handleUpdatePriorities, analyzeSystemTaxonomyPack, handleApplySystemTaxonomyPack, handleUpdateTaxonomyDisplayLabels, projectRoot, projectName, mcpHostRoot, serverHostRoot, mcpScriptPath, tenantId, runtimeMode, workspaceSwitchingEnabled, deleteWorkspace, setMcpHostRoot, isAuthenticated } = input;
     const fetchCloudAuthApi = useCallback(async (path, init) => {
         const resolvedUrl = resolveCloudAuthUrl(path);
         const headers = new Headers(init?.headers || undefined);
@@ -28,9 +28,39 @@ export function useSettingsModel(input) {
         }
         return fetch(resolvedUrl, nextInit);
     }, [currentWorkspaceId, resolveCloudAuthUrl]);
+    const checkLocalMcpCliHealth = useCallback(async () => {
+        const headers = new Headers();
+        const workspaceHeader = String(currentWorkspaceId || '').trim();
+        if (workspaceHeader && workspaceHeader !== 'default') {
+            headers.set('x-taskforce-workspace-id', workspaceHeader);
+        }
+        const response = await fetch('/api/taskforce/mcp/global-cli-health', {
+            method: 'POST',
+            headers,
+            credentials: 'include',
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok || !payload?.result) {
+            throw new Error(String(payload?.error || 'Unable to validate the global Taskforce CLI.'));
+        }
+        return payload.result;
+    }, [currentWorkspaceId]);
+    const getLocalUpdateStatus = useCallback(async () => {
+        const response = await fetch('/api/taskforce/update/status', {
+            method: 'GET',
+            credentials: 'include',
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok || !payload?.result) {
+            throw new Error(String(payload?.error || 'Unable to determine Taskforce update availability.'));
+        }
+        return payload.result;
+    }, []);
     const currentWorkspace = availableWorkspaces.find((workspace) => workspace.id === currentWorkspaceId);
     return {
         fetchCloudAuthApi,
+        checkLocalMcpCliHealth,
+        getLocalUpdateStatus,
         currentTheme,
         configLoaded,
         globalTheme,
@@ -45,12 +75,8 @@ export function useSettingsModel(input) {
         manualComplexityEnabled,
         checklistDropdownEnabled,
         showTaskCardStatusLabel,
-        exportWorkflowsPath,
-        exportingResource,
-        exportResult,
         pathSaved,
         initialSection: settingsSection,
-        exportEnvironment,
         setupState,
         buildInfo,
         onSaveSetupMode: saveSetupMode,
@@ -68,19 +94,9 @@ export function useSettingsModel(input) {
         onShowTaskCardStatusLabelChange: handleShowTaskCardStatusLabelChange,
         onResetProjectToGlobal: handleResetProjectToGlobal,
         onSaveSettings: handleSaveSettings,
-        onExportWorkflowsPathChange: setExportWorkflowsPath,
-        onExportEnvironmentChange: setExportEnvironment,
-        availableWorkflows,
         initiativeTemplates,
-        availableEnvironments,
-        onRefreshWorkflows: fetchWorkflows,
         onRefreshInitiativeTemplates: fetchInitiativeTemplates,
         onCreateInitiativeFromTemplate: createInitiativeFromTemplate,
-        onFetchWorkflowTemplate: fetchWorkflowTemplate,
-        onFetchWorkflowOverrideNames: fetchWorkflowOverrideNames,
-        onSaveWorkflowTemplateDraft: saveWorkflowTemplateDraft,
-        onResetWorkflowTemplateDraft: resetWorkflowTemplateDraft,
-        onExportWorkflows: handleExportWorkflows,
         onShowFolderBrowserChange: setShowFolderBrowser,
         onBrowserTargetChange: setBrowserTarget,
         onFetchFolders: fetchFolders,

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

@@ -18,7 +18,6 @@ interface UseSettingsPersistenceInput {
     setManualComplexityEnabled: (value: boolean) => void;
     setChecklistDropdownEnabled: (value: boolean) => void;
     setShowTaskCardStatusLabel: (value: boolean) => void;
-    setShowChecklist: (value: boolean) => void;
 }
 export declare function useSettingsPersistence(input: UseSettingsPersistenceInput): {
     handleSaveSettings: () => Promise<boolean>;

package/dist/hooks/ui/useSettingsPersistence.js

@@ -1,7 +1,7 @@
 import { useCallback } from 'react';
 import { setLocale as setAppLocale } from '../../localization';
 export function useSettingsPersistence(input) {
-    const { keyShortcut, themeUseGlobalDefault, runtimeMode, jsonBackupUseGlobalDefault, globalTheme, globalJsonBackupEnabled, setCurrentTheme, setThemeUseGlobalDefault, setGlobalTheme, setJsonBackupEnabled, setJsonBackupUseGlobalDefault, setGlobalJsonBackupEnabled, setGlobalWeekStartsOn, setLocale, setManualComplexityEnabled, setChecklistDropdownEnabled, setShowTaskCardStatusLabel, setShowChecklist } = input;
+    const { keyShortcut, themeUseGlobalDefault, runtimeMode, jsonBackupUseGlobalDefault, globalTheme, globalJsonBackupEnabled, setCurrentTheme, setThemeUseGlobalDefault, setGlobalTheme, setJsonBackupEnabled, setJsonBackupUseGlobalDefault, setGlobalJsonBackupEnabled, setGlobalWeekStartsOn, setLocale, setManualComplexityEnabled, setChecklistDropdownEnabled, setShowTaskCardStatusLabel } = input;
     const handleSaveSettings = useCallback(async () => {
         try {
             const globalRes = await fetch('/api/taskforce/global-settings', {
@@ -160,8 +160,6 @@ export function useSettingsPersistence(input) {
     }, [setManualComplexityEnabled]);
     const handleChecklistDropdownEnabledChange = useCallback(async (enabled) => {
         setChecklistDropdownEnabled(enabled);
-        if (!enabled)
-            setShowChecklist(false);
         try {
             const configRes = await fetch('/api/taskforce/config', {
                 method: 'POST',
@@ -177,7 +175,7 @@ export function useSettingsPersistence(input) {
             console.error('[Taskforce] Failed to save checklist dropdown setting');
             return false;
         }
-    }, [setChecklistDropdownEnabled, setShowChecklist]);
+    }, [setChecklistDropdownEnabled]);
     const handleShowTaskCardStatusLabelChange = useCallback(async (enabled) => {
         setShowTaskCardStatusLabel(enabled);
         try {
@@ -203,8 +201,7 @@ export function useSettingsPersistence(input) {
         setJsonBackupEnabled(globalJsonBackupEnabled);
         setManualComplexityEnabled(false);
         setChecklistDropdownEnabled(true);
-        setShowTaskCardStatusLabel(true);
-        setShowChecklist(false);
+        setShowTaskCardStatusLabel(false);
         try {
             const configRes = await fetch('/api/taskforce/config', {
                 method: 'POST',
@@ -235,8 +232,7 @@ export function useSettingsPersistence(input) {
         globalJsonBackupEnabled,
         setManualComplexityEnabled,
         setChecklistDropdownEnabled,
-        setShowTaskCardStatusLabel,
-        setShowChecklist
+        setShowTaskCardStatusLabel
     ]);
     return {
         handleSaveSettings,

package/dist/hooks/ui/useSettingsTaxonomyManagement.js

@@ -370,6 +370,37 @@ export function useSettingsTaxonomyManagement(input) {
             return headers;
         };
         try {
+            const atomicResponse = await fetch(buildWorkspaceScopedUrl('/api/taskforce/taxonomy-library/apply'), {
+                method: 'POST',
+                headers: buildWorkspaceScopedHeaders(),
+                body: JSON.stringify({
+                    packId: pack.id,
+                    sections,
+                    remapExistingValuesToDefault,
+                }),
+            });
+            const atomicPayload = await atomicResponse.json().catch(() => ({}));
+            if (atomicResponse.ok && atomicPayload.taxonomyState) {
+                if (!isRemoteWorkspaceTarget) {
+                    if (sections.categories && atomicPayload.taxonomyState.categories) {
+                        setCustomCategories(atomicPayload.taxonomyState.categories);
+                    }
+                    if (sections.types && atomicPayload.taxonomyState.types) {
+                        setCustomTypes(atomicPayload.taxonomyState.types);
+                    }
+                    if (sections.priorities && atomicPayload.taxonomyState.priorities) {
+                        setPriorities(atomicPayload.taxonomyState.priorities);
+                    }
+                    await refreshTaskCollections({ isSilent: true });
+                }
+                return { success: true };
+            }
+            if (atomicPayload.code !== 'WORKSPACE_SYNC_V3_TAXONOMY_ACTIVATION_DISABLED') {
+                return {
+                    success: false,
+                    error: atomicPayload.error || 'Failed to apply taxonomy library pack atomically.',
+                };
+            }
             if (sections.categories) {
                 const packCategoryValues = new Set(pack.categories.map((categoryConfig) => categoryConfig.value));
                 const nextCategories = remapExistingValuesToDefault

package/dist/hooks/useFilterSort.d.ts

@@ -45,8 +45,8 @@ export declare function useFilterSort({ tasks, archivedTasks, activeCategories,
     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">>;
+    groupBy: "category" | "type" | "priority" | "status" | "complexity" | "assignee" | "schedule";
+    setGroupBy: import("react").Dispatch<import("react").SetStateAction<"category" | "type" | "priority" | "status" | "complexity" | "assignee" | "schedule">>;
     emptyColumnMode: "show" | "collapse" | "hide";
     setEmptyColumnMode: import("react").Dispatch<import("react").SetStateAction<"show" | "collapse" | "hide">>;
     collapsedCategories: Record<string, boolean>;

package/dist/hooks/useFilterSort.js

@@ -20,7 +20,7 @@
  *   - All filter/sort state and their setters
  *   - clearFilters() — resets all filters to "show everything" defaults
  */
-import { useState, useEffect, useCallback, useMemo } from 'react';
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
 import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
 import { STATUS_OPTIONS } from '../utils/constants';
 import { normalizeAssigneeOptions } from '../utils/assignees';
@@ -31,13 +31,15 @@ import { getFilterVisibleTaxonomyOptions } from '../utils/taxonomyFilterOptions.
 import { getVisibleTaxonomiesForTasks } from '../utils/taxonomyLifecycle.js';
 // === SECTION: Filter State ===
 export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTypes, priorities, taxonomies, configLoaded, referenceDataLoaded, assigneeOptionsLoaded, assigneeOptions }) {
+    const relationshipTasks = useMemo(() => [...tasks, ...archivedTasks], [archivedTasks, tasks]);
     const resolvedAssigneeOptions = useMemo(() => normalizeAssigneeOptions(assigneeOptions), [assigneeOptions]);
-    const filterableTaxonomies = useMemo(() => getVisibleTaxonomiesForTasks(taxonomies, [...tasks, ...archivedTasks])
+    const filterableTaxonomies = useMemo(() => getVisibleTaxonomiesForTasks(taxonomies, relationshipTasks)
         .filter((taxonomy) => taxonomy.filterEnabled !== false)
         .map((taxonomy) => ({
         ...taxonomy,
-        options: getFilterVisibleTaxonomyOptions(taxonomy, [...tasks, ...archivedTasks])
-    })), [archivedTasks, tasks, taxonomies]);
+        options: getFilterVisibleTaxonomyOptions(taxonomy, relationshipTasks)
+    })), [relationshipTasks, taxonomies]);
+    const filterableTaxonomyById = useMemo(() => new Map(filterableTaxonomies.map((taxonomy) => [taxonomy.id, taxonomy])), [filterableTaxonomies]);
     const assigneeFilterValues = useMemo(() => resolvedAssigneeOptions.map((opt) => opt.value), [resolvedAssigneeOptions]);
     const [searchQuery, setSearchQuery] = useState('');
     const [filterCategories, setFilterCategories] = useState([]);
@@ -48,6 +50,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
     const [filterAssignees, setFilterAssignees] = useState(assigneeFilterValues);
     const [filterAssigneesAllSelected, setFilterAssigneesAllSelected] = useState(true);
     const [filterTaxonomies, setFilterTaxonomies] = useState({});
+    const assigneeOptionsWereLoadedRef = useRef(assigneeOptionsLoaded);
     // === SECTION: Sort State ===
     const [sortBy, setSortBy] = useState('created');
     const [sortOrder, setSortOrder] = useState('desc');
@@ -66,11 +69,6 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
     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(() => {
@@ -115,10 +113,16 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
         const selectedValidValues = filterAssignees.filter((value) => assigneeFilterValues.includes(value));
         const isAllSelected = assigneeFilterValues.length > 0
             && assigneeFilterValues.every((value) => selectedValidValues.includes(value));
+        if (filterAssigneesAllSelected && !isAllSelected && assigneeOptionsLoaded && !assigneeOptionsWereLoadedRef.current) {
+            return;
+        }
         if (isAllSelected !== filterAssigneesAllSelected) {
             setFilterAssigneesAllSelected(isAllSelected);
         }
     }, [assigneeFilterValues, filterAssignees, filterAssigneesAllSelected, hasInitedFilters, assigneeOptionsLoaded]);
+    useEffect(() => {
+        assigneeOptionsWereLoadedRef.current = assigneeOptionsLoaded;
+    }, [assigneeOptionsLoaded]);
     useEffect(() => {
         if (!configLoaded || !referenceDataLoaded || !hasInitedFilters || activeCategories.length === 0)
             return;
@@ -232,7 +236,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             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);
+                const taxDef = filterableTaxonomyById.get(taxId);
                 if (!taxDef)
                     return true;
                 const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
@@ -249,7 +253,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, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected, taxonomies]);
+    }, [tasks, normalizedSearchQuery, taskSearchContext, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, filterableTaxonomies, filterableTaxonomyById, 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));
@@ -262,7 +266,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             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);
+                const taxDef = filterableTaxonomyById.get(taxId);
                 if (!taxDef)
                     return true;
                 const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
@@ -278,7 +282,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             });
             return matchCategory && matchPriority && matchType && matchStatus && matchAssignee && matchTaxonomies;
         });
-    }, [tasks, archivedTasks, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, hasInitedFilters, filterableTaxonomies, activeCategories, activeTypes, priorities, isAllFilterValuesSelected]);
+    }, [tasks, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, filterAssigneesAllSelected, filterTaxonomies, hasInitedFilters, filterableTaxonomies, filterableTaxonomyById, 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));
@@ -290,7 +294,7 @@ export function useFilterSort({ tasks, archivedTasks, activeCategories, activeTy
             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);
+                const taxDef = filterableTaxonomyById.get(taxId);
                 if (!taxDef)
                     return true;
                 const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
@@ -306,7 +310,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, normalizedSearchQuery, taskSearchContext, 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, filterableTaxonomyById, isAllFilterValuesSelected, taxonomies]);
     const groupedTasks = useMemo(() => {
         const groups = {};
         filteredTasks.forEach(task => {

package/dist/hooks/useRealtimeSync.d.ts

@@ -1,10 +1,20 @@
 import { type RealtimeReconcileTelemetry } from '../sync/realtimeReconcile';
 export type RealtimeConnectionState = 'connected' | 'reconnecting' | 'degraded-fallback';
 type RealtimeSignalType = 'taskforce:update' | 'taskforce:mutation' | 'taskforce:replay' | 'taskforce:replay-gap' | 'taskforce:replay-reset';
+export interface RealtimeInvalidationMetadata {
+    entityType?: string;
+    changeType?: string;
+    entityIds: string[];
+    affectedCollections?: string[];
+    lifecycleTransition?: string;
+    dataVersion?: number;
+}
 export interface RealtimeSyncSignal {
     type: RealtimeSignalType;
     workspaceId: string;
     eventId?: string;
+    eventIds?: string[];
+    invalidations?: RealtimeInvalidationMetadata[];
 }
 export interface UseRealtimeSyncInput {
     enabled: boolean;