@taskforcehq/taskforce 0.3.170 → 0.3.301

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

@@ -0,0 +1,119 @@
+import type { CategoryConfig, TaxonomyDefinition, TaskItem } from '../../types';
+import type { TaxonomyLibraryPack } from '../../shared/taxonomyLibrary.js';
+interface UseSettingsTaxonomyManagementInput {
+    activeCategories: CategoryConfig[];
+    activeTab: 'add' | 'tasks' | 'settings';
+    activeTypes: Array<{
+        value: string;
+        label: string;
+        color?: string;
+        icon?: string;
+        status?: 'active' | 'retired';
+    }>;
+    archivedTasks: TaskItem[];
+    browserTarget: 'storage' | {
+        type: 'category';
+        value: string;
+    } | null;
+    category: string;
+    configLoaded: boolean;
+    customCategories: CategoryConfig[];
+    refreshTaskCollections: (options?: {
+        isSilent?: boolean;
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    fetchTasks: (isSilent?: boolean) => Promise<void>;
+    filterCategories: string[];
+    getCategoryPaths: (category: CategoryConfig) => string[];
+    normalizePath: (fullPath: string) => string;
+    pathValidation: Record<string, {
+        exists: boolean;
+        isDirectory: boolean;
+        isFile: boolean;
+    }>;
+    setBrowserTarget: (value: 'storage' | {
+        type: 'category';
+        value: string;
+    } | null) => void;
+    setCategory: (value: string) => void;
+    setCustomCategories: (value: CategoryConfig[] | ((prev: CategoryConfig[]) => CategoryConfig[])) => void;
+    setCustomTypes: (value: Array<{
+        value: string;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>) => void;
+    setFilterCategories: (value: string[] | ((prev: string[]) => string[])) => void;
+    setPathValidation: (value: Record<string, {
+        exists: boolean;
+        isDirectory: boolean;
+        isFile: boolean;
+    }> | ((prev: Record<string, {
+        exists: boolean;
+        isDirectory: boolean;
+        isFile: boolean;
+    }>) => Record<string, {
+        exists: boolean;
+        isDirectory: boolean;
+        isFile: boolean;
+    }>)) => void;
+    setPriorities: (value: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>) => void;
+    setShowFolderBrowser: (value: boolean) => void;
+    setTaxonomies: (value: TaxonomyDefinition[]) => void;
+    tasks: TaskItem[];
+}
+interface SystemTaxonomyPackAnalysis {
+    unmatchedCategoryValues: string[];
+    unmatchedTypeValues: string[];
+    incompatiblePriorityValues: number[];
+}
+export declare function useSettingsTaxonomyManagement(input: UseSettingsTaxonomyManagementInput): {
+    getCategoryPaths: (category: CategoryConfig) => string[];
+    validatePaths: (paths: string[]) => Promise<void>;
+    handleUpdateCategory: (updatedCat: CategoryConfig, oldLabel?: string) => Promise<void>;
+    handleSaveCategory: (newCategoryName: string) => Promise<void>;
+    handleAddPath: (catValue: string, pathInput: string) => void;
+    handleUpdateCategoryIcon: (catValue: string, iconName: string) => void;
+    handleUpdateCategoryColor: (catValue: string, color: string) => void;
+    handleRemovePath: (catValue: string, pathToRemove: string) => void;
+    handleSelectPath: (path: string) => void;
+    handleRemoveCategory: (catValue: string) => Promise<void>;
+    handleSaveType: (labelInput: string) => Promise<void>;
+    handleRemoveType: (typeToRemove: string) => Promise<void>;
+    handleUpdateType: (typeValue: string, updates: Partial<{
+        label: string;
+        color?: string;
+        icon?: string;
+        status?: "active" | "retired";
+    }>) => Promise<void>;
+    handleUpdateTaxonomies: (updated: TaxonomyDefinition[]) => Promise<void>;
+    handleUpdatePriorities: (updated: Array<{
+        value: number;
+        label: string;
+        color?: string;
+        icon?: string;
+    }>) => Promise<void>;
+    analyzeSystemTaxonomyPack: (pack: TaxonomyLibraryPack) => SystemTaxonomyPackAnalysis;
+    handleApplySystemTaxonomyPack: (input: {
+        pack: TaxonomyLibraryPack;
+        sections: {
+            categories: boolean;
+            types: boolean;
+            priorities: boolean;
+        };
+        remapExistingValuesToDefault: boolean;
+        workspaceIdOverride?: string;
+    }) => Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        error?: undefined;
+    }>;
+};
+export {};

package/dist/hooks/ui/useSettingsTaxonomyManagement.js

@@ -0,0 +1,536 @@
+import { useCallback, useEffect } from 'react';
+import { DEFAULT_CATEGORY_LABEL, DEFAULT_CATEGORY_VALUE, DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
+export function useSettingsTaxonomyManagement(input) {
+    const { activeCategories, activeTab, activeTypes, archivedTasks, browserTarget, category, configLoaded, customCategories, refreshTaskCollections, fetchTasks, filterCategories, getCategoryPaths, normalizePath, pathValidation, setBrowserTarget, setCategory, setCustomCategories, setCustomTypes, setFilterCategories, setPathValidation, setPriorities, setShowFolderBrowser, setTaxonomies, tasks } = input;
+    const parseErrorMessage = useCallback(async (res, fallback) => {
+        const payload = await res.json().catch(() => ({}));
+        return String(payload?.error || fallback);
+    }, []);
+    const getAllTaskSnapshots = useCallback(() => [...tasks, ...archivedTasks], [archivedTasks, tasks]);
+    const getPackDefaultPriorityValue = useCallback((pack) => {
+        return pack.priorities.find((priority) => priority.value === 2)?.value
+            || pack.priorities[0]?.value
+            || 2;
+    }, []);
+    const validatePaths = useCallback(async (paths) => {
+        if (paths.length === 0)
+            return;
+        try {
+            const res = await fetch('/api/taskforce/validate-paths', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ paths }),
+            });
+            if (res.ok) {
+                const data = await res.json();
+                setPathValidation((prev) => ({ ...prev, ...data.results }));
+            }
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to validate paths:', err);
+        }
+    }, [setPathValidation]);
+    useEffect(() => {
+        if (activeTab !== 'settings' || !configLoaded)
+            return;
+        const allPaths = [];
+        activeCategories.forEach((categoryConfig) => {
+            const categoryPaths = getCategoryPaths(categoryConfig);
+            categoryPaths.forEach((path) => {
+                if (!allPaths.includes(path))
+                    allPaths.push(path);
+            });
+        });
+        const pathsToValidate = allPaths.filter((path) => !pathValidation[path]);
+        if (pathsToValidate.length > 0) {
+            void validatePaths(pathsToValidate);
+        }
+    }, [activeCategories, activeTab, configLoaded, getCategoryPaths, pathValidation, validatePaths]);
+    const handleUpdateCategory = useCallback(async (updatedCat, oldLabel) => {
+        if (!configLoaded)
+            return;
+        setCustomCategories((prev) => {
+            const current = prev.length > 0 ? prev : activeCategories;
+            return current.map((categoryConfig) => categoryConfig.value === updatedCat.value ? updatedCat : categoryConfig);
+        });
+        if (oldLabel && oldLabel !== updatedCat.label) {
+            if (category === oldLabel) {
+                setCategory(updatedCat.label);
+            }
+            if (filterCategories.includes(oldLabel)) {
+                setFilterCategories((prev) => prev.map((value) => value === oldLabel ? updatedCat.label : value));
+            }
+        }
+        try {
+            const currentCats = customCategories.length > 0 ? customCategories : activeCategories;
+            const updatedList = currentCats.map((categoryConfig) => categoryConfig.value === updatedCat.value ? updatedCat : categoryConfig);
+            const body = { categories: updatedList };
+            if (oldLabel && oldLabel !== updatedCat.label) {
+                body.reassignFrom = oldLabel;
+                body.reassignTo = updatedCat.label;
+            }
+            await fetch('/api/taskforce/categories', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            if (oldLabel) {
+                await fetchTasks();
+            }
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to update category', err);
+        }
+    }, [
+        activeCategories,
+        category,
+        configLoaded,
+        customCategories,
+        fetchTasks,
+        filterCategories,
+        setCategory,
+        setCustomCategories,
+        setFilterCategories
+    ]);
+    const handleSaveCategory = useCallback(async (newCategoryName) => {
+        if (!configLoaded)
+            return;
+        const generatedId = newCategoryName.trim().toLowerCase().replace(/\s+/g, '-');
+        if (activeCategories.some((categoryConfig) => categoryConfig.value === generatedId)) {
+            return;
+        }
+        const newCatConfig = {
+            value: generatedId,
+            label: newCategoryName.trim(),
+            color: 'blue-200',
+            icon: 'Folder'
+        };
+        setCustomCategories((prev) => {
+            const current = prev.length > 0 ? prev : activeCategories;
+            return [...current, newCatConfig];
+        });
+        try {
+            const currentCats = customCategories.length > 0 ? customCategories : activeCategories;
+            const updated = [...currentCats, newCatConfig];
+            await fetch('/api/taskforce/categories', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ categories: updated }),
+            });
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to create category', err);
+        }
+    }, [activeCategories, configLoaded, customCategories, setCustomCategories]);
+    const handleAddPath = useCallback((catValue, pathInput) => {
+        if (!pathInput.trim())
+            return;
+        const categoryConfig = activeCategories.find((entry) => entry.value === catValue);
+        if (!categoryConfig)
+            return;
+        const currentPaths = getCategoryPaths(categoryConfig);
+        const trimmedPath = pathInput.trim();
+        if (currentPaths.includes(trimmedPath))
+            return;
+        const newPaths = [...currentPaths, trimmedPath];
+        void handleUpdateCategory({ ...categoryConfig, path: undefined, paths: newPaths });
+        void validatePaths(newPaths);
+    }, [activeCategories, getCategoryPaths, handleUpdateCategory, validatePaths]);
+    const handleUpdateCategoryIcon = useCallback((catValue, iconName) => {
+        const categoryConfig = activeCategories.find((entry) => entry.value === catValue);
+        if (categoryConfig) {
+            void handleUpdateCategory({ ...categoryConfig, icon: iconName });
+        }
+    }, [activeCategories, handleUpdateCategory]);
+    const handleUpdateCategoryColor = useCallback((catValue, color) => {
+        const categoryConfig = activeCategories.find((entry) => entry.value === catValue);
+        if (categoryConfig) {
+            void handleUpdateCategory({ ...categoryConfig, color });
+        }
+    }, [activeCategories, handleUpdateCategory]);
+    const handleRemovePath = useCallback((catValue, pathToRemove) => {
+        const categoryConfig = activeCategories.find((entry) => entry.value === catValue);
+        if (!categoryConfig)
+            return;
+        const currentPaths = getCategoryPaths(categoryConfig);
+        const newPaths = currentPaths.filter((path) => path !== pathToRemove);
+        void handleUpdateCategory({ ...categoryConfig, path: undefined, paths: newPaths });
+    }, [activeCategories, getCategoryPaths, handleUpdateCategory]);
+    const handleSelectPath = useCallback((path) => {
+        const relativePath = normalizePath(path);
+        if (browserTarget && typeof browserTarget === 'object' && browserTarget.type === 'category') {
+            const categoryConfig = activeCategories.find((entry) => entry.value === browserTarget.value);
+            if (categoryConfig) {
+                const currentPaths = getCategoryPaths(categoryConfig);
+                if (!currentPaths.includes(relativePath)) {
+                    const newPaths = [...currentPaths, relativePath];
+                    void handleUpdateCategory({ ...categoryConfig, path: undefined, paths: newPaths });
+                }
+            }
+        }
+        setShowFolderBrowser(false);
+        setBrowserTarget(null);
+    }, [activeCategories, browserTarget, getCategoryPaths, handleUpdateCategory, normalizePath, setBrowserTarget, setShowFolderBrowser]);
+    const handleRemoveCategory = useCallback(async (catValue) => {
+        if (!configLoaded)
+            return;
+        const fallbackValue = DEFAULT_CATEGORY_VALUE;
+        const existingFallbackCategory = activeCategories.find((entry) => entry.value === fallbackValue);
+        const fallbackCategory = existingFallbackCategory
+            ? { ...existingFallbackCategory }
+            : { value: fallbackValue, label: DEFAULT_CATEGORY_LABEL, icon: 'Inbox' };
+        const fallbackLabel = fallbackCategory.label;
+        const catToRemove = activeCategories.find((entry) => entry.value === catValue);
+        setCustomCategories((prev) => {
+            const current = prev.length > 0 ? prev : activeCategories;
+            let updated = current.filter((entry) => entry.value !== catValue);
+            if (!updated.some((entry) => entry.value === fallbackValue)) {
+                updated = [fallbackCategory, ...updated];
+            }
+            return updated;
+        });
+        if (catToRemove) {
+            if (category === catToRemove.label || category === catToRemove.value) {
+                setCategory(fallbackValue);
+            }
+            if (filterCategories.includes(catToRemove.label) || filterCategories.includes(catToRemove.value)) {
+                setFilterCategories((prev) => {
+                    const filtered = prev.filter((value) => value !== catToRemove.label && value !== catToRemove.value);
+                    return filtered.includes(fallbackValue) ? filtered : [...filtered, fallbackValue];
+                });
+            }
+        }
+        try {
+            let updatedList = (customCategories.length > 0 ? customCategories : activeCategories)
+                .filter((entry) => entry.value !== catValue);
+            if (!updatedList.some((entry) => entry.value === fallbackValue)) {
+                updatedList = [fallbackCategory, ...updatedList];
+            }
+            await fetch('/api/taskforce/categories', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    categories: updatedList,
+                    reassignFrom: catToRemove?.label || catValue,
+                    reassignTo: fallbackLabel
+                }),
+            });
+            await fetchTasks();
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to remove category', err);
+        }
+    }, [
+        activeCategories,
+        category,
+        configLoaded,
+        customCategories,
+        fetchTasks,
+        filterCategories,
+        setCategory,
+        setCustomCategories,
+        setFilterCategories
+    ]);
+    const handleSaveType = useCallback(async (labelInput) => {
+        if (!labelInput.trim())
+            return;
+        const value = labelInput.trim().toLowerCase().replace(/\s+/g, '-');
+        if (activeTypes.some((type) => type.value === value))
+            return;
+        const updated = [...activeTypes, { value, label: labelInput.trim(), status: 'active' }];
+        setCustomTypes(updated);
+        try {
+            await fetch('/api/taskforce/types', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ types: updated }),
+            });
+        }
+        catch (err) {
+            console.error('Failed to save type', err);
+        }
+    }, [activeTypes, setCustomTypes]);
+    const handleRemoveType = useCallback(async (typeToRemove) => {
+        const updated = activeTypes.map((type) => (type.value === typeToRemove
+            ? { ...type, status: 'retired' }
+            : type));
+        setCustomTypes(updated);
+        try {
+            await fetch('/api/taskforce/types', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    types: updated
+                }),
+            });
+            await fetchTasks();
+        }
+        catch (err) {
+            console.error('Failed to save type', err);
+        }
+    }, [activeTypes, fetchTasks, setCustomTypes]);
+    const handleUpdateType = useCallback(async (typeValue, updates) => {
+        const currentType = activeTypes.find((type) => type.value === typeValue);
+        if (!currentType)
+            return;
+        const nextLabel = typeof updates.label === 'string' ? updates.label.trim() : currentType.label;
+        if (!nextLabel)
+            return;
+        const updated = activeTypes.map((type) => (type.value === typeValue
+            ? {
+                ...type,
+                ...updates,
+                label: nextLabel
+            }
+            : type));
+        const didChange = JSON.stringify(updated) !== JSON.stringify(activeTypes);
+        if (!didChange)
+            return;
+        setCustomTypes(updated);
+        try {
+            await fetch('/api/taskforce/types', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ types: updated }),
+            });
+        }
+        catch (err) {
+            console.error('Failed to update type', err);
+        }
+    }, [activeTypes, setCustomTypes]);
+    const handleUpdateTaxonomies = useCallback(async (updated) => {
+        if (!configLoaded)
+            return;
+        setTaxonomies(updated);
+        try {
+            await fetch('/api/taskforce/taxonomies', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ taxonomies: updated }),
+            });
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to save taxonomies', err);
+        }
+    }, [configLoaded, setTaxonomies]);
+    const handleUpdatePriorities = useCallback(async (updated) => {
+        if (!configLoaded)
+            return;
+        setPriorities(updated);
+        try {
+            await fetch('/api/taskforce/priorities', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ priorities: updated }),
+            });
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to save priorities', err);
+        }
+    }, [configLoaded, setPriorities]);
+    const analyzeSystemTaxonomyPack = useCallback((pack) => {
+        const allTasks = getAllTaskSnapshots();
+        const packCategoryValues = new Set(pack.categories.map((categoryConfig) => categoryConfig.value));
+        const packTypeValues = new Set(pack.types.map((type) => type.value));
+        const packPriorityValues = new Set(pack.priorities.map((priority) => Number(priority.value)));
+        const unmatchedCategoryValues = Array.from(new Set(allTasks
+            .map((task) => String(task.category || '').trim())
+            .filter((value) => value.length > 0 && !packCategoryValues.has(value)))).sort();
+        const unmatchedTypeValues = Array.from(new Set(allTasks
+            .map((task) => String(task.type || '').trim())
+            .filter((value) => value.length > 0 && !packTypeValues.has(value)))).sort();
+        const incompatiblePriorityValues = Array.from(new Set(allTasks
+            .map((task) => Number(task.priority))
+            .filter((value) => Number.isFinite(value) && value > 0 && !packPriorityValues.has(value)))).sort((a, b) => a - b);
+        return {
+            unmatchedCategoryValues,
+            unmatchedTypeValues,
+            incompatiblePriorityValues
+        };
+    }, [getAllTaskSnapshots]);
+    const handleApplySystemTaxonomyPack = useCallback(async (input) => {
+        if (!configLoaded) {
+            return { success: false, error: 'Settings are still loading.' };
+        }
+        const { pack, sections, remapExistingValuesToDefault, workspaceIdOverride } = input;
+        const resolvedWorkspaceIdOverride = String(workspaceIdOverride || '').trim();
+        const isRemoteWorkspaceTarget = resolvedWorkspaceIdOverride.length > 0;
+        const allTasks = isRemoteWorkspaceTarget ? [] : getAllTaskSnapshots();
+        const buildWorkspaceScopedUrl = (path) => {
+            if (!resolvedWorkspaceIdOverride)
+                return path;
+            const separator = path.includes('?') ? '&' : '?';
+            return `${path}${separator}workspaceId=${encodeURIComponent(resolvedWorkspaceIdOverride)}`;
+        };
+        const buildWorkspaceScopedHeaders = () => {
+            const headers = { 'Content-Type': 'application/json' };
+            if (resolvedWorkspaceIdOverride) {
+                headers['x-taskforce-workspace-id'] = resolvedWorkspaceIdOverride;
+            }
+            return headers;
+        };
+        try {
+            if (sections.categories) {
+                const packCategoryValues = new Set(pack.categories.map((categoryConfig) => categoryConfig.value));
+                const nextCategories = remapExistingValuesToDefault
+                    ? [...pack.categories]
+                    : [
+                        ...pack.categories,
+                        ...activeCategories
+                            .filter((categoryConfig) => !packCategoryValues.has(categoryConfig.value))
+                            .map((categoryConfig) => ({ ...categoryConfig, disabled: true }))
+                    ];
+                if (!isRemoteWorkspaceTarget) {
+                    setCustomCategories(nextCategories);
+                }
+                const res = await fetch(buildWorkspaceScopedUrl('/api/taskforce/categories'), {
+                    method: 'POST',
+                    headers: buildWorkspaceScopedHeaders(),
+                    body: JSON.stringify({ categories: nextCategories }),
+                });
+                if (!res.ok) {
+                    return {
+                        success: false,
+                        error: await parseErrorMessage(res, 'Failed to apply category library pack.')
+                    };
+                }
+            }
+            if (sections.types) {
+                const packTypeValues = new Set(pack.types.map((type) => type.value));
+                const defaultTypeValue = pack.types.find((type) => type.value === DEFAULT_TYPE_VALUE)?.value
+                    || pack.types[0]?.value
+                    || DEFAULT_TYPE_VALUE;
+                if (remapExistingValuesToDefault) {
+                    const typeUpdates = allTasks
+                        .filter((task) => task.type && !packTypeValues.has(String(task.type)))
+                        .map((task) => ({ id: task.id, type: defaultTypeValue }));
+                    if (typeUpdates.length > 0) {
+                        const res = await fetch(buildWorkspaceScopedUrl('/api/taskforce/bulk-update-fields'), {
+                            method: 'POST',
+                            headers: buildWorkspaceScopedHeaders(),
+                            body: JSON.stringify({ updates: typeUpdates }),
+                        });
+                        if (!res.ok) {
+                            return {
+                                success: false,
+                                error: await parseErrorMessage(res, 'Failed to remap task types to the pack default.')
+                            };
+                        }
+                    }
+                }
+                const nextTypes = remapExistingValuesToDefault
+                    ? [...pack.types]
+                    : [
+                        ...pack.types,
+                        ...activeTypes
+                            .filter((type) => !packTypeValues.has(type.value))
+                            .map((type) => ({ ...type, status: 'retired' }))
+                    ];
+                if (!isRemoteWorkspaceTarget) {
+                    setCustomTypes(nextTypes);
+                }
+                const res = await fetch(buildWorkspaceScopedUrl('/api/taskforce/types'), {
+                    method: 'POST',
+                    headers: buildWorkspaceScopedHeaders(),
+                    body: JSON.stringify({ types: nextTypes }),
+                });
+                if (!res.ok) {
+                    return {
+                        success: false,
+                        error: await parseErrorMessage(res, 'Failed to apply task type library pack.')
+                    };
+                }
+            }
+            if (sections.priorities) {
+                const packPriorityValues = new Set(pack.priorities.map((priority) => priority.value));
+                const incompatiblePriorityValues = Array.from(new Set(allTasks
+                    .map((task) => Number(task.priority))
+                    .filter((value) => Number.isFinite(value) && value > 0 && !packPriorityValues.has(value)))).sort((a, b) => a - b);
+                if (incompatiblePriorityValues.length > 0 && !remapExistingValuesToDefault) {
+                    return {
+                        success: false,
+                        error: `This workspace still uses priority levels ${incompatiblePriorityValues.join(', ')}. Enable "Remap unmatched existing values to default" to replace them before applying this pack.`
+                    };
+                }
+                if (incompatiblePriorityValues.length > 0) {
+                    const defaultPriorityValue = getPackDefaultPriorityValue(pack);
+                    const priorityUpdates = allTasks
+                        .filter((task) => incompatiblePriorityValues.includes(Number(task.priority)))
+                        .map((task) => ({ id: task.id, priority: defaultPriorityValue }));
+                    if (priorityUpdates.length > 0) {
+                        const res = await fetch(buildWorkspaceScopedUrl('/api/taskforce/bulk-update-fields'), {
+                            method: 'POST',
+                            headers: buildWorkspaceScopedHeaders(),
+                            body: JSON.stringify({ updates: priorityUpdates }),
+                        });
+                        if (!res.ok) {
+                            return {
+                                success: false,
+                                error: await parseErrorMessage(res, 'Failed to remap task priorities to the pack default.')
+                            };
+                        }
+                    }
+                }
+                const nextPriorities = pack.priorities.map((priority) => ({
+                    ...priority,
+                    value: Number(priority.value)
+                }));
+                if (!isRemoteWorkspaceTarget) {
+                    setPriorities(nextPriorities);
+                }
+                const res = await fetch(buildWorkspaceScopedUrl('/api/taskforce/priorities'), {
+                    method: 'POST',
+                    headers: buildWorkspaceScopedHeaders(),
+                    body: JSON.stringify({ priorities: nextPriorities }),
+                });
+                if (!res.ok) {
+                    return {
+                        success: false,
+                        error: await parseErrorMessage(res, 'Failed to apply priority library pack.')
+                    };
+                }
+            }
+            if (!isRemoteWorkspaceTarget) {
+                await refreshTaskCollections({ isSilent: true });
+            }
+            return { success: true };
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to apply system taxonomy pack', err);
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : 'Failed to apply system taxonomy pack.'
+            };
+        }
+    }, [
+        activeCategories,
+        activeTypes,
+        configLoaded,
+        getAllTaskSnapshots,
+        getPackDefaultPriorityValue,
+        parseErrorMessage,
+        refreshTaskCollections,
+        setCustomCategories,
+        setCustomTypes,
+        setPriorities
+    ]);
+    return {
+        getCategoryPaths,
+        validatePaths,
+        handleUpdateCategory,
+        handleSaveCategory,
+        handleAddPath,
+        handleUpdateCategoryIcon,
+        handleUpdateCategoryColor,
+        handleRemovePath,
+        handleSelectPath,
+        handleRemoveCategory,
+        handleSaveType,
+        handleRemoveType,
+        handleUpdateType,
+        handleUpdateTaxonomies,
+        handleUpdatePriorities,
+        analyzeSystemTaxonomyPack,
+        handleApplySystemTaxonomyPack
+    };
+}

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

@@ -0,0 +1 @@
+export { useUiNotice } from '../useUiNotice';

package/dist/hooks/ui/useUiNotice.js

@@ -0,0 +1 @@
+export { useUiNotice } from '../useUiNotice';