@taskforcehq/taskforce 0.3.168

package/dist/hooks/useTaskforce.js

@@ -0,0 +1,4396 @@
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { DEFAULT_CONFIG } from '../types';
+import { STATUS_OPTIONS } from '../utils/constants';
+import { sortChildTasksForDisplay } from '../utils/taskRelations';
+import { shouldPromptReparent, wouldCreateParentCycle } from '../utils/taskParenting';
+import { buildHierarchyDepthMap, collectSubtreeTaskIds } from '../utils/taskHierarchy';
+import { PRIORITY_LOGIC } from '../compat/priorityCompat';
+import { migrateCategoryFilterLabels, matchesPriorityFilter, normalizePriorityFilterValues, normalizeTaskFromApi } from '../migrations/clientMigrations';
+import { getSupportedLocales, initializeLocale, setLocale as setAppLocale, t } from '../localization';
+import { WORKSPACE_BOOTSTRAP_SCOPE, isReservedWorkspaceId, normalizeWorkspaceStorageScopeLegacy, normalizeWorkspaceStorageScope, resolveWorkspaceStorageScopeFromProjectRoot } from '../utils/workspaceIdentity';
+import { resolveRuntimeModeContract } from '../shared/runtimeContract';
+import { useSyncOrchestrator } from './useSyncOrchestrator';
+import { deriveAuthGuardPolicy, shouldSkipDataVersionPolling, shouldSkipDataVersionTick } from './authGuardPolicy';
+const ASSIGNEE_OPTIONS = [
+    { value: 'agent', label: 'AI' },
+    { value: 'user', label: 'User' },
+    { value: 'unassigned', label: 'Unassigned' }
+];
+function generateClientUuid() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2, 14)}`;
+}
+const DEFAULT_CLOUD_APP_ORIGIN = (() => {
+    const configuredBase = typeof import.meta.env.VITE_TASKFORCE_BASE_URL === 'string'
+        ? import.meta.env.VITE_TASKFORCE_BASE_URL.trim().replace(/\/+$/, '')
+        : '';
+    const configuredCloudAuth = typeof import.meta.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL === 'string'
+        ? import.meta.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL.trim().replace(/\/+$/, '')
+        : '';
+    if (configuredCloudAuth)
+        return configuredCloudAuth;
+    const configuredApi = typeof import.meta.env.VITE_TASKFORCE_API_BASE_URL === 'string'
+        ? import.meta.env.VITE_TASKFORCE_API_BASE_URL.trim().replace(/\/+$/, '')
+        : '';
+    if (configuredApi)
+        return configuredApi;
+    if (configuredBase)
+        return configuredBase;
+    // Safety default for local runtime cloud auth/sync fallback.
+    return 'https://app.taskforcehq.ai';
+})();
+const WORKSPACE_CONTEXT_KEY_PREFIX = 'taskforce.workspaceContext.v2';
+const BOOTSTRAP_REQUEST_TIMEOUT_MS = 12_000;
+function buildWorkspaceContextStorageKey(scopeRaw) {
+    const scope = normalizeWorkspaceStorageScope(scopeRaw);
+    return `${WORKSPACE_CONTEXT_KEY_PREFIX}.${scope}`;
+}
+function buildLegacyWorkspaceContextStorageKey(scopeRaw) {
+    const scope = normalizeWorkspaceStorageScopeLegacy(scopeRaw);
+    return `${WORKSPACE_CONTEXT_KEY_PREFIX}.${scope}`;
+}
+function readPersistedWorkspaceId(scopeRaw) {
+    if (typeof window === 'undefined')
+        return '';
+    try {
+        const scopedKey = buildWorkspaceContextStorageKey(scopeRaw);
+        const scopedValue = String(window.localStorage.getItem(scopedKey) || '').trim();
+        if (scopedValue && scopedValue.length <= 120 && !/\s/.test(scopedValue))
+            return scopedValue;
+        const legacyScopedKey = buildLegacyWorkspaceContextStorageKey(scopeRaw);
+        const legacyScopedValue = String(window.localStorage.getItem(legacyScopedKey) || '').trim();
+        if (legacyScopedValue && legacyScopedValue.length <= 120 && !/\s/.test(legacyScopedValue)) {
+            // Migration bridge: promote legacy scope key into hash-scoped key.
+            window.localStorage.setItem(scopedKey, legacyScopedValue);
+            return legacyScopedValue;
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
+function writePersistedWorkspaceId(workspaceId, scopeRaw) {
+    if (typeof window === 'undefined')
+        return;
+    const next = String(workspaceId || '').trim();
+    try {
+        if (!next || isReservedWorkspaceId(next))
+            return;
+        const storageKey = buildWorkspaceContextStorageKey(scopeRaw);
+        const existing = String(window.localStorage.getItem(storageKey) || '').trim();
+        if (!next && existing && existing.toLowerCase() !== 'default') {
+            return;
+        }
+        window.localStorage.setItem(storageKey, next);
+    }
+    catch {
+        // best-effort only
+    }
+}
+export function useTaskforce({ config = {}, initialTaskId, onTaskCountChange, onClose }) {
+    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+    const { categories, types, apiEndpoint, apiBaseUrl, cloudAuthBaseUrl, wsBaseUrl, shortcut: configShortcut } = mergedConfig;
+    const runtimeHost = typeof window !== 'undefined'
+        ? String(window.location.hostname || '').trim().toLowerCase()
+        : '';
+    const isLoopbackHost = runtimeHost === 'localhost' || runtimeHost === '127.0.0.1' || runtimeHost === '::1';
+    const isCloudHost = typeof window !== 'undefined' && !isLoopbackHost;
+    const [runtimeConfigOverride, setRuntimeConfigOverride] = useState({
+        baseUrl: '',
+        apiBaseUrl: '',
+        cloudAuthBaseUrl: '',
+        wsBaseUrl: '',
+        cloudAuthViaLocalProxy: false,
+        authSource: '',
+        workspaceMode: '',
+        workspaceSwitchingEnabled: null
+    });
+    const [runtimeConfigReady, setRuntimeConfigReady] = useState(false);
+    const normalizeBaseUrl = useCallback((value) => {
+        return typeof value === 'string' ? value.trim().replace(/\/+$/, '') : '';
+    }, []);
+    useEffect(() => {
+        if (typeof window === 'undefined') {
+            setRuntimeConfigReady(true);
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const res = await fetch('/api/taskforce/auth/runtime-config', {
+                    method: 'GET',
+                    credentials: 'include'
+                });
+                if (!res.ok)
+                    return;
+                const payload = await res.json().catch(() => ({}));
+                const cfg = payload?.config && typeof payload.config === 'object' ? payload.config : {};
+                if (cancelled)
+                    return;
+                const runtimeModeRaw = String(cfg.runtimeMode || '').trim().toLowerCase();
+                const runtimeModeHint = runtimeModeRaw === 'cloud' ? 'cloud' : 'local';
+                const workspaceModeRaw = String(cfg.workspaceMode || '').trim();
+                const workspaceMode = workspaceModeRaw === 'single-local' || workspaceModeRaw === 'multi-cloud'
+                    ? workspaceModeRaw
+                    : (runtimeModeHint === 'cloud' ? 'multi-cloud' : 'single-local');
+                const authSourceRaw = String(cfg.authSource || '').trim().toLowerCase();
+                const authSource = authSourceRaw === 'local' ? 'local' : 'cloud';
+                setRuntimeConfigOverride({
+                    baseUrl: normalizeBaseUrl(cfg.baseUrl),
+                    apiBaseUrl: normalizeBaseUrl(cfg.apiBaseUrl),
+                    cloudAuthBaseUrl: normalizeBaseUrl(cfg.cloudAuthBaseUrl),
+                    wsBaseUrl: normalizeBaseUrl(cfg.wsBaseUrl),
+                    cloudAuthViaLocalProxy: Boolean(cfg.cloudAuthViaLocalProxy),
+                    authSource,
+                    workspaceMode,
+                    workspaceSwitchingEnabled: typeof cfg.workspaceSwitchingEnabled === 'boolean'
+                        ? Boolean(cfg.workspaceSwitchingEnabled)
+                        : (workspaceMode === 'multi-cloud')
+                });
+            }
+            catch {
+                // Optional endpoint; ignore failures.
+            }
+            finally {
+                if (!cancelled)
+                    setRuntimeConfigReady(true);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [normalizeBaseUrl]);
+    const defaultCloudAuthBaseUrl = (() => {
+        if (typeof window === 'undefined')
+            return '';
+        return isLoopbackHost ? DEFAULT_CLOUD_APP_ORIGIN : '';
+    })();
+    const envBaseUrl = normalizeBaseUrl(import.meta.env.VITE_TASKFORCE_BASE_URL);
+    const envApiBaseUrl = normalizeBaseUrl(import.meta.env.VITE_TASKFORCE_API_BASE_URL);
+    const envCloudAuthBaseUrl = normalizeBaseUrl(import.meta.env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL);
+    const propApiBaseUrl = normalizeBaseUrl(apiBaseUrl);
+    const propCloudAuthBaseUrl = normalizeBaseUrl(cloudAuthBaseUrl);
+    const normalizedApiBaseUrl = propApiBaseUrl
+        || runtimeConfigOverride.apiBaseUrl
+        || runtimeConfigOverride.baseUrl
+        || envApiBaseUrl
+        || envBaseUrl
+        || '';
+    const normalizedCloudAuthBaseUrl = (propCloudAuthBaseUrl
+        || runtimeConfigOverride.cloudAuthBaseUrl
+        || runtimeConfigOverride.baseUrl
+        || envCloudAuthBaseUrl
+        || envBaseUrl
+        || normalizedApiBaseUrl
+        || defaultCloudAuthBaseUrl).trim().replace(/\/+$/, '');
+    const authOnlyCloudMode = Boolean(normalizedCloudAuthBaseUrl) && !normalizedApiBaseUrl;
+    const shouldProbeCloudAuth = runtimeConfigReady && (Boolean(normalizedCloudAuthBaseUrl || normalizedApiBaseUrl) || isCloudHost);
+    const shouldGateProtectedApiCalls = shouldProbeCloudAuth && !authOnlyCloudMode;
+    const cloudAuthConfigured = Boolean(normalizedCloudAuthBaseUrl || normalizedApiBaseUrl || isCloudHost);
+    const initialRuntimeMode = isCloudHost ? 'cloud' : 'local';
+    const resolveApiUrl = useCallback((path) => {
+        if (!path)
+            return path;
+        if (/^https?:\/\//i.test(path))
+            return path;
+        if (!normalizedApiBaseUrl || !path.startsWith('/'))
+            return path;
+        return `${normalizedApiBaseUrl}${path}`;
+    }, [normalizedApiBaseUrl]);
+    const resolveCloudAuthUrl = useCallback((path) => {
+        if (!path)
+            return path;
+        if (/^https?:\/\//i.test(path))
+            return path;
+        if (!path.startsWith('/'))
+            return path;
+        const isCloudScopedPath = path.startsWith('/api/taskforce/auth/') || path.startsWith('/api/taskforce/sync/');
+        if (!isCloudHost && isCloudScopedPath && (!runtimeConfigReady || runtimeConfigOverride.cloudAuthViaLocalProxy)) {
+            return path;
+        }
+        const base = normalizedCloudAuthBaseUrl || normalizedApiBaseUrl;
+        if (base) {
+            const candidate = `${base}${path}`;
+            if (typeof window !== 'undefined' && !isCloudHost && isCloudScopedPath) {
+                try {
+                    const resolved = new URL(candidate, window.location.origin);
+                    // In local runtime, never route cloud auth/sync to the local origin.
+                    if (resolved.origin === window.location.origin) {
+                        return `${DEFAULT_CLOUD_APP_ORIGIN}${path}`;
+                    }
+                }
+                catch {
+                    return `${DEFAULT_CLOUD_APP_ORIGIN}${path}`;
+                }
+            }
+            return candidate;
+        }
+        if (!isCloudHost && isCloudScopedPath)
+            return path;
+        return path;
+    }, [runtimeConfigReady, runtimeConfigOverride.cloudAuthViaLocalProxy, normalizedCloudAuthBaseUrl, normalizedApiBaseUrl, isCloudHost]);
+    const resolveWebSocketUrl = useCallback((path) => {
+        const wsPath = String(path || '').trim() || '/taskforce-ws';
+        const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
+        const configuredBase = String(wsBaseUrl
+            || runtimeConfigOverride.wsBaseUrl
+            || normalizedApiBaseUrl
+            || '').trim().replace(/\/+$/, '');
+        const fallbackBase = typeof window !== 'undefined' ? window.location.origin : '';
+        const base = configuredBase || fallbackBase;
+        if (!base)
+            return '';
+        try {
+            const resolved = new URL(normalizedPath, base);
+            if (resolved.protocol === 'https:')
+                resolved.protocol = 'wss:';
+            if (resolved.protocol === 'http:')
+                resolved.protocol = 'ws:';
+            return resolved.toString();
+        }
+        catch {
+            return '';
+        }
+    }, [wsBaseUrl, runtimeConfigOverride.wsBaseUrl, normalizedApiBaseUrl]);
+    // Tab state
+    const [activeTab, setActiveTab__internal] = useState('tasks');
+    const [isOpen, setIsOpen] = useState(false);
+    const [showArchive, setShowArchive] = useState(false);
+    // Settings state
+    const [currentTheme, setCurrentTheme] = useState(mergedConfig.theme || 'dark');
+    const [globalTheme, setGlobalTheme] = useState(mergedConfig.theme || 'dark');
+    const [themeUseGlobalDefault, setThemeUseGlobalDefault] = useState(true);
+    const [storagePath] = useState('.taskforce');
+    const pathSaved = false;
+    const [showFolderBrowser, setShowFolderBrowser] = useState(false);
+    const [folders, setFolders] = useState([]);
+    const [files, setFiles] = useState([]);
+    const [currentBrowsePath, setCurrentBrowsePath] = useState('');
+    const [browserTarget, setBrowserTarget] = useState(null);
+    const [contextLinkBrowsePath, setContextLinkBrowsePath] = useState('');
+    const [settingsSection, setSettingsSection] = useState(null);
+    const [projectRoot, setProjectRoot] = useState('');
+    const [projectName, setProjectName] = useState('');
+    const workspaceStorageScope = useMemo(() => resolveWorkspaceStorageScopeFromProjectRoot(projectRoot), [projectRoot]);
+    const [mcpScriptPath, setMcpScriptPath] = useState('');
+    const [tenantId, setTenantId] = useState('');
+    const [availableSpecialists, setAvailableSpecialists] = useState([]);
+    const [runtimeMode, setRuntimeMode] = useState(() => initialRuntimeMode);
+    const runtimeContractFallback = resolveRuntimeModeContract(runtimeMode);
+    const workspaceMode = runtimeConfigOverride.workspaceMode === 'single-local' || runtimeConfigOverride.workspaceMode === 'multi-cloud'
+        ? runtimeConfigOverride.workspaceMode
+        : runtimeContractFallback.workspaceMode;
+    const workspaceSwitchingEnabled = typeof runtimeConfigOverride.workspaceSwitchingEnabled === 'boolean'
+        ? runtimeConfigOverride.workspaceSwitchingEnabled
+        : runtimeContractFallback.workspaceSwitchingEnabled;
+    const [authRequiredForApi, setAuthRequiredForApi] = useState(false);
+    const [authBlocked, setAuthBlocked] = useState(false);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [authUserId, setAuthUserId] = useState('anonymous');
+    const [authUserEmail, setAuthUserEmail] = useState('');
+    const [hasBetaAccess, setHasBetaAccess] = useState(true);
+    const [currentWorkspaceId, setCurrentWorkspaceId] = useState(() => {
+        // Local runtime workspace identity must be sourced from local DB (/api/taskforce/config),
+        // not from persisted browser context or cloud session payloads.
+        if (initialRuntimeMode === 'local')
+            return 'default';
+        const persisted = readPersistedWorkspaceId(workspaceStorageScope);
+        return persisted && persisted.toLowerCase() !== 'default' ? persisted : 'default';
+    });
+    const [availableWorkspaces, setAvailableWorkspaces] = useState([]);
+    const [workspaceBootstrapPending, setWorkspaceBootstrapPending] = useState(false);
+    const [authSessionResolved, setAuthSessionResolved] = useState(false);
+    const [bootstrapPhase, setBootstrapPhase] = useState('idle');
+    const [bootstrapError, setBootstrapError] = useState(null);
+    const [bootstrapStartedAt, setBootstrapStartedAt] = useState(null);
+    const authSessionRequestRef = useRef(null);
+    const authSessionLastCheckedAtRef = useRef(0);
+    const authSessionLastResultRef = useRef(false);
+    // Local runtime APIs must stay available immediately on app start, even when cloud
+    // auth probing is still in-flight. Only cloud runtime should defer/block protected APIs.
+    const authGuardPolicy = useMemo(() => deriveAuthGuardPolicy({
+        shouldGateProtectedApiCalls,
+        runtimeMode,
+        authSessionResolved,
+        authRequiredForApi,
+        isAuthenticated
+    }), [shouldGateProtectedApiCalls, runtimeMode, authSessionResolved, authRequiredForApi, isAuthenticated]);
+    const shouldDeferProtectedApiCalls = authGuardPolicy.shouldDeferProtectedApiCalls;
+    const shouldBlockProtectedApiCalls = authGuardPolicy.shouldBlockProtectedApiCalls;
+    const [setupState, setSetupState] = useState(null);
+    const [runtimeCapabilities, setRuntimeCapabilities] = useState(null);
+    const [realtimeSyncEnabled, setRealtimeSyncEnabled] = useState(false);
+    const [realtimeSyncFlagSource, setRealtimeSyncFlagSource] = useState('unknown');
+    const [buildInfo, setBuildInfo] = useState(null);
+    const [keyShortcut, setKeyShortcut] = useState(mergedConfig.shortcut || 'Alt+T');
+    const [priorities, setPriorities] = useState(mergedConfig.priorities || []);
+    const [approaches, setApproaches] = useState(mergedConfig.approaches || []);
+    const [mcpHostRoot, setMcpHostRoot] = useState('');
+    const [jsonBackupEnabled, setJsonBackupEnabled] = useState(false);
+    const [globalJsonBackupEnabled, setGlobalJsonBackupEnabled] = useState(false);
+    const [jsonBackupUseGlobalDefault, setJsonBackupUseGlobalDefault] = useState(true);
+    const [locale, setLocale] = useState(() => initializeLocale());
+    const supportedLocales = useMemo(() => getSupportedLocales(), []);
+    const [globalWeekStartsOn, setGlobalWeekStartsOn] = useState(() => {
+        try {
+            const locale = Intl.DateTimeFormat().resolvedOptions().locale || '';
+            return locale.toLowerCase().startsWith('en-us') ? 'sunday' : 'monday';
+        }
+        catch {
+            return 'monday';
+        }
+    });
+    const [manualComplexityEnabled, setManualComplexityEnabled] = useState(false);
+    const [checklistDropdownEnabled, setChecklistDropdownEnabled] = useState(false);
+    const [assigneeFilterEnabled, setAssigneeFilterEnabled] = useState(false);
+    const [serverHostRoot, setServerHostRoot] = useState('');
+    const [returnTab, setReturnTab] = useState(null);
+    useEffect(() => {
+        if (typeof window === 'undefined' || typeof window.fetch !== 'function')
+            return;
+        const originalFetch = window.fetch.bind(window);
+        const isLocalOnlyTaskforcePath = (pathname) => (pathname === '/api/taskforce/sync/workspace/apply-local');
+        const rewriteTaskforceApiRequest = (input) => {
+            if (typeof input === 'string') {
+                if (runtimeMode !== 'cloud')
+                    return input;
+                return (input.startsWith('/api/taskforce') && !isLocalOnlyTaskforcePath(input)) ? resolveApiUrl(input) : input;
+            }
+            if (input instanceof URL) {
+                if (runtimeMode !== 'cloud')
+                    return input;
+                if (input.origin === window.location.origin && input.pathname.startsWith('/api/taskforce')) {
+                    if (isLocalOnlyTaskforcePath(input.pathname))
+                        return input;
+                    return new URL(resolveApiUrl(`${input.pathname}${input.search}${input.hash}`));
+                }
+                return input;
+            }
+            if (typeof Request !== 'undefined' && input instanceof Request) {
+                if (runtimeMode !== 'cloud')
+                    return input;
+                const parsed = new URL(input.url, window.location.origin);
+                if (parsed.origin === window.location.origin && parsed.pathname.startsWith('/api/taskforce')) {
+                    if (isLocalOnlyTaskforcePath(parsed.pathname))
+                        return input;
+                    return resolveApiUrl(`${parsed.pathname}${parsed.search}${parsed.hash}`);
+                }
+            }
+            return input;
+        };
+        const resolveInputUrl = (input) => {
+            try {
+                if (typeof input === 'string')
+                    return new URL(input, window.location.origin);
+                if (input instanceof URL)
+                    return input;
+                if (typeof Request !== 'undefined' && input instanceof Request) {
+                    return new URL(input.url, window.location.origin);
+                }
+                return null;
+            }
+            catch {
+                return null;
+            }
+        };
+        window.fetch = ((input, init) => {
+            const nextInput = rewriteTaskforceApiRequest(input);
+            const resolvedUrl = resolveInputUrl(nextInput);
+            const shouldInjectWorkspaceHeader = Boolean(resolvedUrl
+                && resolvedUrl.origin === window.location.origin
+                && resolvedUrl.pathname.startsWith('/api/taskforce'));
+            if (!shouldInjectWorkspaceHeader) {
+                return originalFetch(nextInput, init);
+            }
+            const workspaceIdHeader = String(currentWorkspaceId || '').trim();
+            if (typeof Request !== 'undefined' && nextInput instanceof Request) {
+                const headers = new Headers(nextInput.headers);
+                if (init?.headers) {
+                    const initHeaders = new Headers(init.headers);
+                    initHeaders.forEach((value, key) => headers.set(key, value));
+                }
+                if (runtimeMode === 'cloud' && workspaceIdHeader && workspaceIdHeader !== 'default' && !headers.has('x-taskforce-workspace-id')) {
+                    headers.set('x-taskforce-workspace-id', workspaceIdHeader);
+                }
+                const request = new Request(nextInput, { ...init, headers });
+                return originalFetch(request);
+            }
+            const headers = new Headers(init?.headers);
+            if (runtimeMode === 'cloud' && workspaceIdHeader && workspaceIdHeader !== 'default' && !headers.has('x-taskforce-workspace-id')) {
+                headers.set('x-taskforce-workspace-id', workspaceIdHeader);
+            }
+            return originalFetch(nextInput, { ...init, headers });
+        });
+        return () => {
+            window.fetch = originalFetch;
+        };
+    }, [currentWorkspaceId, normalizedApiBaseUrl, resolveApiUrl, runtimeMode]);
+    // Available Workflows
+    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]);
+    // Resource Export state
+    const [exportEnvironment, setExportEnvironment] = useState('antigravity');
+    const [availableEnvironments, setAvailableEnvironments] = useState([]);
+    const [groupBy, setGroupBy] = useState('category');
+    const [emptyColumnMode, setEmptyColumnMode] = useState('show');
+    const [zenMode, setZenMode] = useState(false);
+    const [exportWorkflowsPath, setExportWorkflowsPath] = useState('.agent/workflows');
+    const [exportSpecialistsPath, setExportSpecialistsPath] = useState('.tasknexus/agents');
+    const [exportingResource, setExportingResource] = useState(null);
+    const [exportResult, setExportResult] = useState(null);
+    // Update paths when environment changes
+    useEffect(() => {
+        const env = availableEnvironments.find(e => e.id === exportEnvironment);
+        if (env) {
+            setExportWorkflowsPath(env.directory);
+            // Standardized specialists export path across all environments
+            setExportSpecialistsPath('.tasknexus/agents');
+        }
+    }, [exportEnvironment, availableEnvironments]);
+    // Unsaved Changes Modal State
+    const [unsavedModalOpen, setUnsavedModalOpen] = useState(false);
+    const [pendingNavigation, setPendingNavigation] = useState(null);
+    const [successBanner, setSuccessBanner] = useState(null);
+    const [returnToParentTaskId, setReturnToParentTaskId] = useState(null);
+    const [returnFromChildTaskId, setReturnFromChildTaskId] = useState(null);
+    const tasksScrollRef = useRef(null);
+    const [tasksScrollPos, setTasksScrollPos] = useState(0);
+    // Path normalization helper
+    const normalizePath = useCallback((fullPath) => {
+        if (!fullPath || !projectRoot)
+            return fullPath;
+        if (fullPath.startsWith(projectRoot)) {
+            return fullPath.slice(projectRoot.length).replace(/^[/\\]+/, '');
+        }
+        return fullPath;
+    }, [projectRoot]);
+    // Fullscreen / Zen Mode logic
+    const toggleZenMode = useCallback(async () => {
+        if (!document.fullscreenElement) {
+            try {
+                await document.documentElement.requestFullscreen();
+                setZenMode(true);
+            }
+            catch (err) {
+                console.error(`Error attempting to enable full-screen mode: ${err}`);
+            }
+        }
+        else {
+            if (document.exitFullscreen) {
+                await document.exitFullscreen();
+                setZenMode(false);
+            }
+        }
+    }, [zenMode]);
+    useEffect(() => {
+        const handleFullscreenChange = () => {
+            setZenMode(!!document.fullscreenElement);
+        };
+        document.addEventListener('fullscreenchange', handleFullscreenChange);
+        return () => document.removeEventListener('fullscreenchange', handleFullscreenChange);
+    }, []);
+    const handleSaveSettings = useCallback(async () => {
+        // Save keyboard shortcut only
+        try {
+            const globalRes = await fetch('/api/taskforce/global-settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    shortcut: keyShortcut
+                }),
+            });
+            if (!globalRes.ok) {
+                throw new Error(`Failed to save global settings (${globalRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save shortcut');
+            return false;
+        }
+    }, [keyShortcut]);
+    const handleSaveTheme = useCallback(async (theme) => {
+        setCurrentTheme(theme);
+        setThemeUseGlobalDefault(false);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ theme }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save project theme');
+            return false;
+        }
+    }, []);
+    const handleSaveGlobalTheme = useCallback(async (theme) => {
+        setGlobalTheme(theme);
+        if (themeUseGlobalDefault) {
+            setCurrentTheme(theme);
+        }
+        try {
+            const globalRes = await fetch('/api/taskforce/global-settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ theme }),
+            });
+            if (!globalRes.ok) {
+                throw new Error(`Failed to save global settings (${globalRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save global theme');
+            return false;
+        }
+    }, [themeUseGlobalDefault]);
+    const handleJsonBackupEnabledChange = useCallback(async (enabled) => {
+        setJsonBackupEnabled(enabled);
+        setJsonBackupUseGlobalDefault(false);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ jsonBackupEnabled: enabled }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save project backup setting');
+            return false;
+        }
+    }, []);
+    const handleSaveGlobalJsonBackupEnabled = useCallback(async (enabled) => {
+        setGlobalJsonBackupEnabled(enabled);
+        if (jsonBackupUseGlobalDefault) {
+            setJsonBackupEnabled(enabled);
+        }
+        try {
+            const globalRes = await fetch('/api/taskforce/global-settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ jsonBackupEnabled: enabled }),
+            });
+            if (!globalRes.ok) {
+                throw new Error(`Failed to save global settings (${globalRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save global backup setting');
+            return false;
+        }
+    }, [jsonBackupUseGlobalDefault]);
+    const handleSaveGlobalWeekStartsOn = useCallback(async (weekStartsOn) => {
+        setGlobalWeekStartsOn(weekStartsOn);
+        try {
+            const globalRes = await fetch('/api/taskforce/global-settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    schedulePreferences: {
+                        weekStartsOn
+                    }
+                }),
+            });
+            if (!globalRes.ok) {
+                throw new Error(`Failed to save global settings (${globalRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save regional week start setting');
+            return false;
+        }
+    }, []);
+    const handleSaveLocale = useCallback(async (nextLocale) => {
+        const applied = setAppLocale(nextLocale);
+        setLocale(applied);
+        return true;
+    }, []);
+    const handleManualComplexityEnabledChange = useCallback(async (enabled) => {
+        setManualComplexityEnabled(enabled);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ manualComplexityEnabled: enabled }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save manual complexity setting');
+            return false;
+        }
+    }, []);
+    const handleChecklistDropdownEnabledChange = useCallback(async (enabled) => {
+        setChecklistDropdownEnabled(enabled);
+        if (!enabled)
+            setShowChecklist(false);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ checklistDropdownEnabled: enabled }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save checklist dropdown setting');
+            return false;
+        }
+    }, []);
+    const handleAssigneeFilterEnabledChange = useCallback(async (enabled) => {
+        setAssigneeFilterEnabled(enabled);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ assigneeFilterEnabled: enabled }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to save assignee filter setting');
+            return false;
+        }
+    }, []);
+    const handleResetProjectToGlobal = useCallback(async () => {
+        setThemeUseGlobalDefault(true);
+        setJsonBackupUseGlobalDefault(true);
+        setCurrentTheme(globalTheme);
+        setJsonBackupEnabled(globalJsonBackupEnabled);
+        setManualComplexityEnabled(false);
+        setChecklistDropdownEnabled(false);
+        setAssigneeFilterEnabled(false);
+        setShowChecklist(false);
+        try {
+            const configRes = await fetch('/api/taskforce/config', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    theme: null,
+                    jsonBackupEnabled: null,
+                    manualComplexityEnabled: null,
+                    checklistDropdownEnabled: null,
+                    assigneeFilterEnabled: null
+                }),
+            });
+            if (!configRes.ok) {
+                throw new Error(`Failed to save config (${configRes.status})`);
+            }
+            return true;
+        }
+        catch {
+            console.error('[Taskforce] Failed to reset project settings');
+            return false;
+        }
+    }, [globalTheme, globalJsonBackupEnabled]);
+    const handleExportResources = useCallback(async (type, path) => {
+        setExportingResource(type);
+        setExportResult(null);
+        try {
+            const res = await fetch('/api/taskforce/export-resources', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    type,
+                    path,
+                    variables: {
+                        STORAGE_PATH: storagePath.replace(/\/$/, '') || '.Taskforce',
+                        WORKFLOWS_PATH: exportWorkflowsPath.replace(/\/$/, ''),
+                        SPECIALISTS_PATH: exportSpecialistsPath.replace(/\/$/, '')
+                    },
+                    environment: exportEnvironment
+                })
+            });
+            const data = await res.json();
+            if (data.success) {
+                setExportResult({ type: 'success', message: `Successfully exported ${data.count} ${type} to ${path}` });
+            }
+            else {
+                setExportResult({ type: 'error', message: data.error || `Failed to export ${type}` });
+            }
+        }
+        catch (error) {
+            setExportResult({ type: 'error', message: `Network error exporting ${type}` });
+        }
+        finally {
+            setExportingResource(null);
+            setTimeout(() => setExportResult(null), 5000);
+        }
+    }, [storagePath, exportWorkflowsPath, exportSpecialistsPath, exportEnvironment]);
+    const handleExportWorkflows = useCallback(async (environment, selected) => {
+        setExportingResource('workflows');
+        setExportResult(null);
+        try {
+            const res = await fetch('/api/taskforce/export-resources', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    type: 'workflows',
+                    environment,
+                    workflowNames: selected,
+                    variables: {
+                        STORAGE_PATH: storagePath.replace(/\/$/, '') || '.Taskforce'
+                    }
+                })
+            });
+            const data = await res.json();
+            if (data.success) {
+                setExportResult({ type: 'success', message: `Successfully exported ${data.count} workflows to ${environment}` });
+            }
+            else {
+                setExportResult({ type: 'error', message: data.error || 'Export failed' });
+            }
+        }
+        catch {
+            setExportResult({ type: 'error', message: 'Network error exporting workflows' });
+        }
+        finally {
+            setExportingResource(null);
+            setTimeout(() => setExportResult(null), 5000);
+        }
+    }, [storagePath]);
+    // Tasks state
+    const [tasks, setTasks] = useState([]);
+    const [archivedTasks, setArchivedTasks] = useState([]);
+    const [loadingTasks, setLoadingTasks] = useState(false);
+    const [editingTaskId, setEditingTaskId] = useState(null);
+    const [showMarkdownHelp, setShowMarkdownHelp] = useState(false);
+    const [copiedId, setCopiedId] = useState(null);
+    const [cancellationPromptTask, setCancellationPromptTask] = useState(null);
+    const [cancellationOpenDescendantIds, setCancellationOpenDescendantIds] = useState([]);
+    const [cancellationMode, setCancellationMode] = useState(null);
+    // Custom categories
+    const [customCategories, setCustomCategories] = useState([]);
+    const [configLoaded, setConfigLoaded] = useState(false); // Track if API config has been fetched
+    const [pathValidation, setPathValidation] = useState({}); // Validation results
+    const bootstrapGuardRef = useRef({
+        authSessionResolved: false,
+        configLoaded: false,
+        workspaceBootstrapPending: false
+    });
+    useEffect(() => {
+        bootstrapGuardRef.current = {
+            authSessionResolved,
+            configLoaded,
+            workspaceBootstrapPending
+        };
+    }, [authSessionResolved, configLoaded, workspaceBootstrapPending]);
+    const markBootstrapPhase = useCallback((phase) => {
+        setBootstrapPhase(phase);
+        if (phase !== 'ready') {
+            setBootstrapError(null);
+            setBootstrapStartedAt(Date.now());
+        }
+    }, []);
+    const markBootstrapStalled = useCallback((message) => {
+        // Only surface stalled bootstrap state while initial app bootstrap is unresolved.
+        const guard = bootstrapGuardRef.current;
+        if (guard.authSessionResolved && guard.configLoaded && !guard.workspaceBootstrapPending)
+            return;
+        setBootstrapPhase('stalled');
+        setBootstrapError(message);
+        setBootstrapStartedAt((prev) => prev ?? Date.now());
+    }, []);
+    const fetchWithTimeout = useCallback(async (url, init, timeoutMs = BOOTSTRAP_REQUEST_TIMEOUT_MS) => {
+        const abortController = new AbortController();
+        const timeoutLabel = Number(timeoutMs) > 0 ? Number(timeoutMs) : BOOTSTRAP_REQUEST_TIMEOUT_MS;
+        const timerId = typeof window !== 'undefined'
+            ? window.setTimeout(() => abortController.abort('bootstrap-timeout'), timeoutLabel)
+            : null;
+        try {
+            return await fetch(url, {
+                ...(init || {}),
+                signal: abortController.signal
+            });
+        }
+        catch (error) {
+            const isAbortError = error instanceof DOMException
+                ? error.name === 'AbortError'
+                : String(error?.name || '').toLowerCase() === 'aborterror';
+            if (isAbortError) {
+                const timeoutError = new Error(`Startup checks timed out after ${timeoutLabel}ms.`);
+                timeoutError.name = 'BootstrapTimeoutError';
+                throw timeoutError;
+            }
+            throw error;
+        }
+        finally {
+            if (timerId !== null && typeof window !== 'undefined') {
+                window.clearTimeout(timerId);
+            }
+        }
+    }, []);
+    const isBootstrapTimeoutError = useCallback((error) => {
+        return String(error?.name || '') === 'BootstrapTimeoutError';
+    }, []);
+    // Custom types
+    const [customTypes, setCustomTypes] = useState([]);
+    // Generic Taxonomies (Phase 1)
+    const [taxonomies, setTaxonomies] = useState(mergedConfig.taxonomies || []);
+    // Use custom categories if available, otherwise default
+    const activeCategories = useMemo(() => {
+        const cats = customCategories.length > 0 ? customCategories : (categories || []);
+        return cats
+            .map(cat => typeof cat === 'string' ? { value: cat.toLowerCase().replace(/\s+/g, '-'), label: cat } : cat)
+            .sort((a, b) => a.label.localeCompare(b.label));
+    }, [customCategories, categories]);
+    // Categories that are not disabled (for filter and assignment dropdowns)
+    const visibleCategories = useMemo(() => {
+        return activeCategories.filter(cat => !cat.disabled);
+    }, [activeCategories]);
+    const getPreferredCategoryValue = useCallback((cats) => {
+        const preferred = cats.find(c => c.value === 'default' ||
+            c.value === 'general' ||
+            c.label === 'General' ||
+            c.value === 'Taskforce' ||
+            c.label === 'Taskforce');
+        return preferred?.value || cats[0]?.value || 'default';
+    }, []);
+    const activeTypes = customTypes.length > 0 ? customTypes : types;
+    // Form state
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState('');
+    const handleUnauthorized = useCallback(() => {
+        // Local runtime supports guest usage; do not force login screen there.
+        setAuthBlocked(runtimeMode === 'cloud');
+        setIsAuthenticated(false);
+        setAuthUserEmail('');
+        setError('Authentication required. Sign in to continue.');
+    }, [runtimeMode]);
+    const checkAuthSession = useCallback(async () => {
+        markBootstrapPhase('auth');
+        if (!runtimeConfigReady) {
+            // Keep prior auth identity during bootstrap until runtime auth config is resolved.
+            // This avoids transient "signed out" UI flicker on refresh.
+            return authSessionLastResultRef.current;
+        }
+        if (!shouldProbeCloudAuth) {
+            setRuntimeMode('local');
+            setAuthRequiredForApi(false);
+            setIsAuthenticated(false);
+            setAuthUserId('anonymous');
+            setAuthUserEmail('');
+            setUserGlobalSyncStatus('disconnected');
+            setUserGlobalSyncPendingChanges(0);
+            setUserGlobalSyncError(null);
+            setHasBetaAccess(true);
+            setAvailableWorkspaces([]);
+            setAuthBlocked(false);
+            setAuthSessionResolved(true);
+            authSessionLastResultRef.current = false;
+            authSessionLastCheckedAtRef.current = Date.now();
+            return false;
+        }
+        const sessionUrl = resolveCloudAuthUrl('/api/taskforce/auth/session');
+        const now = Date.now();
+        if (authSessionRequestRef.current)
+            return authSessionRequestRef.current;
+        if (authSessionResolved && (now - authSessionLastCheckedAtRef.current) < 1500) {
+            return authSessionLastResultRef.current;
+        }
+        const request = (async () => {
+            const abortController = new AbortController();
+            const timeoutId = typeof window !== 'undefined'
+                ? window.setTimeout(() => abortController.abort(), 8000)
+                : null;
+            try {
+                const res = await fetch(sessionUrl, {
+                    method: 'GET',
+                    credentials: 'include',
+                    mode: 'cors',
+                    signal: abortController.signal
+                });
+                if (res.status === 429) {
+                    setAuthSessionResolved(true);
+                    return authSessionLastResultRef.current;
+                }
+                if (!res.ok) {
+                    setAuthSessionResolved(true);
+                    authSessionLastResultRef.current = false;
+                    return false;
+                }
+                const data = await res.json();
+                const required = Boolean(data.authRequiredForApi);
+                const authenticated = Boolean(data.authenticated);
+                const betaAccess = authenticated ? (data.betaAccess !== false) : true;
+                const workspaceId = typeof data.workspaceId === 'string' && data.workspaceId.trim().length > 0
+                    ? data.workspaceId.trim()
+                    : '';
+                const userId = typeof data.userId === 'string' && data.userId.trim().length > 0
+                    ? data.userId.trim()
+                    : 'anonymous';
+                const userEmail = typeof data.email === 'string' && data.email.trim().length > 0
+                    ? data.email.trim().toLowerCase()
+                    : '';
+                const isLocalRuntime = runtimeMode === 'local';
+                const keepLocalWorkspaceContext = runtimeMode === 'local' || authOnlyCloudMode;
+                setAuthRequiredForApi(authOnlyCloudMode ? false : (isLocalRuntime ? false : required));
+                setIsAuthenticated(authenticated);
+                setAuthUserId(authenticated ? userId : 'anonymous');
+                setAuthUserEmail(authenticated ? userEmail : '');
+                setUserGlobalSyncStatus(authenticated ? 'idle' : 'disconnected');
+                setUserGlobalSyncError(null);
+                if (!authenticated)
+                    setUserGlobalSyncPendingChanges(0);
+                setHasBetaAccess(betaAccess);
+                if (keepLocalWorkspaceContext) {
+                    // Local runtime resolves workspace identity from local DB via /api/taskforce/config.
+                    // Do not override it from cloud auth session payloads.
+                }
+                else {
+                    setCurrentWorkspaceId(workspaceId || readPersistedWorkspaceId(workspaceStorageScope) || 'default');
+                }
+                setAuthBlocked(authOnlyCloudMode ? false : (isLocalRuntime ? false : (required && !authenticated)));
+                // Runtime mode should be sourced from /api/taskforce/config, not
+                // from auth-session responses which may come from a separate cloud-auth origin.
+                setAuthSessionResolved(true);
+                authSessionLastResultRef.current = authenticated;
+                if (authenticated)
+                    markBootstrapPhase('ready');
+                return authenticated;
+            }
+            catch {
+                setAuthSessionResolved(true);
+                authSessionLastResultRef.current = false;
+                markBootstrapStalled('Unable to verify your session.');
+                return authSessionLastResultRef.current;
+            }
+            finally {
+                if (timeoutId !== null && typeof window !== 'undefined') {
+                    window.clearTimeout(timeoutId);
+                }
+                authSessionLastCheckedAtRef.current = Date.now();
+                authSessionRequestRef.current = null;
+            }
+        })();
+        authSessionRequestRef.current = request;
+        return request;
+    }, [
+        runtimeConfigReady,
+        shouldProbeCloudAuth,
+        authSessionResolved,
+        resolveCloudAuthUrl,
+        authOnlyCloudMode,
+        runtimeMode,
+        workspaceStorageScope,
+        markBootstrapPhase,
+        markBootstrapStalled
+    ]);
+    const { userGlobalSyncStatus, setUserGlobalSyncStatus, userGlobalLastSyncedAt, setUserGlobalLastSyncedAt, userGlobalSyncPendingChanges, setUserGlobalSyncPendingChanges, userGlobalSyncError, setUserGlobalSyncError, workspaceLastPullAt, setWorkspaceLastPullAt, workspaceLastPushAt, setWorkspaceLastPushAt, workspaceLastErrorAt, setWorkspaceLastErrorAt, workspaceLastErrorMessage, setWorkspaceLastErrorMessage, workspaceLastWarningMessage, workspaceCloudSyncEnabled, realtimeConnectionState, realtimeTelemetry, setWorkspaceCloudSyncEnabled, workspaceSyncSourceOfTruth, setWorkspaceSyncSourceOfTruth, workspaceSyncOnboardingCompleted, setWorkspaceSyncOnboardingCompleted, workspaceSyncReady, setWorkspaceSyncReady, workspaceCloudHydrated, setWorkspaceCloudHydrated, workspaceSyncDocuments, setWorkspaceSyncDocuments, workspaceSyncDocumentsFingerprint, setWorkspaceSyncDocumentsFingerprint, syncInFlightRef, workspaceRetryAt, isWorkspacePullRetryPending, workspaceBootstrapSyncInProgress, setWorkspaceBootstrapSyncInProgress, workspaceBootstrapSyncPages, setWorkspaceBootstrapSyncPages, workspaceBootstrapSyncAppliedChanges, setWorkspaceBootstrapSyncAppliedChanges, workspaceSyncFailureCount, workspaceSyncRetryScheduledCount, workspaceSyncAuthFailureCount, workspaceSyncLastFailureSource, workspaceSyncLastFailureStatusCode, workspacePushInFlightRef, workspacePullInFlightRef, workspaceLastPushedSignatureRef, workspacePendingSignatureRef, workspaceLastPushedTaskIdsRef, workspaceDeletedTaskIdsRef, workspacePullCursorRef, workspacePullBootstrapDoneRef, workspaceBackfillForcedRef, workspaceSyncReadyRef, workspaceCloudHydratedRef, clearWorkspaceRetry, scheduleWorkspacePullRetry, isWorkspacePullCooldownActive, markWorkspacePullCooldown, tryAcquireWorkspacePullLease, releaseWorkspacePullLease, recordWorkspaceSyncFailure, incrementWorkspaceSyncAuthFailure, persistWorkspaceSyncPatch, loadWorkspaceSyncState, applyWorkspaceSyncStateSnapshot, syncUserGlobalSettings, getLocalUserSyncUpdatedAt, setLocalUserSyncUpdatedAt, buildUserGlobalSyncPayload, applyRemoteUserGlobalSyncPayload, ensureCloudWorkspaceReadyForSync, buildWorkspaceSyncPayload, buildWorkspaceSyncSignature, refreshWorkspaceSyncDocumentsSnapshot, handleSyncAuthFailure, ensureWorkspaceSyncReady, pushWorkspaceChangesToCloud, pullWorkspaceChangesFromCloud, fetchLocalWorkspaceSnapshot, saveWorkspaceCloudSyncSettings, retryUserGlobalSettingsSync, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull } = useSyncOrchestrator({
+        currentWorkspaceId,
+        cloudAuthConfigured,
+        runtimeMode,
+        isAuthenticated,
+        authUserId,
+        projectName,
+        resolveCloudAuthUrl,
+        resolveWebSocketUrl,
+        realtimeSyncEnabled,
+        tasks,
+        archivedTasks,
+        taxonomies,
+        setupState,
+        globalTheme,
+        locale,
+        globalWeekStartsOn,
+        themeUseGlobalDefault,
+        setTasks,
+        setArchivedTasks,
+        setAuthBlocked,
+        setIsAuthenticated,
+        checkAuthSession,
+        setGlobalTheme,
+        setCurrentTheme,
+        setSetupState,
+        setLocale,
+        setGlobalWeekStartsOn
+    });
+    const [category, setCategory] = useState(() => {
+        return getPreferredCategoryValue(activeCategories);
+    });
+    const [type, setType] = useState('feature');
+    const [priority, setPriority] = useState(2);
+    const [complexity, setComplexity] = useState(3);
+    const [approach, setApproach] = useState('default');
+    const [assignee, setAssignee] = useState('agent');
+    const [scheduledDate, setScheduledDate] = useState('');
+    const [dueDate, setDueDate] = useState('');
+    const [parentTaskIdInput, setParentTaskIdInput] = useState('');
+    const [addChildTaskIdInput, setAddChildTaskIdInput] = useState('');
+    const [title, setTitle] = useState('');
+    const [description, setDescription] = useState('');
+    const [comments, setComments] = useState([]);
+    const [newCommentText, setNewCommentText] = useState('');
+    const [formTaxonomies, setFormTaxonomies] = useState({});
+    const commentsEndRef = useRef(null);
+    const [selectedSpecialists, setSelectedSpecialists] = useState([]);
+    const [showSpecialists, setShowSpecialists] = useState(false);
+    const [showChecklist, setShowChecklist] = useState(false);
+    const [showTaskRelationships, setShowTaskRelationships] = useState(false);
+    const [showChildTasks, setShowChildTasks] = useState(false);
+    const [lastUsedCategory, setLastUsedCategory] = useState('');
+    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(ASSIGNEE_OPTIONS.map((opt) => opt.value));
+    const [parentTaskFilterMode, setParentTaskFilterMode] = useState('all');
+    const [filterTaxonomies, setFilterTaxonomies] = useState({});
+    const [sortBy, setSortBy] = useState('created');
+    const [sortOrder, setSortOrder] = useState('desc');
+    const [showComments, setShowComments] = useState(false);
+    const [descriptionFocused, setDescriptionFocused] = useState(false);
+    const [isCapturingScreenshot, setIsCapturingScreenshot] = useState(false);
+    const [screenshots, setScreenshots] = useState([]);
+    const [recentlyChangedTaskIds, setRecentlyChangedTaskIds] = useState([]);
+    const [scheduleWarningPrompt, setScheduleWarningPrompt] = useState(null);
+    const taskRevisionMapRef = useRef(new Map());
+    const hasFetchedTasksRef = useRef(false);
+    const highlightTimersRef = useRef(new Map());
+    const dataVersionRef = useRef(null);
+    const authSessionResolvedRef = useRef(authSessionResolved);
+    const authRequiredForApiRef = useRef(authRequiredForApi);
+    const isAuthenticatedRef = useRef(isAuthenticated);
+    const hasLoadedUiStateRef = useRef(false);
+    const [uiStateReady, setUiStateReady] = useState(false);
+    useEffect(() => {
+        if (runtimeMode !== 'cloud')
+            return;
+        writePersistedWorkspaceId(currentWorkspaceId, workspaceStorageScope);
+    }, [runtimeMode, currentWorkspaceId, workspaceStorageScope]);
+    useEffect(() => {
+        authSessionResolvedRef.current = authSessionResolved;
+        authRequiredForApiRef.current = authRequiredForApi;
+        isAuthenticatedRef.current = isAuthenticated;
+    }, [authSessionResolved, authRequiredForApi, isAuthenticated]);
+    const getTaskRevisionKey = useCallback((task) => {
+        return `${task.updatedAt || task.createdAt || ''}|${task.status}|${task.priority}|${task.title}`;
+    }, []);
+    const markRecentlyChangedTasks = useCallback((taskIds) => {
+        if (!taskIds.length || typeof window === 'undefined')
+            return;
+        setRecentlyChangedTaskIds(prev => Array.from(new Set([...prev, ...taskIds])));
+        taskIds.forEach((taskId) => {
+            const existing = highlightTimersRef.current.get(taskId);
+            if (existing) {
+                window.clearTimeout(existing);
+            }
+            const timerId = window.setTimeout(() => {
+                highlightTimersRef.current.delete(taskId);
+                setRecentlyChangedTaskIds(prev => prev.filter(id => id !== taskId));
+            }, 4000);
+            highlightTimersRef.current.set(taskId, timerId);
+        });
+    }, []);
+    const loadPersistedUiState = useCallback(async () => {
+        try {
+            const res = await fetch('/api/taskforce/ui-state?key=app', {
+                method: 'GET',
+                credentials: 'include'
+            });
+            if (!res.ok) {
+                setUiStateReady(true);
+                return;
+            }
+            const data = await res.json().catch(() => ({}));
+            const state = (data?.state && typeof data.state === 'object')
+                ? data.state
+                : null;
+            if (!state) {
+                setUiStateReady(true);
+                return;
+            }
+            if (typeof state.groupBy === 'string')
+                setGroupBy(state.groupBy);
+            if (state.emptyColumnMode === 'show' || state.emptyColumnMode === 'collapse' || state.emptyColumnMode === 'hide')
+                setEmptyColumnMode(state.emptyColumnMode);
+            if (typeof state.zenMode === 'boolean')
+                setZenMode(state.zenMode);
+            if (typeof state.searchQuery === 'string')
+                setSearchQuery(state.searchQuery);
+            if (Array.isArray(state.filterCategories))
+                setFilterCategories(state.filterCategories);
+            if (Array.isArray(state.filterPriorities))
+                setFilterPriorities(state.filterPriorities);
+            if (Array.isArray(state.filterTypes))
+                setFilterTypes(state.filterTypes);
+            if (Array.isArray(state.filterStatus))
+                setFilterStatus(state.filterStatus);
+            if (Array.isArray(state.filterAssignees))
+                setFilterAssignees(state.filterAssignees);
+            if (state.filterTaxonomies && typeof state.filterTaxonomies === 'object')
+                setFilterTaxonomies(state.filterTaxonomies);
+            if (state.parentTaskFilterMode === 'all' || state.parentTaskFilterMode === 'parents' || state.parentTaskFilterMode === 'linked' || state.parentTaskFilterMode === 'unlinked') {
+                setParentTaskFilterMode(state.parentTaskFilterMode);
+            }
+            if (state.sortBy === 'created' || state.sortBy === 'priority' || state.sortBy === 'updated' || state.sortBy === 'complexity')
+                setSortBy(state.sortBy);
+            if (state.sortOrder === 'asc' || state.sortOrder === 'desc')
+                setSortOrder(state.sortOrder);
+            if (typeof state.hasInitedFilters === 'boolean')
+                setHasInitedFilters(state.hasInitedFilters);
+            if (typeof state.showChecklist === 'boolean')
+                setShowChecklist(state.showChecklist);
+            if (typeof state.showTaskRelationships === 'boolean')
+                setShowTaskRelationships(state.showTaskRelationships);
+            if (typeof state.showChildTasks === 'boolean')
+                setShowChildTasks(state.showChildTasks);
+            if (typeof state.lastCategory === 'string')
+                setLastUsedCategory(state.lastCategory);
+            if (typeof state.exportEnvironment === 'string' && state.exportEnvironment.trim().length > 0) {
+                setExportEnvironment(state.exportEnvironment.trim());
+            }
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            setUiStateReady(true);
+        }
+    }, []);
+    useEffect(() => {
+        if (!uiStateReady)
+            return;
+        const timeoutId = window.setTimeout(async () => {
+            try {
+                await fetch('/api/taskforce/ui-state', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'include',
+                    body: JSON.stringify({
+                        stateKey: 'app',
+                        patch: {
+                            groupBy,
+                            emptyColumnMode,
+                            zenMode,
+                            searchQuery,
+                            filterCategories,
+                            filterPriorities,
+                            filterTypes,
+                            filterStatus,
+                            filterAssignees,
+                            filterTaxonomies,
+                            parentTaskFilterMode,
+                            sortBy,
+                            sortOrder,
+                            hasInitedFilters,
+                            showChecklist,
+                            showTaskRelationships,
+                            showChildTasks,
+                            lastCategory: lastUsedCategory || '',
+                            exportEnvironment
+                        }
+                    })
+                });
+            }
+            catch {
+                // ignore persistence errors
+            }
+        }, 250);
+        return () => window.clearTimeout(timeoutId);
+    }, [
+        uiStateReady,
+        groupBy,
+        emptyColumnMode,
+        zenMode,
+        searchQuery,
+        filterCategories,
+        filterPriorities,
+        filterTypes,
+        filterStatus,
+        filterAssignees,
+        filterTaxonomies,
+        parentTaskFilterMode,
+        sortBy,
+        sortOrder,
+        hasInitedFilters,
+        showChecklist,
+        showTaskRelationships,
+        showChildTasks,
+        lastUsedCategory,
+        exportEnvironment
+    ]);
+    // Fetch current config from server
+    const fetchConfig = useCallback(async (options) => {
+        const ignoreAuthGuard = options?.ignoreAuthGuard === true;
+        if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
+            return;
+        markBootstrapPhase('config');
+        try {
+            // Fetch core config
+            const res = await fetchWithTimeout('/api/taskforce/config', undefined, BOOTSTRAP_REQUEST_TIMEOUT_MS);
+            if (res.status === 401) {
+                handleUnauthorized();
+                setConfigLoaded(true);
+                return;
+            }
+            if (res.ok) {
+                const data = await res.json();
+                setRuntimeMode(data.runtimeMode === 'cloud' ? 'cloud' : 'local');
+                setAuthRequiredForApi(Boolean(data.authRequiredForApi));
+                if (typeof data.workspaceId === 'string' && data.workspaceId.trim().length > 0) {
+                    const nextWorkspaceId = data.workspaceId.trim();
+                    const nextRuntimeMode = data.runtimeMode === 'cloud' ? 'cloud' : 'local';
+                    if (nextRuntimeMode === 'local') {
+                        // Local runtime source of truth is server-resolved DB workspace identity.
+                        setCurrentWorkspaceId(nextWorkspaceId);
+                    }
+                    else {
+                        setCurrentWorkspaceId((prev) => {
+                            const prevValue = String(prev || '').trim();
+                            if (nextWorkspaceId === 'default' && prevValue && prevValue.toLowerCase() !== 'default') {
+                                return prevValue;
+                            }
+                            return nextWorkspaceId;
+                        });
+                    }
+                }
+                if (data.runtimeMode === 'cloud' && data.authRequiredForApi) {
+                    setAuthBlocked(!isAuthenticated);
+                }
+                else {
+                    setAuthBlocked(false);
+                }
+                if (data.setupState && typeof data.setupState === 'object') {
+                    setSetupState(data.setupState);
+                }
+                else {
+                    setSetupState(null);
+                }
+                if (data.runtimeCapabilities && typeof data.runtimeCapabilities === 'object') {
+                    setRuntimeCapabilities(data.runtimeCapabilities);
+                }
+                else {
+                    setRuntimeCapabilities(null);
+                }
+                setRealtimeSyncEnabled(Boolean(data.realtimeSyncEnabled));
+                const realtimeFlagSource = String(data.realtimeSyncFlagSource || '').trim().toLowerCase();
+                if (realtimeFlagSource === 'env' || realtimeFlagSource === 'settings' || realtimeFlagSource === 'default') {
+                    setRealtimeSyncFlagSource(realtimeFlagSource);
+                }
+                else {
+                    setRealtimeSyncFlagSource('unknown');
+                }
+                if (typeof data.shortcut === 'string' && data.shortcut.trim().length > 0) {
+                    setKeyShortcut(data.shortcut);
+                }
+                if (data.theme === 'dark' || data.theme === 'light' || data.theme === 'midnight') {
+                    setCurrentTheme(data.theme);
+                }
+                if (data.globalTheme === 'dark' || data.globalTheme === 'light' || data.globalTheme === 'midnight') {
+                    setGlobalTheme(data.globalTheme);
+                }
+                if (typeof data.themeUseGlobalDefault === 'boolean') {
+                    setThemeUseGlobalDefault(data.themeUseGlobalDefault);
+                }
+                if (data.projectRoot) {
+                    setProjectRoot(data.projectRoot);
+                }
+                if (typeof data.tenantId === 'string' && data.tenantId.trim().length > 0) {
+                    setTenantId(data.tenantId.trim());
+                }
+                const resolvedRuntimeMode = data.runtimeMode === 'cloud' ? 'cloud' : 'local';
+                const detectedProjectName = resolvedRuntimeMode === 'cloud'
+                    ? String(data.projectName || '').trim()
+                    : (data.projectName || data.paths?.projectName || '');
+                if (String(detectedProjectName || '').trim().length > 0 || resolvedRuntimeMode === 'cloud') {
+                    setProjectName(detectedProjectName);
+                }
+                if (data.mcpScript) {
+                    setMcpScriptPath(data.mcpScript);
+                }
+                if (data.hostRoot) {
+                    setServerHostRoot(data.hostRoot);
+                }
+                if (typeof data.jsonBackupEnabled === 'boolean') {
+                    setJsonBackupEnabled(data.jsonBackupEnabled);
+                }
+                if (typeof data.globalJsonBackupEnabled === 'boolean') {
+                    setGlobalJsonBackupEnabled(data.globalJsonBackupEnabled);
+                }
+                if (typeof data.jsonBackupUseGlobalDefault === 'boolean') {
+                    setJsonBackupUseGlobalDefault(data.jsonBackupUseGlobalDefault);
+                }
+                const configuredWeekStartsOn = data?.schedulePreferences?.weekStartsOn;
+                if (configuredWeekStartsOn === 'sunday' || configuredWeekStartsOn === 'monday') {
+                    setGlobalWeekStartsOn(configuredWeekStartsOn);
+                }
+                if (typeof data.manualComplexityEnabled === 'boolean') {
+                    setManualComplexityEnabled(data.manualComplexityEnabled);
+                }
+                if (typeof data.checklistDropdownEnabled === 'boolean') {
+                    setChecklistDropdownEnabled(data.checklistDropdownEnabled);
+                }
+                else {
+                    setChecklistDropdownEnabled(false);
+                }
+                if (typeof data.assigneeFilterEnabled === 'boolean') {
+                    setAssigneeFilterEnabled(data.assigneeFilterEnabled);
+                }
+                else {
+                    setAssigneeFilterEnabled(false);
+                }
+            }
+            // Fetch deployment/build metadata (best effort)
+            try {
+                const versionRes = await fetchWithTimeout('/api/taskforce/version', undefined, BOOTSTRAP_REQUEST_TIMEOUT_MS);
+                if (versionRes.ok) {
+                    const versionData = await versionRes.json().catch(() => ({}));
+                    if (versionData?.build && typeof versionData.build === 'object') {
+                        setBuildInfo({
+                            version: String(versionData.build.version || ''),
+                            gitSha: versionData.build.gitSha ? String(versionData.build.gitSha) : null,
+                            buildTime: versionData.build.buildTime ? String(versionData.build.buildTime) : null,
+                            deployId: versionData.build.deployId ? String(versionData.build.deployId) : null
+                        });
+                    }
+                }
+            }
+            catch (versionError) {
+                if (isBootstrapTimeoutError(versionError)) {
+                    markBootstrapStalled('Startup checks timed out.');
+                }
+                // ignore build-info errors
+            }
+            // Fetch categories
+            const catRes = await fetch('/api/taskforce/categories');
+            if (catRes.ok) {
+                const catData = await catRes.json();
+                if (catData.categories && catData.categories.length > 0) {
+                    // Map to config objects if they come back as strings
+                    const mapped = catData.categories.map((c) => typeof c === 'string' ? { value: c.toLowerCase().replace(/\s+/g, '-'), label: c } : c);
+                    setCustomCategories(mapped);
+                }
+            }
+            // Fetch types
+            const typeRes = await fetch('/api/taskforce/types');
+            if (typeRes.ok) {
+                const typeData = await typeRes.json();
+                if (typeData.types && typeData.types.length > 0) {
+                    setCustomTypes(typeData.types);
+                }
+            }
+            // Fetch priorities
+            const priorityRes = await fetch('/api/taskforce/priorities');
+            if (priorityRes.ok) {
+                const priorityData = await priorityRes.json();
+                if (priorityData.priorities)
+                    setPriorities(priorityData.priorities);
+            }
+            // Fetch templates
+            const templateRes = await fetch('/api/taskforce/workflow-templates');
+            if (templateRes.ok) {
+                const templateData = await templateRes.json();
+                if (templateData.templates)
+                    setAvailableWorkflows(templateData.templates);
+            }
+            // Fetch initiative templates
+            await fetchInitiativeTemplates();
+            // Fetch environments
+            const envRes = await fetch('/api/taskforce/environments');
+            if (envRes.ok) {
+                const envData = await envRes.json();
+                if (envData.environments)
+                    setAvailableEnvironments(envData.environments);
+            }
+            // Fetch approaches
+            const approachRes = await fetch('/api/taskforce/approaches');
+            if (approachRes.ok) {
+                const approachData = await approachRes.json();
+                if (approachData.approaches)
+                    setApproaches(approachData.approaches);
+            }
+            // Fetch generic taxonomies
+            const taxRes = await fetch('/api/taskforce/taxonomies');
+            if (taxRes.ok) {
+                const taxData = await taxRes.json();
+                if (taxData.taxonomies) {
+                    setTaxonomies(taxData.taxonomies);
+                }
+            }
+            // Fetch specialists
+            const specialistRes = await fetch('/api/taskforce/specialists');
+            if (specialistRes.ok) {
+                const specialistData = await specialistRes.json();
+                if (specialistData.specialists) {
+                    setAvailableSpecialists(specialistData.specialists);
+                }
+            }
+            if (!hasLoadedUiStateRef.current) {
+                hasLoadedUiStateRef.current = true;
+                await loadPersistedUiState();
+            }
+            // Mark config as loaded (even if some fetches failed)
+            setConfigLoaded(true);
+            markBootstrapPhase('ready');
+        }
+        catch (error) {
+            if (!hasLoadedUiStateRef.current) {
+                hasLoadedUiStateRef.current = true;
+                await loadPersistedUiState();
+            }
+            if (isBootstrapTimeoutError(error)) {
+                markBootstrapStalled('Startup checks timed out.');
+            }
+            else {
+                markBootstrapStalled('Unable to finish startup checks.');
+            }
+            // Still mark as loaded so we can use default config
+            setConfigLoaded(true);
+        }
+    }, [
+        currentWorkspaceId,
+        fetchWithTimeout,
+        fetchInitiativeTemplates,
+        handleUnauthorized,
+        isAuthenticated,
+        isBootstrapTimeoutError,
+        loadPersistedUiState,
+        markBootstrapPhase,
+        markBootstrapStalled,
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls
+    ]);
+    const refreshSetupContext = useCallback(async () => {
+        await checkAuthSession();
+        await fetchConfig();
+    }, [checkAuthSession, fetchConfig]);
+    const fetchWorkspaces = useCallback(async () => {
+        if (!workspaceSwitchingEnabled) {
+            setAvailableWorkspaces([]);
+            return { success: true, workspaces: [] };
+        }
+        try {
+            const res = await fetchWithTimeout('/api/taskforce/workspaces', {
+                method: 'GET',
+                credentials: 'include'
+            }, BOOTSTRAP_REQUEST_TIMEOUT_MS);
+            if (res.status === 401) {
+                setAvailableWorkspaces([]);
+                return { success: false, error: 'Authentication required.' };
+            }
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                setAvailableWorkspaces([]);
+                return { success: false, error: data?.error || `Failed to load workspaces (${res.status})` };
+            }
+            const workspaces = Array.isArray(data?.workspaces) ? data.workspaces : [];
+            setAvailableWorkspaces(workspaces);
+            if (runtimeMode !== 'local' && typeof data?.currentWorkspaceId === 'string' && data.currentWorkspaceId.trim().length > 0) {
+                const nextWorkspaceId = data.currentWorkspaceId.trim();
+                setCurrentWorkspaceId((prev) => {
+                    const prevValue = String(prev || '').trim();
+                    if (nextWorkspaceId === 'default' && prevValue && prevValue.toLowerCase() !== 'default')
+                        return prevValue;
+                    return nextWorkspaceId;
+                });
+            }
+            return { success: true, workspaces };
+        }
+        catch (error) {
+            if (isBootstrapTimeoutError(error)) {
+                markBootstrapStalled('Startup checks timed out.');
+            }
+            setAvailableWorkspaces([]);
+            return { success: false, error: 'Failed to load workspaces.' };
+        }
+    }, [
+        fetchWithTimeout,
+        isBootstrapTimeoutError,
+        markBootstrapStalled,
+        runtimeMode,
+        workspaceStorageScope,
+        workspaceSwitchingEnabled
+    ]);
+    const switchWorkspace = useCallback(async (workspaceId, options) => {
+        if (!workspaceSwitchingEnabled) {
+            return { success: false, error: 'Workspace switching is unavailable in local mode.', code: 'WORKSPACE_SWITCHING_DISABLED' };
+        }
+        const normalizedWorkspaceId = String(workspaceId || '').trim();
+        if (!normalizedWorkspaceId)
+            return { success: false, error: 'workspaceId is required.' };
+        try {
+            const res = await fetch('/api/taskforce/session/workspace', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ workspaceId: normalizedWorkspaceId })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                return { success: false, error: data?.error || `Failed to switch workspace (${res.status})`, code: data?.code };
+            }
+            await checkAuthSession();
+            if (options?.hydrate === false) {
+                await fetchWorkspaces();
+            }
+            else {
+                await Promise.all([fetchConfig(), fetchWorkspaces()]);
+            }
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Failed to switch workspace.' };
+        }
+    }, [checkAuthSession, fetchConfig, fetchWorkspaces, workspaceSwitchingEnabled]);
+    const resolveWorkspaceAfterAuth = useCallback(async (options) => {
+        markBootstrapPhase('workspace');
+        setWorkspaceBootstrapPending(true);
+        try {
+            if (!workspaceSwitchingEnabled) {
+                const localWorkspaceId = String(currentWorkspaceId || '').trim() || 'default';
+                setCurrentWorkspaceId(localWorkspaceId);
+                return { success: true, workspaceSetupRequired: false, workspaceId: localWorkspaceId };
+            }
+            const preferredWorkspaceId = String(options?.preferredWorkspaceId || '').trim();
+            const persistedWorkspaceId = readPersistedWorkspaceId(workspaceStorageScope);
+            const workspacesResult = await fetchWorkspaces();
+            if (!workspacesResult.success) {
+                return {
+                    success: false,
+                    workspaceSetupRequired: false,
+                    error: workspacesResult.error || 'Failed to load workspaces after authentication.'
+                };
+            }
+            const workspaces = Array.isArray(workspacesResult.workspaces) ? workspacesResult.workspaces : [];
+            if (workspaces.length === 0) {
+                setCurrentWorkspaceId('default');
+                return { success: true, workspaceSetupRequired: true };
+            }
+            const ids = new Set(workspaces.map((workspace) => String(workspace.id || '').trim()).filter(Boolean));
+            const selectedWorkspaceId = ((preferredWorkspaceId && ids.has(preferredWorkspaceId) ? preferredWorkspaceId : '')
+                || (persistedWorkspaceId && ids.has(persistedWorkspaceId) ? persistedWorkspaceId : '')
+                || String(workspaces[0]?.id || '').trim());
+            if (!selectedWorkspaceId) {
+                setCurrentWorkspaceId('default');
+                return { success: true, workspaceSetupRequired: true };
+            }
+            const current = String(currentWorkspaceId || '').trim();
+            if (current !== selectedWorkspaceId) {
+                const switched = await switchWorkspace(selectedWorkspaceId, { hydrate: false });
+                if (!switched.success) {
+                    return {
+                        success: false,
+                        workspaceSetupRequired: false,
+                        error: switched.error || 'Failed to set workspace after authentication.',
+                        code: switched.code
+                    };
+                }
+            }
+            else {
+                setCurrentWorkspaceId(selectedWorkspaceId);
+            }
+            return { success: true, workspaceSetupRequired: false, workspaceId: selectedWorkspaceId };
+        }
+        catch {
+            markBootstrapStalled('Unable to resolve workspace access.');
+            return { success: false, workspaceSetupRequired: false, error: 'Failed to resolve workspace access.' };
+        }
+        finally {
+            setWorkspaceBootstrapPending(false);
+        }
+    }, [
+        currentWorkspaceId,
+        fetchWorkspaces,
+        markBootstrapPhase,
+        markBootstrapStalled,
+        switchWorkspace,
+        workspaceStorageScope,
+        workspaceSwitchingEnabled
+    ]);
+    const retryBootstrapChecks = useCallback(async () => {
+        setBootstrapError(null);
+        markBootstrapPhase('auth');
+        const authenticated = await checkAuthSession();
+        if (workspaceSwitchingEnabled && authenticated) {
+            const workspaceResolution = await resolveWorkspaceAfterAuth();
+            if (!workspaceResolution.success || workspaceResolution.workspaceSetupRequired) {
+                await fetchConfig({ ignoreAuthGuard: true });
+                return;
+            }
+        }
+        await fetchConfig({ ignoreAuthGuard: true });
+    }, [
+        checkAuthSession,
+        fetchConfig,
+        markBootstrapPhase,
+        resolveWorkspaceAfterAuth,
+        workspaceSwitchingEnabled
+    ]);
+    const createWorkspace = useCallback(async (name, description) => {
+        if (!workspaceSwitchingEnabled) {
+            return { success: false, error: 'Workspace management is unavailable in local mode.', code: 'WORKSPACE_MANAGEMENT_DISABLED' };
+        }
+        const trimmedName = String(name || '').trim();
+        if (!trimmedName)
+            return { success: false, error: 'Workspace name is required.' };
+        try {
+            const res = await fetch('/api/taskforce/workspaces', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({
+                    name: trimmedName,
+                    description: typeof description === 'string' ? description : undefined
+                })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                return { success: false, error: data?.error || `Failed to create workspace (${res.status})`, code: data?.code };
+            }
+            const workspace = data?.workspace;
+            await fetchWorkspaces();
+            if (workspace?.id) {
+                const switched = await switchWorkspace(workspace.id);
+                if (!switched.success) {
+                    return { success: false, error: switched.error || 'Workspace created but failed to activate.', code: switched.code };
+                }
+            }
+            return { success: true, workspace };
+        }
+        catch {
+            return { success: false, error: 'Failed to create workspace.' };
+        }
+    }, [fetchWorkspaces, switchWorkspace, workspaceSwitchingEnabled]);
+    const deleteWorkspace = useCallback(async (workspaceId) => {
+        if (!workspaceSwitchingEnabled) {
+            return { success: false, error: 'Workspace management is unavailable in local mode.', code: 'WORKSPACE_MANAGEMENT_DISABLED' };
+        }
+        const normalizedWorkspaceId = String(workspaceId || '').trim();
+        if (!normalizedWorkspaceId)
+            return { success: false, error: 'workspaceId is required.', code: 'WORKSPACE_ID_REQUIRED' };
+        try {
+            const res = await fetch(`/api/taskforce/workspaces/${encodeURIComponent(normalizedWorkspaceId)}`, {
+                method: 'DELETE',
+                credentials: 'include'
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                return { success: false, error: data?.error || `Failed to delete workspace (${res.status})`, code: data?.code };
+            }
+            await checkAuthSession();
+            await Promise.all([fetchConfig(), fetchWorkspaces()]);
+            const nextWorkspaceId = typeof data?.nextWorkspaceId === 'string' ? data.nextWorkspaceId.trim() : '';
+            if (nextWorkspaceId) {
+                setCurrentWorkspaceId(nextWorkspaceId);
+            }
+            return {
+                success: true,
+                nextWorkspaceId: nextWorkspaceId || undefined,
+                workspaceSetupRequired: data?.workspaceSetupRequired === true,
+                cleanupWarnings: Array.isArray(data?.cleanupWarnings) ? data.cleanupWarnings.map((item) => String(item || '')) : []
+            };
+        }
+        catch {
+            return { success: false, error: 'Failed to delete workspace.' };
+        }
+    }, [checkAuthSession, fetchConfig, fetchWorkspaces, workspaceSwitchingEnabled]);
+    const saveSetupMode = useCallback(async (mode) => {
+        const nextMode = mode === 'operations' ? 'operations' : 'core';
+        try {
+            const res = await fetch('/api/taskforce/global-settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ setup: { mode: nextMode } })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false)
+                return false;
+            await refreshSetupContext();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, [refreshSetupContext]);
+    const saveWorkspaceProfile = useCallback(async (input) => {
+        const name = String(input?.name || '').trim();
+        if (!name)
+            return { success: false, error: 'Workspace name is required.', code: 'WORKSPACE_NAME_REQUIRED' };
+        try {
+            const res = await fetch('/api/taskforce/workspace-profile', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-taskforce-runtime-mode': runtimeMode
+                },
+                credentials: 'include',
+                body: JSON.stringify({
+                    workspaceId: input.workspaceId,
+                    name,
+                    description: typeof input.description === 'string' ? input.description : undefined,
+                    allowCreate: true
+                })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                return { success: false, error: data?.error || `Failed to save workspace (${res.status})`, code: data?.code };
+            }
+            const savedWorkspaceId = String(data?.workspace?.id || '').trim();
+            if (savedWorkspaceId) {
+                setCurrentWorkspaceId(savedWorkspaceId);
+                await new Promise((resolve) => window.setTimeout(resolve, 0));
+                if (runtimeMode === 'cloud' && isAuthenticated && savedWorkspaceId !== currentWorkspaceId) {
+                    const switched = await switchWorkspace(savedWorkspaceId);
+                    if (!switched.success) {
+                        return {
+                            success: false,
+                            error: switched.error || 'Workspace saved but failed to activate session workspace.',
+                            code: 'WORKSPACE_SWITCH_FAILED'
+                        };
+                    }
+                }
+            }
+            await refreshSetupContext();
+            return { success: true, workspaceId: savedWorkspaceId || undefined };
+        }
+        catch {
+            return { success: false, error: 'Failed to save workspace profile.' };
+        }
+    }, [refreshSetupContext, runtimeMode, isAuthenticated, currentWorkspaceId, switchWorkspace]);
+    // Fetch tasks
+    const fetchTasks = useCallback(async (isSilent = false, options) => {
+        const ignoreAuthGuard = options?.ignoreAuthGuard === true;
+        if (!ignoreAuthGuard && (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls))
+            return;
+        if (!isSilent)
+            setLoadingTasks(true);
+        try {
+            const res = await fetch('/api/taskforce/tasks');
+            if (res.status === 401) {
+                handleUnauthorized();
+                setTasks([]);
+                if (!isSilent)
+                    setLoadingTasks(false);
+                return;
+            }
+            if (res.ok) {
+                const data = await res.json();
+                const sanitized = (data.tasks || []).map((t) => normalizeTaskFromApi(t, { mapLegacyTodoStatus: true }));
+                const nextRevisionMap = new Map();
+                const changedTaskIds = [];
+                for (const task of sanitized) {
+                    const revision = getTaskRevisionKey(task);
+                    nextRevisionMap.set(task.id, revision);
+                    if (!hasFetchedTasksRef.current)
+                        continue;
+                    const previousRevision = taskRevisionMapRef.current.get(task.id);
+                    if (!previousRevision || previousRevision !== revision) {
+                        changedTaskIds.push(task.id);
+                    }
+                }
+                taskRevisionMapRef.current = nextRevisionMap;
+                if (hasFetchedTasksRef.current) {
+                    markRecentlyChangedTasks(changedTaskIds);
+                }
+                else {
+                    hasFetchedTasksRef.current = true;
+                }
+                setTasks(sanitized);
+            }
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to fetch tasks:', err);
+        }
+        if (!isSilent)
+            setLoadingTasks(false);
+    }, [
+        getTaskRevisionKey,
+        markRecentlyChangedTasks,
+        handleUnauthorized,
+        authRequiredForApi,
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls
+    ]);
+    const loginWithCredentials = useCallback(async (email, password) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedEmail = email.trim().toLowerCase();
+        const rawPassword = password;
+        if (!trimmedEmail || !rawPassword) {
+            return { success: false, error: 'Email and password are required.' };
+        }
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/login'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ email: trimmedEmail, password: rawPassword })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Sign in failed.', code: data?.code };
+            }
+            setError('');
+            await checkAuthSession();
+            const workspaceResolution = await resolveWorkspaceAfterAuth();
+            if (!workspaceResolution.success) {
+                return {
+                    success: false,
+                    error: workspaceResolution.error || 'Unable to resolve workspace after sign in.',
+                    code: workspaceResolution.code
+                };
+            }
+            if (workspaceResolution.workspaceSetupRequired) {
+                return { success: true, workspaceSetupRequired: true };
+            }
+            await Promise.all([
+                fetchConfig({ ignoreAuthGuard: true }),
+                fetchTasks(true, { ignoreAuthGuard: true })
+            ]);
+            void syncUserGlobalSettings({ preferCloudOnFirstSync: true });
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Sign in failed.' };
+        }
+    }, [checkAuthSession, fetchConfig, fetchTasks, resolveWorkspaceAfterAuth, syncUserGlobalSettings, resolveCloudAuthUrl, cloudAuthConfigured]);
+    const registerWithCredentials = useCallback(async (email, password) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedEmail = email.trim().toLowerCase();
+        const rawPassword = password;
+        if (!trimmedEmail || !rawPassword) {
+            return { success: false, error: 'Email and password are required.' };
+        }
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/register'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ email: trimmedEmail, password: rawPassword })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Create account failed.', code: data?.code };
+            }
+            return {
+                success: true,
+                workspaceSetupRequired: Boolean(data?.workspaceSetupRequired),
+                verificationRequired: Boolean(data?.verificationRequired),
+                verificationToken: typeof data?.verificationToken === 'string' ? data.verificationToken : undefined,
+                emailSent: data?.emailSent !== false,
+                emailError: typeof data?.emailError === 'string' ? data.emailError : undefined
+            };
+        }
+        catch {
+            return { success: false, error: 'Create account failed.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const requestEmailVerification = useCallback(async (email) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedEmail = email.trim().toLowerCase();
+        if (!trimmedEmail)
+            return { success: false, error: 'Email is required.' };
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/verify-email/request'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ email: trimmedEmail })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Failed to request verification email.', code: data?.code };
+            }
+            return {
+                success: true,
+                verificationToken: data?.verificationToken ?? null,
+                emailSent: data?.emailSent !== false,
+                emailError: typeof data?.emailError === 'string' ? data.emailError : undefined
+            };
+        }
+        catch {
+            return { success: false, error: 'Failed to request verification email.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const confirmEmailVerification = useCallback(async (token) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedToken = token.trim();
+        if (!trimmedToken)
+            return { success: false, error: 'Token is required.' };
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/verify-email/confirm'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ token: trimmedToken })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Verification failed.', code: data?.code };
+            }
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Verification failed.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const requestPasswordReset = useCallback(async (email) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedEmail = email.trim().toLowerCase();
+        if (!trimmedEmail)
+            return { success: false, error: 'Email is required.' };
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/password-reset/request'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ email: trimmedEmail })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Failed to request password reset.', code: data?.code };
+            }
+            return {
+                success: true,
+                resetToken: data?.resetToken ?? null,
+                emailSent: data?.emailSent !== false,
+                emailError: typeof data?.emailError === 'string' ? data.emailError : undefined
+            };
+        }
+        catch {
+            return { success: false, error: 'Failed to request password reset.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const confirmPasswordReset = useCallback(async (token, password) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedToken = token.trim();
+        const rawPassword = password;
+        if (!trimmedToken || !rawPassword) {
+            return { success: false, error: 'Token and password are required.' };
+        }
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/password-reset/confirm'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ token: trimmedToken, password: rawPassword })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Failed to reset password.', code: data?.code };
+            }
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Failed to reset password.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const inspectInviteAcceptance = useCallback(async (token) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedToken = token.trim();
+        if (!trimmedToken)
+            return { success: false, error: 'Token is required.' };
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/invite/inspect'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ token: trimmedToken })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return {
+                    success: false,
+                    error: data?.error || 'Invite inspection failed.',
+                    code: data?.code,
+                    state: data?.state
+                };
+            }
+            return {
+                success: true,
+                state: data?.state,
+                email: typeof data?.email === 'string' ? data.email : undefined,
+                workspaceId: typeof data?.workspaceId === 'string' ? data.workspaceId : undefined
+            };
+        }
+        catch {
+            return { success: false, error: 'Invite inspection failed.' };
+        }
+    }, [resolveCloudAuthUrl, cloudAuthConfigured]);
+    const acceptInviteWithToken = useCallback(async (token, password) => {
+        if (!cloudAuthConfigured) {
+            return { success: false, error: 'Cloud auth endpoint is not configured.' };
+        }
+        const trimmedToken = token.trim();
+        const rawPassword = password;
+        if (!trimmedToken || !rawPassword) {
+            return { success: false, error: 'Token and password are required.' };
+        }
+        try {
+            const res = await fetch(resolveCloudAuthUrl('/api/taskforce/auth/invite/accept'), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ token: trimmedToken, password: rawPassword })
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || 'Invite acceptance failed.', code: data?.code };
+            }
+            setError('');
+            await checkAuthSession();
+            const preferredWorkspaceId = typeof data?.workspaceId === 'string' ? data.workspaceId : null;
+            const workspaceResolution = await resolveWorkspaceAfterAuth({ preferredWorkspaceId });
+            if (!workspaceResolution.success) {
+                return {
+                    success: false,
+                    error: workspaceResolution.error || 'Unable to resolve workspace after invite acceptance.',
+                    code: workspaceResolution.code
+                };
+            }
+            if (workspaceResolution.workspaceSetupRequired) {
+                return { success: true, workspaceSetupRequired: true };
+            }
+            await Promise.all([
+                fetchConfig({ ignoreAuthGuard: true }),
+                fetchTasks(true, { ignoreAuthGuard: true })
+            ]);
+            void syncUserGlobalSettings({ preferCloudOnFirstSync: true });
+            return { success: true };
+        }
+        catch {
+            return { success: false, error: 'Invite acceptance failed.' };
+        }
+    }, [checkAuthSession, fetchConfig, fetchTasks, resolveWorkspaceAfterAuth, syncUserGlobalSettings, resolveCloudAuthUrl, cloudAuthConfigured]);
+    const logout = useCallback(async () => {
+        try {
+            if (cloudAuthConfigured) {
+                await fetch(resolveCloudAuthUrl('/api/taskforce/auth/logout'), {
+                    method: 'POST',
+                    credentials: 'include'
+                });
+            }
+        }
+        catch {
+            // no-op
+        }
+        finally {
+            setIsAuthenticated(false);
+            setAuthUserId('anonymous');
+            setAuthUserEmail('');
+            setUserGlobalSyncStatus('disconnected');
+            setUserGlobalSyncPendingChanges(0);
+            setUserGlobalSyncError(null);
+            setAuthBlocked(runtimeMode === 'cloud' && authRequiredForApi);
+            setCurrentWorkspaceId((prev) => {
+                const existing = String(prev || '').trim();
+                if (existing && existing.toLowerCase() !== 'default')
+                    return existing;
+                if (runtimeMode === 'local')
+                    return 'default';
+                return readPersistedWorkspaceId(workspaceStorageScope) || 'default';
+            });
+            setAvailableWorkspaces([]);
+            setTasks([]);
+        }
+    }, [authRequiredForApi, resolveCloudAuthUrl, cloudAuthConfigured, workspaceStorageScope, runtimeMode]);
+    const createInitiativeFromTemplate = useCallback(async (payload) => {
+        try {
+            const res = await fetch('/api/taskforce/initiative-templates/create', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || `Create failed (${res.status})` };
+            }
+            await fetchTasks(true);
+            return { success: true, result: data?.results };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [fetchTasks]);
+    const cloneChecklistBlocksToChildren = useCallback(async (payload) => {
+        try {
+            const res = await fetch('/api/taskforce/initiative-templates/clone-checklists', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || !data?.success) {
+                return { success: false, error: data?.error || `Clone failed (${res.status})` };
+            }
+            await fetchTasks(true);
+            return { success: true, updated: Number(data?.results?.updated || 0) };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }, [fetchTasks]);
+    // Initialize auth once, then bootstrap protected data once auth gates are settled.
+    const hasInitializedAuthRef = useRef(false);
+    const hasBootstrappedDataRef = useRef(false);
+    useEffect(() => {
+        setIsOpen(true); // Always open in standalone-first
+        if (hasInitializedAuthRef.current)
+            return;
+        hasInitializedAuthRef.current = true;
+        checkAuthSession();
+    }, [checkAuthSession]);
+    useEffect(() => {
+        if (!runtimeConfigReady)
+            return;
+        void checkAuthSession();
+    }, [runtimeConfigReady, checkAuthSession]);
+    // Keep local runtime auth state aligned with cloud session changes
+    // (e.g. user signs in/out in another tab or cloud-hosted app).
+    useEffect(() => {
+        if (runtimeMode !== 'local' || !shouldProbeCloudAuth)
+            return;
+        if (typeof window === 'undefined')
+            return;
+        const recheck = () => { void checkAuthSession(); };
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'visible')
+                recheck();
+        };
+        window.addEventListener('focus', recheck);
+        window.addEventListener('online', recheck);
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        const intervalId = window.setInterval(recheck, 30_000);
+        return () => {
+            window.removeEventListener('focus', recheck);
+            window.removeEventListener('online', recheck);
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+            window.clearInterval(intervalId);
+        };
+    }, [runtimeMode, shouldProbeCloudAuth, checkAuthSession]);
+    useEffect(() => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        if (hasBootstrappedDataRef.current)
+            return;
+        hasBootstrappedDataRef.current = true;
+        void (async () => {
+            fetchWorkflows();
+            if (runtimeMode === 'cloud' && authSessionResolved && isAuthenticated) {
+                const workspaceResolution = await resolveWorkspaceAfterAuth();
+                if (!workspaceResolution.success || workspaceResolution.workspaceSetupRequired) {
+                    await fetchConfig();
+                    return;
+                }
+            }
+            await fetchConfig();
+            await fetchTasks();
+        })();
+    }, [
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls,
+        runtimeMode,
+        authSessionResolved,
+        isAuthenticated,
+        resolveWorkspaceAfterAuth,
+        fetchConfig,
+        fetchWorkflows,
+        fetchTasks
+    ]);
+    useEffect(() => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        if (workspaceStorageScope === WORKSPACE_BOOTSTRAP_SCOPE)
+            return;
+        if (!hasBootstrappedDataRef.current)
+            return;
+        void fetchConfig();
+    }, [
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls,
+        workspaceStorageScope,
+        fetchConfig
+    ]);
+    useEffect(() => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        void loadWorkspaceSyncState();
+    }, [shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls, currentWorkspaceId, loadWorkspaceSyncState]);
+    useEffect(() => {
+        if (runtimeMode !== 'cloud' || !authSessionResolved || !isAuthenticated) {
+            if (runtimeMode !== 'cloud') {
+                setAvailableWorkspaces([]);
+            }
+            return;
+        }
+        fetchWorkspaces();
+    }, [runtimeMode, authSessionResolved, isAuthenticated, fetchWorkspaces]);
+    // Report task count to parent
+    useEffect(() => {
+        if (onTaskCountChange) {
+            onTaskCountChange(tasks.length);
+        }
+    }, [tasks.length, onTaskCountChange]);
+    // Deep linking handler
+    useEffect(() => {
+        if (initialTaskId && tasks.length > 0) {
+            const task = tasks.find(t => t.id.endsWith(initialTaskId) || t.id === initialTaskId);
+            if (task) {
+                handleEdit(task);
+                setActiveTab('add');
+            }
+        }
+    }, [initialTaskId, tasks]);
+    // Update active category logic
+    const hasInitedCategoryRef = useRef(false);
+    useEffect(() => {
+        if (!configLoaded)
+            return;
+        if (!hasInitedCategoryRef.current && activeCategories.length > 0) {
+            hasInitedCategoryRef.current = true;
+            const lastCat = lastUsedCategory;
+            const lastCatExists = activeCategories.some(c => c.label === lastCat || c.value === lastCat);
+            if (lastCat && lastCatExists) {
+                const found = activeCategories.find(c => c.label === lastCat || c.value === lastCat);
+                setCategory(found?.value || lastCat);
+            }
+            else {
+                setCategory(getPreferredCategoryValue(activeCategories));
+            }
+            return;
+        }
+        const categoryExists = activeCategories.some(c => c.value === category);
+        if (activeCategories.length > 0 && !categoryExists) {
+            setCategory(getPreferredCategoryValue(activeCategories));
+        }
+    }, [configLoaded, activeCategories, category, getPreferredCategoryValue, lastUsedCategory]);
+    // Sanitize tasks with invalid categories
+    useEffect(() => {
+        if (!configLoaded || activeCategories.length === 0)
+            return;
+        const needsSanitization = (t) => {
+            return !activeCategories.some(c => c.value === t.category);
+        };
+        const invalidTasks = tasks.some(needsSanitization);
+        const invalidArchived = archivedTasks.some(needsSanitization);
+        if (invalidTasks || invalidArchived) {
+            const defaultCategory = getPreferredCategoryValue(activeCategories);
+            // console.warn(`[Taskforce] Found tasks with invalid categories, using "${defaultCategory}"`);
+            if (invalidTasks) {
+                setTasks(prev => prev.map(t => needsSanitization(t) ? { ...t, category: defaultCategory } : t));
+            }
+            if (invalidArchived) {
+                setArchivedTasks(prev => prev.map(t => needsSanitization(t) ? { ...t, category: defaultCategory } : t));
+            }
+        }
+    }, [configLoaded, activeCategories, tasks, archivedTasks, getPreferredCategoryValue]);
+    // Fetch archive
+    const fetchArchive = useCallback(async (isSilent = false) => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        try {
+            const res = await fetch('/api/taskforce/archive');
+            if (res.ok) {
+                const data = await res.json();
+                const sanitized = (data.archived || []).map((t) => ({
+                    ...normalizeTaskFromApi(t),
+                    isArchived: true
+                }));
+                setArchivedTasks(sanitized);
+            }
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to fetch archive:', err);
+        }
+    }, [shouldDeferProtectedApiCalls, shouldBlockProtectedApiCalls]);
+    // HMR Listener for Real-Time Updates
+    useEffect(() => {
+        if (import.meta.hot) {
+            import.meta.hot.on('taskforce:update', () => {
+                // console.log('[Taskforce] Received HMR update, refreshing data...');
+                fetchTasks(true);
+                fetchArchive(true);
+            });
+        }
+    }, [fetchTasks, fetchArchive]);
+    useEffect(() => {
+        return () => {
+            if (typeof window === 'undefined')
+                return;
+            highlightTimersRef.current.forEach((timerId) => window.clearTimeout(timerId));
+            highlightTimersRef.current.clear();
+        };
+    }, []);
+    // Fallback sync for cross-process writes (e.g., MCP tools) that may miss watcher/websocket events.
+    useEffect(() => {
+        if (typeof window === 'undefined' || typeof document === 'undefined')
+            return;
+        if (shouldSkipDataVersionPolling({
+            isOpen,
+            authBlocked,
+            authRequiredForApi,
+            isAuthenticated,
+            canCallProtectedApi: authGuardPolicy.canCallProtectedApi
+        }))
+            return;
+        let cancelled = false;
+        const checkDataVersion = async () => {
+            if (cancelled || document.visibilityState !== 'visible' || syncInFlightRef.current)
+                return;
+            if (shouldSkipDataVersionTick({
+                shouldGateProtectedApiCalls,
+                authSessionResolved: authSessionResolvedRef.current,
+                authRequiredForApi: authRequiredForApiRef.current,
+                isAuthenticated: isAuthenticatedRef.current
+            }))
+                return;
+            syncInFlightRef.current = true;
+            try {
+                const res = await fetch('/api/taskforce/data-version');
+                if (!res.ok)
+                    return;
+                const data = await res.json();
+                const version = Number(data?.dataVersion);
+                if (!Number.isFinite(version))
+                    return;
+                if (dataVersionRef.current === null) {
+                    dataVersionRef.current = version;
+                    return;
+                }
+                if (version !== dataVersionRef.current) {
+                    dataVersionRef.current = version;
+                    await Promise.all([fetchTasks(true), fetchArchive(true)]);
+                }
+            }
+            catch {
+                // Keep polling best-effort and silent.
+            }
+            finally {
+                syncInFlightRef.current = false;
+            }
+        };
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                checkDataVersion();
+            }
+        };
+        const intervalId = window.setInterval(checkDataVersion, 3000);
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        checkDataVersion();
+        return () => {
+            cancelled = true;
+            window.clearInterval(intervalId);
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+        };
+    }, [
+        isOpen,
+        fetchTasks,
+        fetchArchive,
+        authBlocked,
+        authRequiredForApi,
+        isAuthenticated,
+        authGuardPolicy,
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls,
+        shouldGateProtectedApiCalls
+    ]);
+    // Toggle sort order
+    const toggleSortOrder = useCallback(() => {
+        setSortOrder(prev => prev === 'asc' ? 'desc' : 'asc');
+    }, []);
+    // Initialize filters once config is loaded
+    useEffect(() => {
+        if (!configLoaded)
+            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(ASSIGNEE_OPTIONS.map((opt) => opt.value));
+            const initialTaxFilters = {};
+            taxonomies.forEach(tax => {
+                initialTaxFilters[tax.id] = tax.options.map(o => o.value);
+            });
+            setFilterTaxonomies(initialTaxFilters);
+            setHasInitedFilters(true);
+        }
+    }, [configLoaded, activeCategories, activeTypes, priorities, taxonomies, hasInitedFilters]);
+    // Migration: Categorization labels -> values in filters
+    useEffect(() => {
+        if (!configLoaded || !hasInitedFilters || activeCategories.length === 0)
+            return;
+        const needsMigration = filterCategories.some(f => activeCategories.some(c => c.label === f && c.value !== f));
+        if (needsMigration) {
+            setFilterCategories(prev => migrateCategoryFilterLabels(prev, activeCategories));
+        }
+    }, [configLoaded, activeCategories, hasInitedFilters, filterCategories]);
+    // Migration: Legacy priority filters (0..4) and string/number mismatch -> current priority values
+    useEffect(() => {
+        if (!configLoaded || !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, hasInitedFilters, priorities, filterPriorities]);
+    const clearFilters = () => {
+        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(ASSIGNEE_OPTIONS.map((opt) => opt.value));
+        setParentTaskFilterMode('all');
+        const initialTaxFilters = {};
+        taxonomies.forEach(tax => {
+            initialTaxFilters[tax.id] = tax.options.map(o => o.value);
+        });
+        setFilterTaxonomies(initialTaxFilters);
+        setSortBy('created');
+        setSortOrder('desc');
+    };
+    const filteredTasks = useMemo(() => {
+        const parentTaskIdSet = new Set();
+        for (const task of tasks) {
+            if (task.parentTaskId)
+                parentTaskIdSet.add(task.parentTaskId);
+        }
+        for (const task of archivedTasks) {
+            if (task.parentTaskId)
+                parentTaskIdSet.add(task.parentTaskId);
+        }
+        return tasks.filter(t => {
+            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
+                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
+                t.id.toLowerCase().includes(searchQuery.toLowerCase()));
+            const matchCategory = !hasInitedFilters || filterCategories.includes(t.category);
+            const matchPriority = !hasInitedFilters || matchesPriorityFilter(t.priority, filterPriorities);
+            const matchType = !hasInitedFilters || filterTypes.includes(t.type || 'feature');
+            const matchStatus = !hasInitedFilters || filterStatus.includes(t.status);
+            const matchAssignee = !assigneeFilterEnabled || !hasInitedFilters || filterAssignees.includes((t.assignee || 'unassigned'));
+            const hasParent = Boolean(t.parentTaskId);
+            const hasChildren = parentTaskIdSet.has(t.id);
+            const matchParentFilter = parentTaskFilterMode === 'all'
+                ? true
+                : parentTaskFilterMode === 'parents'
+                    ? hasChildren
+                    : parentTaskFilterMode === 'linked'
+                        ? (hasParent || hasChildren)
+                        : (!hasParent && !hasChildren);
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    const taxDef = taxonomies.find(tax => tax.id === taxId);
+                    const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                    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 && matchParentFilter;
+        }).sort((a, b) => {
+            let comparison = 0;
+            if (sortBy === 'created')
+                comparison = new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+            else if (sortBy === 'updated') {
+                const aUpdated = a.updatedAt || a.createdAt;
+                const bUpdated = b.updatedAt || b.createdAt;
+                comparison = new Date(bUpdated).getTime() - new Date(aUpdated).getTime();
+            }
+            else if (sortBy === 'priority') {
+                const weightA = typeof a.priority === 'number' ? a.priority : (PRIORITY_LOGIC[a.priority] ?? 2);
+                const weightB = typeof b.priority === 'number' ? b.priority : (PRIORITY_LOGIC[b.priority] ?? 2);
+                if (weightA !== weightB)
+                    comparison = weightB - weightA;
+                else
+                    comparison = new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+            }
+            else if (sortBy === 'complexity') {
+                const complexityA = typeof a.complexity === 'number' ? a.complexity : 3;
+                const complexityB = typeof b.complexity === 'number' ? b.complexity : 3;
+                if (complexityA !== complexityB)
+                    comparison = complexityB - complexityA;
+                else
+                    comparison = new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+            }
+            else {
+                comparison = new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+            }
+            // Invert if ascending (default is usually descending for newest/priority)
+            // But we want 'asc' to mean literal "First" (Oldest, Low Priority) and 'desc' to mean "Last" (Newest, High Priority)
+            // Currently, 'newest' comparison is (b - a) which is DESCENDING (highest/newest time first).
+            // So if sortOrder is 'asc', we want to invert it.
+            return sortOrder === 'desc' ? comparison : -comparison;
+        });
+    }, [tasks, archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, assigneeFilterEnabled, filterTaxonomies, sortBy, sortOrder, hasInitedFilters, parentTaskFilterMode]);
+    const searchAgnosticTasks = useMemo(() => {
+        const parentTaskIdSet = new Set();
+        for (const task of tasks) {
+            if (task.parentTaskId)
+                parentTaskIdSet.add(task.parentTaskId);
+        }
+        for (const task of archivedTasks) {
+            if (task.parentTaskId)
+                parentTaskIdSet.add(task.parentTaskId);
+        }
+        return tasks.filter(t => {
+            const matchCategory = !hasInitedFilters || filterCategories.includes(t.category);
+            const matchPriority = !hasInitedFilters || matchesPriorityFilter(t.priority, filterPriorities);
+            const matchType = !hasInitedFilters || filterTypes.includes(t.type || 'feature');
+            const matchStatus = !hasInitedFilters || filterStatus.includes(t.status);
+            const matchAssignee = !assigneeFilterEnabled || !hasInitedFilters || filterAssignees.includes((t.assignee || 'unassigned'));
+            const hasParent = Boolean(t.parentTaskId);
+            const hasChildren = parentTaskIdSet.has(t.id);
+            const matchParentFilter = parentTaskFilterMode === 'all'
+                ? true
+                : parentTaskFilterMode === 'parents'
+                    ? hasChildren
+                    : parentTaskFilterMode === 'linked'
+                        ? (hasParent || hasChildren)
+                        : (!hasParent && !hasChildren);
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    const taxDef = taxonomies.find(tax => tax.id === taxId);
+                    const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                    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 && matchParentFilter;
+        });
+    }, [tasks, archivedTasks, filterCategories, filterPriorities, filterTypes, filterStatus, filterAssignees, assigneeFilterEnabled, filterTaxonomies, hasInitedFilters, taxonomies, parentTaskFilterMode]);
+    const filteredArchive = useMemo(() => {
+        const isAllCategoriesSelected = activeCategories.every(c => filterCategories.includes(c.value));
+        return archivedTasks.filter(t => {
+            const matchSearch = (t.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
+                (t.description?.toLowerCase() || '').includes(searchQuery.toLowerCase()) ||
+                t.id.toLowerCase().includes(searchQuery.toLowerCase()));
+            const matchCategory = !hasInitedFilters || isAllCategoriesSelected || filterCategories.includes(t.category);
+            const matchPriority = !hasInitedFilters || matchesPriorityFilter(t.priority, filterPriorities);
+            const matchType = !hasInitedFilters || filterTypes.includes(t.type || 'feature');
+            const matchAssignee = !assigneeFilterEnabled || !hasInitedFilters || filterAssignees.includes((t.assignee || 'unassigned'));
+            const matchTaxonomies = Object.entries(filterTaxonomies).every(([taxId, selectedValues]) => {
+                const taskValue = t.taxonomies?.[taxId];
+                if (!taskValue) {
+                    const taxDef = taxonomies.find(tax => tax.id === taxId);
+                    const isAllSelected = taxDef?.options.every((opt) => selectedValues.includes(opt.value)) ?? true;
+                    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) => {
+            const comparison = new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+            return sortBy === 'created' ? (sortOrder === 'desc' ? comparison : -comparison) : 0;
+        });
+    }, [archivedTasks, searchQuery, filterCategories, filterPriorities, filterTypes, filterAssignees, assigneeFilterEnabled, filterTaxonomies, sortBy, hasInitedFilters, activeCategories]);
+    const relationshipTasks = useMemo(() => {
+        const byId = new Map();
+        for (const task of archivedTasks)
+            byId.set(task.id, task);
+        for (const task of tasks)
+            byId.set(task.id, task);
+        return Array.from(byId.values());
+    }, [tasks, archivedTasks]);
+    const [collapsedCategories, setCollapsedCategories] = useState({});
+    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]);
+    // Load tasks when modal opens
+    useEffect(() => {
+        if (shouldDeferProtectedApiCalls || shouldBlockProtectedApiCalls)
+            return;
+        if (isOpen) {
+            if (activeTab === 'tasks') {
+                fetchTasks();
+                fetchArchive(true);
+            }
+            else if (activeTab === 'settings') {
+                fetchConfig();
+                if (settingsSection === 'commands' || settingsSection === 'resources') {
+                    fetchWorkflows();
+                }
+            }
+        }
+    }, [
+        isOpen,
+        activeTab,
+        settingsSection,
+        showArchive,
+        fetchTasks,
+        fetchArchive,
+        fetchConfig,
+        fetchWorkflows,
+        shouldDeferProtectedApiCalls,
+        shouldBlockProtectedApiCalls
+    ]);
+    const fetchFolders = useCallback(async (path = '') => {
+        try {
+            const res = await fetch(`/api/taskforce/folders?path=${encodeURIComponent(path)}`);
+            if (res.ok) {
+                const data = await res.json();
+                setFolders(data.folders || []);
+                setFiles(data.files || []);
+                setCurrentBrowsePath(path);
+            }
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to fetch folders:', err);
+        }
+    }, []);
+    const getCategoryPaths = useCallback((cat) => {
+        const paths = [];
+        if (cat.path) {
+            paths.push(cat.path);
+        }
+        if (cat.paths && cat.paths.length > 0) {
+            for (const p of cat.paths) {
+                if (!paths.includes(p)) {
+                    paths.push(p);
+                }
+            }
+        }
+        return paths;
+    }, []);
+    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);
+        }
+    }, []);
+    useEffect(() => {
+        if (activeTab === 'settings' && configLoaded) {
+            const allPaths = [];
+            activeCategories.forEach(cat => {
+                const catPaths = getCategoryPaths(cat);
+                catPaths.forEach(p => {
+                    if (!allPaths.includes(p))
+                        allPaths.push(p);
+                });
+            });
+            const pathsToValidate = allPaths.filter(p => !pathValidation[p]);
+            if (pathsToValidate.length > 0) {
+                validatePaths(pathsToValidate);
+            }
+        }
+    }, [activeTab, configLoaded, activeCategories, getCategoryPaths, validatePaths, pathValidation]);
+    const handleUpdateCategory = useCallback(async (updatedCat, oldLabel) => {
+        if (!configLoaded)
+            return;
+        setCustomCategories(prev => {
+            const current = prev.length > 0 ? prev : activeCategories;
+            return current.map(c => c.value === updatedCat.value ? updatedCat : c);
+        });
+        if (oldLabel && oldLabel !== updatedCat.label) {
+            if (category === oldLabel) {
+                setCategory(updatedCat.label);
+            }
+            if (filterCategories.includes(oldLabel)) {
+                setFilterCategories(prev => prev.map(c => c === oldLabel ? updatedCat.label : c));
+            }
+        }
+        try {
+            // Get the latest updated list for the API call
+            // Since we just called setCustomCategories, we can't easily get the 'new' state here
+            // but we can compute it again or use activeCategories if we know it's fresh.
+            // Best is to use the same logic as the functional update above.
+            const currentCats = customCategories.length > 0 ? customCategories : activeCategories;
+            const updatedList = currentCats.map(c => c.value === updatedCat.value ? updatedCat : c);
+            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)
+                fetchTasks();
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to update category', err);
+        }
+    }, [configLoaded, activeCategories, customCategories, category, filterCategories, fetchTasks]);
+    const handleSaveCategory = useCallback(async (newCategoryName) => {
+        if (!configLoaded)
+            return;
+        const generatedId = newCategoryName.trim().toLowerCase().replace(/\s+/g, '-');
+        // Check in activeCategories to be sure
+        if (activeCategories.some(c => c.value === generatedId)) {
+            // Already exists
+            return;
+        }
+        const newCatConfig = {
+            value: generatedId,
+            label: newCategoryName.trim(),
+            color: 'blue-200', // Default light shade
+            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);
+        }
+    }, [configLoaded, activeCategories, customCategories]);
+    // ... Implement other helpers similarly by copying/refactoring from TaskforceCore ...
+    // Note: Due to size, I am implementing the core parts first. The rest of the event handlers need to be extracted.
+    // I will include ALL handlers in this file.
+    // Navigation and Tab Management
+    const setActiveTab = useCallback((tab) => {
+        // Record scroll position before switching away from tasks
+        if (activeTab === 'tasks' && tasksScrollRef.current) {
+            setTasksScrollPos(tasksScrollRef.current.scrollTop);
+        }
+        setActiveTab__internal(tab);
+    }, [activeTab]);
+    const handleNavigation = useCallback((action) => {
+        // Check for unsaved changes... 
+        let hasChanges = false;
+        if (editingTaskId) {
+            // Existing Logic for Editing Tasks: Compare against original
+            const original = tasks.find(t => t.id === editingTaskId);
+            if (original) {
+                const isDescriptionEqual = (original.description || '') === (description || '');
+                const isPriorityEqual = Number(original.priority) === Number(priority);
+                const isComplexityEqual = Number(original.complexity ?? 3) === Number(complexity ?? 3);
+                const isApproachEqual = (original.approach || '') === (approach || '');
+                const isAssigneeEqual = (original.assignee || 'unassigned') === (assignee || 'unassigned');
+                const isParentEqual = (original.parentTaskId || '') === (parentTaskIdInput || '').trim();
+                const isTaxonomiesEqual = JSON.stringify(original.taxonomies || {}) === JSON.stringify(formTaxonomies);
+                const isSpecialistsEqual = JSON.stringify(original.specialists || []) === JSON.stringify(selectedSpecialists);
+                const isScreenshotsEqual = JSON.stringify(original.attachments || original.screenshots || []) === JSON.stringify(screenshots);
+                if (original.title !== title ||
+                    !isDescriptionEqual ||
+                    original.category !== category ||
+                    original.type !== type ||
+                    !isPriorityEqual ||
+                    !isComplexityEqual ||
+                    !isApproachEqual ||
+                    !isAssigneeEqual ||
+                    !isParentEqual ||
+                    !isTaxonomiesEqual ||
+                    !isSpecialistsEqual ||
+                    !isScreenshotsEqual ||
+                    newCommentText.trim() !== '') {
+                    hasChanges = true;
+                }
+            }
+        }
+        else {
+            // New Task Logic: Relaxed check
+            // Only consider it "dirty" if the user has actually typed content or added attachments.
+            // We IGNORE: category, type, priority, approach, taxonomies (as they have defaults)
+            hasChanges = title.trim() !== '' ||
+                description.trim() !== '' ||
+                newCommentText.trim() !== '' ||
+                comments.length > 0 ||
+                screenshots.length > 0;
+        }
+        // If adding and empty, allow
+        if (!hasChanges) {
+            action();
+            return;
+        }
+        // Otherwise prompt
+        setPendingNavigation(() => action);
+        setUnsavedModalOpen(true);
+    }, [title, description, category, type, priority, complexity, approach, assignee, scheduledDate, dueDate, parentTaskIdInput, editingTaskId, tasks, formTaxonomies, selectedSpecialists, screenshots, activeCategories]);
+    const handleClose = useCallback(() => {
+        setIsOpen(false);
+        // Reset state after close animation?
+    }, []);
+    const resetForm = useCallback(() => {
+        setEditingTaskId(null);
+        setTitle('');
+        setDescription('');
+        // Reset category to last used or default
+        const lastCat = lastUsedCategory;
+        const lastCatExists = activeCategories.some(c => c.label === lastCat || c.value === lastCat);
+        if (lastCat && lastCatExists) {
+            const found = activeCategories.find(c => c.label === lastCat || c.value === lastCat);
+            setCategory(found?.value || lastCat);
+        }
+        else {
+            setCategory(getPreferredCategoryValue(activeCategories));
+        }
+        setType('feature');
+        setPriority(2);
+        setComplexity(3);
+        setApproach('default');
+        setAssignee('agent');
+        setScheduledDate('');
+        setDueDate('');
+        setParentTaskIdInput('');
+        setAddChildTaskIdInput('');
+        setFormTaxonomies({});
+        setComments([]);
+        setNewCommentText('');
+        setSelectedSpecialists([]);
+        setScreenshots([]);
+        setError('');
+    }, [activeCategories, getPreferredCategoryValue, lastUsedCategory]);
+    const resolveTaskIdInput = useCallback((value) => {
+        const needle = value.trim();
+        if (!needle)
+            return null;
+        const exact = relationshipTasks.find(t => t.id === needle);
+        if (exact)
+            return exact;
+        const suffixMatches = relationshipTasks.filter(t => t.id.endsWith(needle));
+        if (suffixMatches.length === 1)
+            return suffixMatches[0];
+        return null;
+    }, [relationshipTasks]);
+    const handleEdit = useCallback((task) => {
+        if (returnFromChildTaskId && task.id !== returnFromChildTaskId) {
+            setReturnToParentTaskId(null);
+            setReturnFromChildTaskId(null);
+        }
+        setEditingTaskId(task.id);
+        setTitle(task.title);
+        setDescription(task.description || '');
+        setCategory(task.category || getPreferredCategoryValue(activeCategories));
+        setType(task.type || 'feature');
+        setPriority(typeof task.priority === 'number' ? task.priority : 2);
+        setComplexity(typeof task.complexity === 'number' ? task.complexity : 3);
+        setApproach(task.approach || 'default');
+        setAssignee((task.assignee || 'unassigned'));
+        setScheduledDate(task.scheduledDate || '');
+        setDueDate(task.dueDate || '');
+        setParentTaskIdInput(task.parentTaskId || '');
+        setAddChildTaskIdInput('');
+        setComments(task.comments || []);
+        // Handle taxonomies
+        setFormTaxonomies(task.taxonomies || {});
+        // Also sync approach if it's in taxonomies
+        if (task.taxonomies?.approach) {
+            setApproach(task.taxonomies.approach);
+        }
+        setSelectedSpecialists(task.specialists || []);
+        setScreenshots(task.attachments || task.screenshots || []);
+        // Switch tab
+        setActiveTab('add');
+        // Scroll to top of form
+    }, [activeCategories, returnFromChildTaskId, getPreferredCategoryValue]);
+    const handleOpenTaskById = useCallback((taskId) => {
+        const target = tasks.find(t => t.id === taskId);
+        if (!target)
+            return;
+        if (activeTab === 'add' && editingTaskId && editingTaskId !== target.id) {
+            setReturnToParentTaskId(editingTaskId);
+            setReturnFromChildTaskId(target.id);
+        }
+        handleEdit(target);
+    }, [tasks, handleEdit, activeTab, editingTaskId]);
+    // CRUD Operations
+    const saveTask = async () => {
+        if (!title.trim()) {
+            setError('Title is required');
+            return false;
+        }
+        if (editingTaskId) {
+            const existing = relationshipTasks.find((t) => t.id === editingTaskId);
+            if (existing?.isArchived) {
+                setError('Archived tasks are read-only. Unarchive first to make changes.');
+                return false;
+            }
+        }
+        setLoading(true);
+        setError('');
+        try {
+            const url = editingTaskId
+                ? `/api/taskforce/task/${editingTaskId}`
+                : apiEndpoint.replace('/api/dev/task', '/api/taskforce/task').replace('/api/taskforce/task', '/api/taskforce/task');
+            const method = editingTaskId ? 'PATCH' : 'POST';
+            const sanitizedCategory = typeof category === 'string'
+                ? category
+                : category.label || getPreferredCategoryValue(activeCategories);
+            const sanitizedType = typeof type === 'string' ? type : type.label || 'feature';
+            const res = await fetch(url, {
+                method,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    title,
+                    description: description || null,
+                    category: sanitizedCategory || getPreferredCategoryValue(activeCategories),
+                    type: sanitizedType,
+                    priority,
+                    complexity: Number(complexity) || 3,
+                    approach: approach || 'default',
+                    assignee: assignee || 'agent',
+                    scheduledDate: scheduledDate || null,
+                    dueDate: dueDate || null,
+                    parentTaskId: parentTaskIdInput.trim() || null,
+                    comments,
+                    attachments: screenshots,
+                    taxonomies: formTaxonomies,
+                    specialists: selectedSpecialists,
+                    createdAt: new Date().toISOString(),
+                    createdBy: 'user',
+                }),
+            });
+            if (res.ok) {
+                // Save last used category
+                setLastUsedCategory(sanitizedCategory);
+                setLoading(false);
+                return true;
+            }
+            else {
+                const data = await res.json();
+                setError(data.message || `Failed to ${editingTaskId ? 'update' : 'save'} task`);
+                setLoading(false);
+                return false;
+            }
+        }
+        catch {
+            setError('Failed to connect to server');
+            setLoading(false);
+            return false;
+        }
+    };
+    const runSaveFlow = useCallback(async () => {
+        const success = await saveTask();
+        if (success) {
+            setSuccessBanner({
+                message: `Task ${editingTaskId ? 'updated' : 'added'} successfully`,
+                type: editingTaskId ? 'updated' : 'added'
+            });
+            setTimeout(() => setSuccessBanner(null), 3000);
+            if (activeTab === 'add') {
+                resetForm();
+                setActiveTab('tasks');
+                fetchTasks(); // Refresh list
+            }
+        }
+    }, [saveTask, editingTaskId, activeTab, resetForm, fetchTasks]);
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        if (dueDate && scheduledDate && dueDate < scheduledDate) {
+            setScheduleWarningPrompt({ dueDate, scheduledDate });
+            return;
+        }
+        await runSaveFlow();
+    };
+    const confirmScheduleWarning = useCallback(async () => {
+        setScheduleWarningPrompt(null);
+        await runSaveFlow();
+    }, [runSaveFlow]);
+    const cancelScheduleWarning = useCallback(() => {
+        setScheduleWarningPrompt(null);
+    }, []);
+    const handleDelete = async (id, archive = false, options = {}) => {
+        if (!options.skipConfirm && !confirm('Are you sure you want to delete this task permanently?'))
+            return false;
+        const isArchivedTask = archive || archivedTasks.some((task) => task.id === id);
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}`, { method: 'DELETE' });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to delete task.');
+                return false;
+            }
+            if (window.location.search.includes(id)) {
+                // remove query param if we deleted the deep linked task
+                const url = new URL(window.location.href);
+                url.searchParams.delete('task');
+                window.history.pushState({}, '', url.toString());
+            }
+            if (isArchivedTask) {
+                setArchivedTasks(prev => prev.filter(t => t.id !== id));
+            }
+            else {
+                setTasks(prev => prev.filter(t => t.id !== id));
+            }
+            workspaceDeletedTaskIdsRef.current.add(id);
+            if (cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled) {
+                const signature = buildWorkspaceSyncSignature();
+                workspacePendingSignatureRef.current = signature;
+                void pushWorkspaceChangesToCloud(signature);
+            }
+            if (editingTaskId === id) {
+                resetForm();
+                setActiveTab('tasks');
+            }
+            setError('');
+            return true;
+        }
+        catch (err) {
+            console.error('Failed to delete task:', err);
+            setError('Failed to delete task.');
+            return false;
+        }
+    };
+    // Generic update handler for drag-and-drop
+    const handleUpdateTask = useCallback(async (id, updates) => {
+        const previousTasks = tasks;
+        const previousArchivedTasks = archivedTasks;
+        // Optimistic update
+        setTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        setArchivedTasks(prev => prev.map(t => t.id === id ? { ...t, ...updates } : t));
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(updates),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || `Failed to update task ${id}.`);
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
+                return;
+            }
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to update task", err);
+            // Revert on error
+            setError(`Failed to update task ${id}.`);
+            setTasks(previousTasks);
+            setArchivedTasks(previousArchivedTasks);
+        }
+    }, [tasks, archivedTasks]);
+    // Other handlers (Archive, Status Toggles, etc.)
+    const handleToggleComplete = async (task) => {
+        const newStatus = task.status === 'done' ? 'task' : 'done';
+        const isDone = newStatus === 'done';
+        const hierarchySource = [...tasks, ...archivedTasks];
+        const hasDescendants = Array.from(collectSubtreeTaskIds(hierarchySource, task.id)).some((id) => id !== task.id);
+        if (isDone && hasDescendants) {
+            setError('Parent tasks complete automatically when all descendant tasks are done or cancelled.');
+            return;
+        }
+        try {
+            const completedAt = isDone ? new Date().toISOString() : undefined;
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus, completedAt }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to update task status.');
+                await fetchTasks(true);
+                return;
+            }
+            await fetchTasks(true);
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to toggle complete", err);
+            setError('Failed to update task status.');
+            fetchTasks();
+        }
+    };
+    const handleToggleCancel = async (task) => {
+        const newStatus = task.status === 'cancelled' ? 'task' : 'cancelled';
+        const isCancelled = newStatus === 'cancelled';
+        if (isCancelled) {
+            const taskById = new Map();
+            tasks.forEach((item) => taskById.set(item.id, item));
+            const depthById = buildHierarchyDepthMap(tasks);
+            const activeDescendantIds = Array.from(collectSubtreeTaskIds(tasks, task.id))
+                .filter((id) => id !== task.id)
+                .filter((id) => {
+                const child = taskById.get(id);
+                return Boolean(child) && !child?.isArchived && child?.status !== 'done' && child?.status !== 'cancelled';
+            })
+                .sort((a, b) => (depthById.get(b) || 0) - (depthById.get(a) || 0));
+            setCancellationOpenDescendantIds(activeDescendantIds);
+            setCancellationMode(null);
+            setCancellationPromptTask(task);
+            return;
+        }
+        try {
+            const res = await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to update task status.');
+                await fetchTasks(true);
+                return;
+            }
+            await fetchTasks(true);
+            setError('');
+        }
+        catch (err) {
+            console.error("Failed to toggle cancel", err);
+            setError('Failed to update task status.');
+            fetchTasks();
+        }
+    };
+    const confirmCancellation = useCallback(async (reason, mode) => {
+        if (!cancellationPromptTask)
+            return false;
+        const task = cancellationPromptTask;
+        const selectedMode = mode || cancellationMode;
+        if (cancellationOpenDescendantIds.length > 0 && !selectedMode) {
+            setError('Choose how to handle open descendant tasks before confirming cancellation.');
+            return false;
+        }
+        try {
+            const res = await fetch(`/api/taskforce/task/${task.id}/cancel-parent`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    reason,
+                    mode: selectedMode || 'cascade'
+                }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to update task status.');
+                await fetchTasks(true);
+                return false;
+            }
+            setError('');
+            setCancellationPromptTask(null);
+            setCancellationOpenDescendantIds([]);
+            setCancellationMode(null);
+            await fetchTasks(true);
+            return true;
+        }
+        catch (err) {
+            console.error("Failed to confirm cancellation", err);
+            setError('Failed to update task status.');
+            fetchTasks();
+            return false;
+        }
+    }, [cancellationPromptTask, cancellationOpenDescendantIds, cancellationMode, fetchTasks]);
+    const cancelCancellationPrompt = useCallback(() => {
+        setCancellationPromptTask(null);
+        setCancellationOpenDescendantIds([]);
+        setCancellationMode(null);
+    }, []);
+    const handleToggleInProgress = async (task) => {
+        const newStatus = task.status === 'in-progress' ? 'task' : 'in-progress';
+        const isInProgress = newStatus === 'in-progress';
+        setTasks(prev => prev.map(t => t.id === task.id ? {
+            ...t,
+            status: newStatus
+        } : t));
+        try {
+            await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+        }
+        catch (err) {
+            fetchTasks();
+        }
+    };
+    const handleToggleReview = async (task) => {
+        const newStatus = task.status === 'review' ? 'task' : 'review';
+        const isReview = newStatus === 'review';
+        setTasks(prev => prev.map(t => t.id === task.id ? {
+            ...t,
+            status: newStatus
+        } : t));
+        try {
+            await fetch(`/api/taskforce/task/${task.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ status: newStatus }),
+            });
+        }
+        catch (err) {
+            fetchTasks();
+        }
+    };
+    const handleArchiveTask = async (task) => {
+        try {
+            const taskById = new Map();
+            tasks.forEach((item) => taskById.set(item.id, item));
+            const depthById = buildHierarchyDepthMap(tasks);
+            const descendantIds = Array.from(collectSubtreeTaskIds(tasks, task.id))
+                .filter((id) => id !== task.id)
+                .filter((id) => {
+                const child = taskById.get(id);
+                return Boolean(child) && !child?.isArchived;
+            })
+                .sort((a, b) => (depthById.get(b) || 0) - (depthById.get(a) || 0));
+            const shouldCascadeArchive = descendantIds.length > 0
+                ? window.confirm(t('actionHeader.confirmCascadeArchive', { count: descendantIds.length }))
+                : false;
+            if (descendantIds.length > 0 && shouldCascadeArchive) {
+                for (const childId of descendantIds) {
+                    const child = taskById.get(childId);
+                    if (!child)
+                        continue;
+                    const childEndpoint = child.status === 'cancelled' ? 'cancel' : 'complete';
+                    const childRes = await fetch(`/api/taskforce/task/${childId}/${childEndpoint}`, { method: 'POST' });
+                    if (!childRes.ok) {
+                        const data = await childRes.json().catch(() => ({}));
+                        setError(data.error || 'Failed to archive task.');
+                        await fetchTasks(true);
+                        return;
+                    }
+                }
+            }
+            const isCancelled = task.status === 'cancelled';
+            const endpoint = isCancelled ? 'cancel' : 'complete';
+            const res = await fetch(`/api/taskforce/task/${task.id}/${endpoint}`, { method: 'POST' });
+            if (res.ok) {
+                const archivedIdSet = new Set([task.id, ...(shouldCascadeArchive ? descendantIds : [])]);
+                setTasks(prev => prev.filter(t => !archivedIdSet.has(t.id)));
+                // backend returns task via data result or we can just fetch
+                fetchArchive();
+                // If archiving from edit modal, close edit and return to task list.
+                if (editingTaskId && archivedIdSet.has(editingTaskId)) {
+                    resetForm();
+                    setActiveTab('tasks');
+                }
+            }
+            else {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to archive task.');
+            }
+        }
+        catch (err) {
+            console.error("Failed to archive", err);
+            setError('Failed to archive task.');
+        }
+    };
+    const handleBulkArchive = async () => {
+        const completedOrCancelled = tasks.filter(t => t.status === 'done' || t.status === 'cancelled');
+        if (completedOrCancelled.length === 0)
+            return;
+        if (!confirm(`Archive ${completedOrCancelled.length} completed/cancelled tasks?`))
+            return;
+        try {
+            const res = await fetch('/api/taskforce/bulk-archive', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ ids: completedOrCancelled.map(t => t.id) })
+            });
+            if (res.ok) {
+                const data = await res.json();
+                setTasks(prev => prev.filter(t => !(['done', 'cancelled'].includes(t.status))));
+                fetchArchive();
+                setSuccessBanner({
+                    message: `${data.archived || completedOrCancelled.length} tasks archived`,
+                    type: 'info'
+                });
+                setTimeout(() => setSuccessBanner(null), 3000);
+                setError('');
+            }
+            else {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to bulk archive tasks.');
+            }
+        }
+        catch (err) {
+            console.error("Failed to bulk archive", err);
+            setError('Failed to bulk archive tasks.');
+        }
+    };
+    const handleUnarchive = async (id) => {
+        try {
+            const res = await fetch(`/api/taskforce/task/${id}/unarchive`, { method: 'POST' });
+            if (res.ok) {
+                const data = await res.json();
+                setArchivedTasks(prev => prev.filter(t => t.id !== id));
+                fetchTasks(); // Refresh list to get the unarchived task
+            }
+        }
+        catch (err) {
+            console.error("Failed to unarchive", err);
+        }
+    };
+    const handleAddComment = async (text) => {
+        if (!editingTaskId || !text.trim())
+            return;
+        const comment = {
+            id: `comment-${generateClientUuid()}`,
+            author: 'user',
+            text: text,
+            timestamp: new Date().toISOString()
+        };
+        const updatedComments = [...comments, comment];
+        setComments(updatedComments);
+        setNewCommentText('');
+        try {
+            await fetch(`/api/taskforce/task/${editingTaskId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ comments: updatedComments })
+            });
+            // Update local task
+            setTasks(prev => prev.map(t => t.id === editingTaskId ? { ...t, comments: updatedComments } : t));
+        }
+        catch (err) {
+            console.error("Failed to add comment", err);
+        }
+    };
+    const handleSetParentForCurrentTask = useCallback(async (parentTaskIdOverride) => {
+        if (!editingTaskId)
+            return;
+        const current = relationshipTasks.find(t => t.id === editingTaskId);
+        if (!current)
+            return;
+        const nextParentRaw = typeof parentTaskIdOverride === 'string'
+            ? parentTaskIdOverride.trim()
+            : parentTaskIdOverride === null
+                ? ''
+                : parentTaskIdInput.trim();
+        const resolvedParent = nextParentRaw ? resolveTaskIdInput(nextParentRaw) : null;
+        const normalizedParentId = nextParentRaw.length > 0 ? (resolvedParent?.id || nextParentRaw) : null;
+        if (normalizedParentId === editingTaskId) {
+            setError('A task cannot be its own parent.');
+            return;
+        }
+        if (wouldCreateParentCycle(editingTaskId, normalizedParentId, relationshipTasks)) {
+            setError(`Cannot set parent ${normalizedParentId} for ${editingTaskId}: link would create a cycle.`);
+            return;
+        }
+        if (shouldPromptReparent(current.parentTaskId, normalizedParentId)) {
+            const confirmed = window.confirm(`This task already has parent ${current.parentTaskId}. Re-parent to ${normalizedParentId}?`);
+            if (!confirmed)
+                return;
+        }
+        try {
+            const res = await fetch(`/api/taskforce/task/${editingTaskId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ parentTaskId: normalizedParentId })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to set parent task.');
+                return;
+            }
+            setError('');
+            setSuccessBanner({ message: normalizedParentId ? 'Parent set' : 'Parent removed', type: 'info' });
+            setTimeout(() => setSuccessBanner(null), 2500);
+            await fetchTasks(true);
+        }
+        catch {
+            setError('Failed to set parent task.');
+        }
+    }, [editingTaskId, parentTaskIdInput, relationshipTasks, fetchTasks, resolveTaskIdInput]);
+    const handleAddChildToCurrentTask = useCallback(async () => {
+        if (!editingTaskId)
+            return;
+        const typed = addChildTaskIdInput.trim();
+        if (!typed)
+            return;
+        const childTask = resolveTaskIdInput(typed);
+        if (!childTask) {
+            setError('Child task not found by that ID.');
+            return;
+        }
+        if (childTask.id === editingTaskId) {
+            setError('A task cannot be a child of itself.');
+            return;
+        }
+        if (wouldCreateParentCycle(childTask.id, editingTaskId, relationshipTasks)) {
+            setError(`Cannot link child ${childTask.id} to parent ${editingTaskId}: link would create a cycle.`);
+            return;
+        }
+        if (shouldPromptReparent(childTask.parentTaskId, editingTaskId)) {
+            const confirmed = window.confirm(`Task ${childTask.id} is already parented to ${childTask.parentTaskId}. Re-parent it to ${editingTaskId}?`);
+            if (!confirmed)
+                return;
+        }
+        try {
+            const res = await fetch(`/api/taskforce/task/${childTask.id}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ parentTaskId: editingTaskId })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to add child task.');
+                return;
+            }
+            setError('');
+            setAddChildTaskIdInput('');
+            setSuccessBanner({ message: `Child linked: ${childTask.id}`, type: 'info' });
+            setTimeout(() => setSuccessBanner(null), 2500);
+            await fetchTasks(true);
+        }
+        catch {
+            setError('Failed to add child task.');
+        }
+    }, [editingTaskId, addChildTaskIdInput, resolveTaskIdInput, relationshipTasks, fetchTasks]);
+    const handleCreateChildForCurrentTask = useCallback(async () => {
+        if (!editingTaskId)
+            return;
+        const parent = relationshipTasks.find(t => t.id === editingTaskId);
+        if (!parent) {
+            setError('Parent task not found.');
+            return;
+        }
+        const childTitle = `Child of ${parent.title}`;
+        const payload = {
+            title: childTitle,
+            description: null,
+            category: parent.category || category || getPreferredCategoryValue(activeCategories),
+            type: parent.type || type || 'feature',
+            priority: typeof parent.priority === 'number' ? parent.priority : 2,
+            complexity: typeof parent.complexity === 'number' ? parent.complexity : 3,
+            approach: parent.approach || null,
+            assignee: parent.assignee || 'agent',
+            parentTaskId: editingTaskId,
+            comments: [],
+            attachments: [],
+            taxonomies: {},
+            specialists: [],
+            createdAt: new Date().toISOString(),
+            createdBy: 'user'
+        };
+        try {
+            const res = await fetch('/api/taskforce/task', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to create child task.');
+                return;
+            }
+            const createdRaw = await res.json();
+            const created = normalizeTaskFromApi(createdRaw, { mapLegacyTodoStatus: true });
+            setTasks(prev => [created, ...prev]);
+            setError('');
+            setSuccessBanner({ message: `Child task created: ${created.id}`, type: 'added' });
+            setTimeout(() => setSuccessBanner(null), 3000);
+            setReturnToParentTaskId(editingTaskId);
+            setReturnFromChildTaskId(created.id);
+            handleEdit(created);
+            await fetchTasks(true);
+        }
+        catch {
+            setError('Failed to create child task.');
+        }
+    }, [editingTaskId, relationshipTasks, category, type, manualComplexityEnabled, handleEdit, fetchTasks, getPreferredCategoryValue, activeCategories]);
+    const clearReturnToParentTask = useCallback(() => {
+        setReturnToParentTaskId(null);
+        setReturnFromChildTaskId(null);
+    }, []);
+    const handleUnlinkChildTask = useCallback(async (childId) => {
+        const confirmed = window.confirm(`Remove child link for ${childId}?`);
+        if (!confirmed)
+            return;
+        try {
+            const res = await fetch(`/api/taskforce/task/${childId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ parentTaskId: null })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to unlink child task.');
+                return;
+            }
+            setError('');
+            setSuccessBanner({ message: `Child unlinked: ${childId}`, type: 'info' });
+            setTimeout(() => setSuccessBanner(null), 2500);
+            await fetchTasks(true);
+        }
+        catch {
+            setError('Failed to unlink child task.');
+        }
+    }, [fetchTasks]);
+    const handleReorderChildTasks = useCallback(async (parentTaskId, orderedChildIds) => {
+        if (!parentTaskId || orderedChildIds.length === 0)
+            return;
+        const updates = orderedChildIds.map((id, index) => ({ id, childDisplayOrder: index }));
+        const updateMap = new Map(updates.map(update => [update.id, update.childDisplayOrder]));
+        setTasks(prev => prev.map(task => {
+            const nextOrder = updateMap.get(task.id);
+            if (nextOrder === undefined)
+                return task;
+            return { ...task, childDisplayOrder: nextOrder };
+        }));
+        setArchivedTasks(prev => prev.map(task => {
+            const nextOrder = updateMap.get(task.id);
+            if (nextOrder === undefined)
+                return task;
+            return { ...task, childDisplayOrder: nextOrder };
+        }));
+        try {
+            const res = await fetch('/api/taskforce/bulk-update-fields', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ updates }),
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to save child task order.');
+                await fetchTasks(true);
+                return;
+            }
+            setError('');
+        }
+        catch {
+            setError('Failed to save child task order.');
+            await fetchTasks(true);
+        }
+    }, [fetchTasks]);
+    const handleClearParentTask = useCallback(async (taskId) => {
+        const confirmed = window.confirm(`Remove parent link for ${taskId}?`);
+        if (!confirmed)
+            return;
+        try {
+            const res = await fetch(`/api/taskforce/task/${taskId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ parentTaskId: null })
+            });
+            if (!res.ok) {
+                const data = await res.json().catch(() => ({}));
+                setError(data.error || 'Failed to remove parent task.');
+                return;
+            }
+            setError('');
+            setSuccessBanner({ message: `Parent removed: ${taskId}`, type: 'info' });
+            setTimeout(() => setSuccessBanner(null), 2500);
+            await fetchTasks(true);
+        }
+        catch {
+            setError('Failed to remove parent task.');
+        }
+    }, [fetchTasks]);
+    // Copy ID helper
+    const handleCopyId = (e, id) => {
+        e.stopPropagation();
+        navigator.clipboard.writeText(id);
+        setCopiedId(id);
+        setTimeout(() => setCopiedId(null), 2000);
+    };
+    // --- Missing Path Handlers ---
+    const handleAddPath = useCallback((catValue, pathInput) => {
+        if (!pathInput.trim())
+            return;
+        const catToUpdate = activeCategories.find(c => c.value === catValue);
+        if (catToUpdate) {
+            const currentPaths = getCategoryPaths(catToUpdate);
+            const trimmedPath = pathInput.trim();
+            if (!currentPaths.includes(trimmedPath)) {
+                const newPaths = [...currentPaths, trimmedPath];
+                handleUpdateCategory({ ...catToUpdate, path: undefined, paths: newPaths });
+                validatePaths(newPaths); // Validate the new set
+            }
+        }
+    }, [activeCategories, getCategoryPaths, validatePaths, handleUpdateCategory]);
+    const handleUpdateCategoryIcon = useCallback((catValue, iconName) => {
+        const catToUpdate = activeCategories.find(c => c.value === catValue);
+        if (catToUpdate) {
+            handleUpdateCategory({ ...catToUpdate, icon: iconName });
+        }
+    }, [activeCategories, handleUpdateCategory]);
+    const handleUpdateCategoryColor = useCallback((catValue, color) => {
+        const catToUpdate = activeCategories.find(c => c.value === catValue);
+        if (catToUpdate) {
+            handleUpdateCategory({ ...catToUpdate, color });
+        }
+    }, [activeCategories, handleUpdateCategory]);
+    const handleRemovePath = useCallback((catValue, pathToRemove) => {
+        const catToUpdate = activeCategories.find(c => c.value === catValue);
+        if (catToUpdate) {
+            const currentPaths = getCategoryPaths(catToUpdate);
+            const newPaths = currentPaths.filter(p => p !== pathToRemove);
+            handleUpdateCategory({ ...catToUpdate, path: undefined, paths: newPaths });
+        }
+    }, [activeCategories, getCategoryPaths]);
+    // Browser selection handler
+    const handleSelectPath = useCallback((path) => {
+        const relativePath = normalizePath(path);
+        if (browserTarget && typeof browserTarget === 'object' && browserTarget.type === 'category') {
+            const catToUpdate = activeCategories.find(c => c.value === browserTarget.value);
+            if (catToUpdate) {
+                const currentPaths = getCategoryPaths(catToUpdate);
+                if (!currentPaths.includes(relativePath)) {
+                    const newPaths = [...currentPaths, relativePath];
+                    handleUpdateCategory({ ...catToUpdate, path: undefined, paths: newPaths });
+                }
+                setShowFolderBrowser(false);
+            }
+        }
+        if (browserTarget && typeof browserTarget === 'object' && browserTarget.type === 'context-link') {
+            setContextLinkBrowsePath(relativePath);
+            setShowFolderBrowser(false);
+        }
+        setShowFolderBrowser(false);
+        setBrowserTarget(null);
+    }, [browserTarget, currentTheme, keyShortcut, mcpHostRoot, activeCategories, getCategoryPaths, normalizePath]);
+    const handleRemoveCategory = useCallback(async (catValue) => {
+        if (!configLoaded)
+            return;
+        const fallbackValue = 'default';
+        const fallbackLabel = 'Default';
+        const catToRemove = activeCategories.find(c => c.value === catValue);
+        setCustomCategories(prev => {
+            const current = prev.length > 0 ? prev : activeCategories;
+            let updated = current.filter(c => c.value !== catValue);
+            // Ensure fallback exists
+            if (!updated.some(c => c.value === fallbackValue)) {
+                updated.unshift({ value: fallbackValue, label: fallbackLabel });
+            }
+            return updated;
+        });
+        // Synchronize state if necessary
+        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(c => c !== catToRemove.label && c !== catToRemove.value);
+                    // Add fallback if not already in the filter to ensure reassigned tasks show up
+                    const fallback = filtered.includes(fallbackValue) ? [] : [fallbackValue];
+                    return [...filtered, ...fallback];
+                });
+            }
+        }
+        try {
+            const currentCats = customCategories.length > 0 ? customCategories : activeCategories;
+            let updatedList = currentCats.filter(c => c.value !== catValue);
+            if (!updatedList.some(c => c.value === fallbackValue)) {
+                updatedList.unshift({ value: fallbackValue, label: fallbackLabel });
+            }
+            await fetch('/api/taskforce/categories', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    categories: updatedList,
+                    reassignFrom: catToRemove?.label || catValue,
+                    reassignTo: fallbackLabel
+                }),
+            });
+            // Refresh tasks locally to reflect reassignment
+            fetchTasks();
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to remove category', err);
+        }
+    }, [configLoaded, activeCategories, customCategories, category, filterCategories, fetchTasks]);
+    // Type Management
+    const handleSaveType = async (labelInput) => {
+        if (!labelInput.trim())
+            return;
+        const val = labelInput.trim().toLowerCase().replace(/\s+/g, '-');
+        if (activeTypes.some(t => t.value === val))
+            return;
+        const updated = [...activeTypes, { value: val, label: labelInput.trim() }];
+        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);
+        }
+    };
+    const handleRemoveType = async (typeToRemove) => {
+        const fallback = 'feature';
+        const updated = activeTypes.filter(t => t.value !== typeToRemove);
+        if (!updated.some(t => t.value === fallback) && typeToRemove !== fallback) {
+            updated.unshift({ value: 'feature', label: 'Feature' });
+        }
+        setCustomTypes(updated);
+        try {
+            await fetch('/api/taskforce/types', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    types: updated,
+                    reassignFrom: typeToRemove,
+                    reassignTo: fallback
+                }),
+            });
+            fetchTasks();
+        }
+        catch (err) {
+            console.error('Failed to save type', err);
+        }
+    };
+    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]);
+    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]);
+    const handleUpdateApproaches = useCallback(async (updated) => {
+        if (!configLoaded)
+            return;
+        setApproaches(updated);
+        try {
+            await fetch('/api/taskforce/approaches', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ approaches: updated }),
+            });
+        }
+        catch (err) {
+            console.error('[Taskforce] Failed to save approaches', err);
+        }
+    }, [configLoaded]);
+    const currentTask = useMemo(() => {
+        if (!editingTaskId)
+            return undefined;
+        return relationshipTasks.find(t => t.id === editingTaskId);
+    }, [relationshipTasks, editingTaskId]);
+    const currentTaskParent = useMemo(() => {
+        if (!currentTask?.parentTaskId)
+            return undefined;
+        return relationshipTasks.find(t => t.id === currentTask.parentTaskId);
+    }, [relationshipTasks, currentTask]);
+    const currentTaskChildren = useMemo(() => {
+        if (!editingTaskId)
+            return [];
+        return sortChildTasksForDisplay(relationshipTasks.filter(t => t.parentTaskId === editingTaskId));
+    }, [relationshipTasks, editingTaskId]);
+    const settingsModel = {
+        currentTheme,
+        configLoaded,
+        globalTheme,
+        themeUseGlobalDefault,
+        keyShortcut,
+        jsonBackupEnabled,
+        globalJsonBackupEnabled,
+        globalWeekStartsOn,
+        locale,
+        supportedLocales,
+        jsonBackupUseGlobalDefault,
+        manualComplexityEnabled,
+        checklistDropdownEnabled,
+        assigneeFilterEnabled,
+        exportWorkflowsPath,
+        exportSpecialistsPath,
+        exportingResource,
+        exportResult,
+        pathSaved,
+        initialSection: settingsSection,
+        exportEnvironment,
+        setupState,
+        buildInfo,
+        onSaveSetupMode: saveSetupMode,
+        onSaveWorkspaceProfile: saveWorkspaceProfile,
+        onThemeChange: setCurrentTheme,
+        onSaveTheme: handleSaveTheme,
+        onSaveGlobalTheme: handleSaveGlobalTheme,
+        onKeyShortcutChange: setKeyShortcut,
+        onJsonBackupEnabledChange: handleJsonBackupEnabledChange,
+        onSaveGlobalJsonBackupEnabled: handleSaveGlobalJsonBackupEnabled,
+        onSaveGlobalWeekStartsOn: handleSaveGlobalWeekStartsOn,
+        onSaveLocale: handleSaveLocale,
+        onManualComplexityEnabledChange: handleManualComplexityEnabledChange,
+        onChecklistDropdownEnabledChange: handleChecklistDropdownEnabledChange,
+        onAssigneeFilterEnabledChange: handleAssigneeFilterEnabledChange,
+        onResetProjectToGlobal: handleResetProjectToGlobal,
+        onSaveSettings: handleSaveSettings,
+        onExportWorkflowsPathChange: setExportWorkflowsPath,
+        onExportSpecialistsPathChange: setExportSpecialistsPath,
+        onExportEnvironmentChange: setExportEnvironment,
+        onExportResources: handleExportResources,
+        availableWorkflows,
+        initiativeTemplates,
+        availableEnvironments,
+        onRefreshWorkflows: fetchWorkflows,
+        onRefreshInitiativeTemplates: fetchInitiativeTemplates,
+        onCreateInitiativeFromTemplate: createInitiativeFromTemplate,
+        onCloneChecklistBlocksToChildren: cloneChecklistBlocksToChildren,
+        onFetchWorkflowTemplate: fetchWorkflowTemplate,
+        onFetchWorkflowOverrideNames: fetchWorkflowOverrideNames,
+        onSaveWorkflowTemplateDraft: saveWorkflowTemplateDraft,
+        onResetWorkflowTemplateDraft: resetWorkflowTemplateDraft,
+        onExportWorkflows: handleExportWorkflows,
+        onShowFolderBrowserChange: setShowFolderBrowser,
+        onBrowserTargetChange: setBrowserTarget,
+        onFetchFolders: fetchFolders,
+        categories: activeCategories,
+        pathValidation,
+        onUpdateCategory: handleUpdateCategory,
+        onRemoveCategory: handleRemoveCategory,
+        onSaveCategory: handleSaveCategory,
+        onAddPath: handleAddPath,
+        onRemovePath: handleRemovePath,
+        onUpdateCategoryIcon: handleUpdateCategoryIcon,
+        onUpdateCategoryColor: handleUpdateCategoryColor,
+        types: activeTypes,
+        onSaveType: handleSaveType,
+        onRemoveType: handleRemoveType,
+        taxonomies,
+        onUpdateTaxonomies: handleUpdateTaxonomies,
+        priorities,
+        onUpdatePriorities: handleUpdatePriorities,
+        approaches,
+        onUpdateApproaches: handleUpdateApproaches,
+        projectRoot,
+        projectName,
+        mcpHostRoot,
+        serverHostRoot,
+        mcpScriptPath,
+        tenantId,
+        workspaceId: currentWorkspaceId,
+        runtimeMode,
+        workspaceSwitchingEnabled,
+        currentWorkspaceRole: (availableWorkspaces.find((workspace) => workspace.id === currentWorkspaceId)?.role || 'member'),
+        currentWorkspaceName: String(availableWorkspaces.find((workspace) => workspace.id === currentWorkspaceId)?.name || ''),
+        onDeleteWorkspace: deleteWorkspace,
+        onMcpHostRootChange: setMcpHostRoot,
+        isAuthenticated
+    };
+    const showParentsOnly = parentTaskFilterMode === 'parents';
+    const setShowParentsOnly = useCallback((show) => {
+        setParentTaskFilterMode(show ? 'parents' : 'all');
+    }, []);
+    useEffect(() => {
+        if (typeof window !== 'undefined') {
+            window.__TASKFORCE_DEBUG__ = {
+                tasks,
+                archivedTasks,
+                runtimeMode,
+                currentWorkspaceId,
+                isAuthenticated,
+                workspaceCloudSyncEnabled,
+                realtimeSyncEnabled,
+                fetchTasks,
+                fetchArchive,
+                retryWorkspaceCloudSync,
+                resetWorkspaceSyncCursorAndPull,
+                __dispatch: {
+                    handleUpdateTask,
+                    handleToggleComplete,
+                    handleArchiveTask,
+                    handleToggleCancel,
+                    handleToggleInProgress,
+                    handleToggleReview,
+                    handleSubmit,
+                    handleDelete
+                }
+            };
+        }
+    }, [
+        tasks,
+        archivedTasks,
+        runtimeMode,
+        currentWorkspaceId,
+        isAuthenticated,
+        workspaceCloudSyncEnabled,
+        realtimeSyncEnabled,
+        fetchTasks,
+        fetchArchive,
+        retryWorkspaceCloudSync,
+        resetWorkspaceSyncCursorAndPull,
+        handleUpdateTask,
+        handleToggleComplete,
+        handleArchiveTask,
+        handleToggleCancel,
+        handleToggleInProgress,
+        handleToggleReview,
+        handleSubmit,
+        handleDelete
+    ]);
+    // Return the massive context object
+    return {
+        // Config & State
+        config: mergedConfig,
+        isOpen,
+        setIsOpen,
+        activeTab,
+        setActiveTab,
+        currentTheme,
+        setCurrentTheme,
+        configLoaded,
+        // Settings
+        storagePath,
+        saveSettings: handleSaveSettings,
+        pathSaved,
+        keyShortcut,
+        setKeyShortcut,
+        globalWeekStartsOn,
+        locale,
+        supportedLocales,
+        saveLocale: handleSaveLocale,
+        jsonBackupEnabled,
+        setJsonBackupEnabled,
+        manualComplexityEnabled,
+        checklistDropdownEnabled,
+        assigneeFilterEnabled,
+        setManualComplexityEnabled,
+        mcpHostRoot,
+        setMcpHostRoot,
+        settingsSection, // Export this
+        setSettingsSection, // Export this (needed for settings nav)
+        runtimeMode,
+        workspaceMode,
+        workspaceSwitchingEnabled,
+        cloudAuthConfigured,
+        authRequiredForApi,
+        authBlocked,
+        isAuthenticated,
+        authUserEmail,
+        userGlobalSyncStatus,
+        userGlobalLastSyncedAt,
+        workspaceLastPullAt,
+        workspaceLastPushAt,
+        workspaceLastErrorAt,
+        workspaceRetryAt,
+        userGlobalSyncPendingChanges,
+        userGlobalSyncError,
+        workspaceLastErrorMessage,
+        workspaceLastWarningMessage,
+        workspaceSyncFailureCount,
+        workspaceSyncRetryScheduledCount,
+        workspaceSyncAuthFailureCount,
+        workspaceSyncLastFailureSource,
+        workspaceSyncLastFailureStatusCode,
+        workspaceBootstrapSyncInProgress,
+        workspaceBootstrapSyncPages,
+        workspaceBootstrapSyncAppliedChanges,
+        retryUserGlobalSettingsSync,
+        retryWorkspaceCloudSync,
+        resetWorkspaceSyncCursorAndPull,
+        hasBetaAccess,
+        realtimeSyncEnabled,
+        realtimeSyncFlagSource,
+        currentWorkspaceId,
+        availableWorkspaces,
+        workspaceCloudSyncEnabled,
+        realtimeConnectionState,
+        realtimeTelemetry,
+        workspaceSyncSourceOfTruth,
+        workspaceSyncOnboardingCompleted,
+        workspaceSyncReady,
+        workspaceCloudHydrated,
+        saveWorkspaceCloudSyncSettings,
+        applyWorkspaceSyncStateSnapshot,
+        authSessionResolved,
+        workspaceBootstrapPending,
+        bootstrapPhase,
+        bootstrapError,
+        bootstrapStartedAt,
+        setupState,
+        runtimeCapabilities,
+        refreshSetupContext,
+        retryBootstrapChecks,
+        saveWorkspaceProfile,
+        fetchWorkspaces,
+        createWorkspace,
+        deleteWorkspace,
+        switchWorkspace,
+        loginWithCredentials,
+        registerWithCredentials,
+        requestEmailVerification,
+        confirmEmailVerification,
+        requestPasswordReset,
+        confirmPasswordReset,
+        inspectInviteAcceptance,
+        acceptInviteWithToken,
+        logout,
+        // Browser
+        showFolderBrowser,
+        setShowFolderBrowser,
+        folders,
+        files,
+        currentBrowsePath,
+        fetchFolders,
+        browserTarget,
+        setBrowserTarget,
+        contextLinkBrowsePath,
+        groupBy, setGroupBy,
+        emptyColumnMode, setEmptyColumnMode,
+        zenMode, setZenMode: toggleZenMode,
+        handleSelectPath,
+        handleAddPath,
+        handleRemovePath,
+        // Data
+        tasks,
+        loadingTasks,
+        archivedTasks,
+        activeCategories,
+        activeTypes,
+        priorities,
+        approaches,
+        availableSpecialists,
+        taxonomies,
+        // Filtering
+        searchQuery,
+        setSearchQuery,
+        filterCategories,
+        setFilterCategories,
+        filterTypes,
+        setFilterTypes,
+        filterPriorities,
+        setFilterPriorities,
+        filterStatus,
+        setFilterStatus,
+        filterAssignees,
+        setFilterAssignees,
+        parentTaskFilterMode,
+        setParentTaskFilterMode,
+        showParentsOnly,
+        setShowParentsOnly,
+        filterTaxonomies,
+        setFilterTaxonomies,
+        sortBy,
+        setSortBy,
+        sortOrder,
+        setSortOrder,
+        toggleSortOrder,
+        showArchive,
+        setShowArchive,
+        clearFilters,
+        filteredTasks,
+        searchAgnosticTasks,
+        filteredArchive,
+        groupedTasks,
+        collapsedCategories,
+        setCollapsedCategories,
+        // Actions
+        fetchTasks,
+        fetchArchive,
+        handleEdit,
+        handleDelete,
+        handleCopyId,
+        handleToggleComplete,
+        handleToggleCancel,
+        handleToggleInProgress,
+        handleToggleReview,
+        handleArchiveTask,
+        handleBulkArchive,
+        handleUnarchive,
+        handleUpdateTask,
+        // Form State
+        editingTaskId,
+        loading,
+        error,
+        title,
+        setTitle,
+        description,
+        setDescription,
+        category,
+        setCategory,
+        type,
+        setType,
+        priority,
+        setPriority,
+        complexity,
+        setComplexity,
+        approach,
+        setApproach,
+        assignee,
+        setAssignee,
+        scheduledDate,
+        setScheduledDate,
+        dueDate,
+        setDueDate,
+        parentTaskIdInput,
+        setParentTaskIdInput,
+        addChildTaskIdInput,
+        setAddChildTaskIdInput,
+        formTaxonomies,
+        setFormTaxonomies,
+        selectedSpecialists,
+        setSelectedSpecialists,
+        comments,
+        newCommentText,
+        setNewCommentText,
+        screenshots,
+        setScreenshots,
+        descriptionFocused,
+        setDescriptionFocused,
+        showMarkdownHelp,
+        setShowMarkdownHelp,
+        showSpecialists,
+        setShowSpecialists,
+        showChecklist,
+        setShowChecklist,
+        showTaskRelationships,
+        setShowTaskRelationships,
+        showChildTasks,
+        setShowChildTasks,
+        showComments,
+        setShowComments,
+        isCapturingScreenshot,
+        setIsCapturingScreenshot,
+        // Form Actions
+        handleSubmit,
+        resetForm,
+        handleAddComment,
+        handleSetParentForCurrentTask,
+        handleAddChildToCurrentTask,
+        handleCreateChildForCurrentTask,
+        handleUnlinkChildTask,
+        handleReorderChildTasks,
+        handleClearParentTask,
+        handleOpenTaskById,
+        // Modals
+        unsavedModalOpen,
+        setUnsavedModalOpen,
+        pendingNavigation,
+        handleNavigation,
+        handleClose,
+        // Misc
+        successBanner,
+        returnToParentTaskId,
+        returnFromChildTaskId,
+        clearReturnToParentTask,
+        copiedId,
+        recentlyChangedTaskIds,
+        cancellationPromptTask,
+        cancellationOpenDescendantIds,
+        cancellationMode,
+        setCancellationMode,
+        confirmCancellation,
+        cancelCancellationPrompt,
+        scheduleWarningPrompt,
+        confirmScheduleWarning,
+        cancelScheduleWarning,
+        tasksScrollRef,
+        setTasksScrollPos, // Export if needed
+        // Export
+        exportEnvironment,
+        setExportEnvironment,
+        exportWorkflowsPath,
+        setExportWorkflowsPath,
+        exportSpecialistsPath,
+        setExportSpecialistsPath,
+        exportResult,
+        handleExportResources,
+        exportingResource,
+        // Categories & Types & Taxonomies mgmt
+        handleUpdateCategory,
+        handleRemoveCategory,
+        handleSaveCategory, // Expose manually
+        handleUpdateCategoryIcon,
+        handleUpdateCategoryColor,
+        handleSaveType,
+        handleRemoveType,
+        handleUpdateTaxonomies,
+        handleUpdatePriorities,
+        handleUpdateApproaches,
+        pathValidation,
+        validatePaths,
+        getCategoryPaths,
+        customCategories,
+        setCustomCategories,
+        projectRoot, // Export (needed for settings)
+        projectName, // Export
+        mcpScriptPath, // Export
+        serverHostRoot, // Export
+        // Refs
+        commentsEndRef,
+        // Memoized Derived State
+        currentTask,
+        currentTaskParent,
+        currentTaskChildren,
+        availableWorkflows,
+        initiativeTemplates,
+        availableEnvironments,
+        fetchWorkflows,
+        fetchInitiativeTemplates,
+        fetchWorkflowTemplate,
+        fetchWorkflowOverrideNames,
+        saveWorkflowTemplateDraft,
+        resetWorkflowTemplateDraft,
+        onExportWorkflows: handleExportWorkflows,
+        settingsModel
+    };
+}