@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/components/views/StandaloneLayout.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import React, { useMemo, useCallback, useState, useEffect, useRef, Suspense } from 'react';
+import React, { useMemo, useCallback, useState, useEffect, useRef, useLayoutEffect, Suspense } from 'react';
 import { createPortal } from 'react-dom';
 import { useLocation, useNavigate } from 'react-router-dom';
-import { Settings, Plus, Filter, Layers, User, Maximize2, Minimize2, Check, ChevronLeft, ArrowUp, ArrowDown, ArrowUpDown, AlertTriangle, Save, Loader2, Folder, FileText, LogOut, NotebookTabs, ClipboardCheck, Cloud, CloudOff, Users, ClockAlert, Mail, ChevronsUp, ChevronsDown, EyeOff, Zap, HelpCircle, Bot, Image, Workflow, Plug } from 'lucide-react';
+import { Settings, Plus, Filter, Layers, User, Maximize2, Minimize2, Check, X, ChevronLeft, ChevronRight, ArrowUp, ArrowDown, ArrowUpDown, AlertTriangle, Save, Loader2, Folder, FileText, LogOut, NotebookTabs, ClipboardCheck, Cloud, CloudOff, Users, ClockAlert, ChevronsUp, ChevronsDown, EyeOff, Zap, HelpCircle, Bot, Image, Plug, Workflow } from 'lucide-react';
 import { STATUS_OPTIONS, getStatusDefinition } from '../../utils/constants';
 import styles from '../../Taskforce.module.css';
 import shellStyles from './WorkspaceShell.module.css';
@@ -11,45 +11,62 @@ import authStyles from './AuthShell.module.css';
 import folderBrowserStyles from './FolderBrowser.module.css';
 import modalStyles from '../ui/Modal.module.css';
 import { CreateWorkspaceConfirmModal } from './standalone/modals/CreateWorkspaceConfirmModal';
-import { AccountHubModal } from './standalone/modals/AccountHubModal';
+import { AccountSettingsModal } from './standalone/modals/AccountSettingsModal';
 import { AvatarImageManagerModal } from './standalone/modals/AvatarImageManagerModal';
-import { EditProfileModal } from './standalone/modals/EditProfileModal';
 import { HelpModal } from './standalone/modals/HelpModal';
 import { ScheduleWarningModal } from './standalone/modals/ScheduleWarningModal';
 import { SyncEnableWarningModal } from './standalone/modals/SyncEnableWarningModal';
 import { SyncStatusModal } from './standalone/modals/SyncStatusModal';
 import { TeamManagementModal } from './standalone/modals/TeamManagementModal';
+import { getDeletedTaskExpiresAt } from '../../shared/deletedTaskRetention';
 import { Modal } from '../ui/Modal';
+import { DiscardChangesDialog } from '../ui/DiscardChangesDialog';
 import { TaskForm } from '../task/TaskForm';
+import { AttachmentPreviewHost } from '../context/AttachmentPreviewHost';
 import { TaskKanban } from '../task/TaskKanban';
 import { TaskActionHeader } from '../task/TaskActionHeader';
+import { TrashRestoreControls } from '../task/TrashRestoreControls';
 import { TopNoticeLayer } from '../ui/TopNoticeLayer';
 import { TypeMeta } from '../../utils/constants';
 import { resolveDraftDefaultsForGrouping } from '../../utils/taskDraftDefaults';
 import { formatDate } from '../../utils/formatting';
-import { resolveHeaderWorkspaceSyncPresentation } from '../../utils/workspaceSyncPresentation';
+import { resolveCoordinatorWorkspaceSyncPresentation, resolveHeaderWorkspaceSyncPresentation, } from '../../utils/workspaceSyncPresentation';
 import { getTaskReferenceLabel, parseTaskReference } from '../../utils/taskReferences';
+import { useTaskReferenceContract } from '../../hooks/tasks/useTaskReferenceContract';
+import { useTrashSelection } from '../../hooks/tasks/useTrashSelection';
 import { normalizeTaskSearchQuery, taskMatchesSearch } from '../../utils/taskSearch';
+import { matchesTaskHeaderQuickFilter, useTaskHeaderQuickFilter } from '../../utils/taskHeaderQuickFilter';
 import { formatInitiativeReference, formatWorkstreamReference, parseWorkstreamReference, resolveInitiativeReference } from '../../utils/planningReferences';
 import { DEFAULT_TYPE_VALUE } from '../../shared/taxonomyDefaults.js';
 import { getImageReferenceLabel } from '../../utils/imageReferences';
+import { TASK_DEEP_LINK_QUERY_KEYS } from '../../shared/taskDeepLinks';
 import { isPlanningEntityVisibleForScope, scopePlanningSummaries, scopeTasksToPlanningSelection } from './planningScope';
-import { buildReferenceMismatchSummaries, buildSyncDiagnosticsSummary, buildSyncEventRows, getActiveReferenceMismatchCount, resolveSyncStageLabel, resolveSyncStatusMeta, } from '../../utils/syncStatusPresentation';
+import { buildReferenceMismatchSummaries, buildSyncDiagnosticsSummary, buildSyncEventRows, getActiveReferenceMismatchCount, resolveSyncStageLabel, resolveSyncStatusMeta, resolveHeaderSyncStatusMeta, } from '../../utils/syncStatusPresentation';
 import { buildCustomTaxonomySortOptions } from '../../utils/taxonomySorting.js';
 import { getLocale, t } from '../../localization';
-import { resolveAnnotatedAttachmentDetail } from '../../utils/annotatedAttachments';
+import { getAnnotatedAttachmentContextIdentity, resolveAnnotatedAttachmentDetail, shouldApplyPersistedAnnotatedAttachmentContext, } from '../../utils/annotatedAttachments';
+import { dispatchPreviewContextAttachment } from '../../utils/contextAttachmentPreview';
+import { parseCanonicalEntityReference, } from '../../utils/entityReferences';
+import { resolveCanonicalAttachmentReference } from '../../utils/canonicalReferenceAttachments';
 import { ACCOUNT_PROFILE_SUMMARY_PATH, invalidateAccountProfileSummaryCache, loadAccountProfileSummaryCached } from '../../utils/accountProfileSummaryCache';
 import { prepareAvatarUploadFile } from '../../utils/avatarUpload';
 import { resolveCommercialLifecyclePresentation } from '../../utils/commercialLifecyclePresentation';
 import { buildSupportMailtoHref } from '../../utils/supportContact';
+import { mergePlanningLifetimeTasks, resolveInitiativeArchiveReadiness, resolveWorkstreamArchiveReadiness, } from '../../utils/planningArchiveReadiness';
+import { archiveResolvedInitiativeHierarchy, archiveResolvedWorkstreamHierarchy, } from '../../utils/planningArchiveOrchestrator';
+import { resolvePlanningArchiveDetailState } from '../../utils/planningArchivePresentation';
 import { AppShellHeader } from './AppShellHeader';
 import { getTaskforceCloudEnvironmentConfig, parseTaskforceCloudEnvironment, resolveTaskforceCloudEnvironmentFromBaseUrl } from '../../config/cloudEnvironment';
-import { logBootstrapDebug, persistRemoteUiState } from '../../hooks/workspace/workspaceLocalState';
+import { logBootstrapDebug } from '../../hooks/workspace/workspaceLocalState';
+import { buildLayoutUiStateLoadKey, usePersistedLayoutUiState, } from '../../hooks/workspace/usePersistedLayoutUiState';
+import { togglePlanningFavorite } from '../../utils/planningFavorites';
 import { FilterToolbar } from './panels/FilterToolbar';
-import { DocumentFilterToolbar } from './panels/DocumentFilterToolbar';
 import { PlanningDrawer, getPlanningDrawerWidthPx, } from './panels/PlanningDrawer';
+import { normalizePlanningTaskArrangeMode, } from '../features/planning/planningTaskArrangement';
+import { resolveWorkstreamCreateInitiativeId } from '../features/planning/planningCreateIntent';
+import { shouldUsePlanningBootstrapTaskSummaries } from '../features/planning/planningWorkspaceModel';
 import { getWorkspaceChromeDefinition, getWorkspaceModuleDefinitions, resolveWorkspaceModule, } from './chrome/workspaceChrome';
-import { EmptyWorkspaceFilterBar, WorkspaceHeaderActions, WorkspaceHeaderDivider, WorkspaceHeaderSearch, WorkspaceHeaderSelect, WorkspacePrimaryAction, } from './chrome/WorkspaceChromeSections';
+import { WorkspaceHeaderActions, WorkspaceHeaderDivider, WorkspaceHeaderSearch, WorkspaceHeaderSelect, WorkspacePrimaryAction, } from './chrome/WorkspaceChromeSections';
 import { ScheduleSidebar, SCHEDULE_SIDEBAR_WIDTH_PX } from './panels/ScheduleSidebar';
 import { DOCUMENT_ATTACHMENT_FILTER_OPTIONS, DOCUMENT_TYPE_FILTER_OPTIONS, } from '../features/documentWorkspaceFilters';
 import { canManageTeamWorkspace as computeCanManageTeamWorkspace, canOpenTeamManagement as computeCanOpenTeamManagement } from './teamManagementAccess';
@@ -57,17 +74,29 @@ import { useRecentSyncEvents } from '../../hooks/sync/useRecentSyncEvents';
 import { useSyncStatusActions } from '../../hooks/sync/useSyncStatusActions';
 import { useSyncStatusControls } from '../../hooks/sync/useSyncStatusControls';
 import { toDateOnlyLocal, parseDateOnlyLocal, startOfWeek, getDayOffsetFromWeekStart, addDays, dateOnlyToIsoWeekKey, SCHEDULE_DAY_KEYS, SCHEDULE_DAY_LABELS, } from './panels/scheduleUtils';
-import { AGENTS_WORKSPACE_FEATURE_KEY, ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, DOCUMENT_WORKSPACE_FEATURE_KEY, INITIATIVES_WORKSPACE_FEATURE_KEY, WORKFLOWS_WORKSPACE_FEATURE_KEY, resolveFeatureAccess, } from '../../runtime/appGates';
+import { AI_PROFILES_WORKSPACE_FEATURE_KEY, ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, DOCUMENT_WORKSPACE_FEATURE_KEY, PLANNING_WORKSPACE_FEATURE_KEY, TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY, resolveFeatureAccess, } from '../../runtime/appGates';
 // Heavy feature modules — lazy-loaded to reduce the initial app chunk size.
 const TaskSettings = React.lazy(() => import('../features/TaskSettings').then(m => ({ default: m.TaskSettings })));
 const AnnotatedAttachmentWorkspaceShell = React.lazy(() => import('../features/AnnotatedAttachmentWorkspace').then(m => ({ default: m.AnnotatedAttachmentWorkspaceShell })));
 const DocumentWorkspaceShell = React.lazy(() => import('../features/DocumentWorkspace').then(m => ({ default: m.DocumentWorkspaceShell })));
-const WorkflowsModule = React.lazy(() => import('../features/WorkflowsModule').then(m => ({ default: m.WorkflowsModule })));
-const AgentsModule = React.lazy(() => import('../features/AgentsModule').then(m => ({ default: m.AgentsModule })));
-const InitiativesModule = React.lazy(() => import('../features/InitiativesModule').then(m => ({ default: m.InitiativesModule })));
+const TaskforceAgentsModule = React.lazy(() => import('../features/TaskforceAgentsModule').then(m => ({ default: m.TaskforceAgentsModule })));
+const WorkflowManagerModule = React.lazy(() => import('../features/workflowManager/WorkflowManagerModule').then(m => ({ default: m.WorkflowManagerModule })));
+const AiProfilesModule = React.lazy(() => import('../features/AiProfilesModule').then(m => ({ default: m.AiProfilesModule })));
+const PlanningModule = React.lazy(() => import('../features/planning/PlanningModule').then(m => ({ default: m.PlanningModule })));
 const PlansPage = React.lazy(() => import('./PlansPage').then(m => ({ default: m.PlansPage })));
+const MAX_REMEMBERED_LAYOUT_ITEMS = 50;
+function withBoundedRecordEntry(current, key, value) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey)
+        return current;
+    const next = { ...current };
+    delete next[normalizedKey];
+    next[normalizedKey] = value;
+    return Object.fromEntries(Object.entries(next).slice(-MAX_REMEMBERED_LAYOUT_ITEMS));
+}
 const PROFILE_AVATAR_ACCEPT = 'image/png,image/jpeg,image/webp,image/gif';
 const PROFILE_AVATAR_MAX_BYTES = 5 * 1024 * 1024;
+const TASKFORCE_AGENT_DRAWER_FALLBACK_TOP = 56;
 const resolveSameOriginTaskforcePath = (path) => path;
 function resolveConnectedEnvironmentLabel(explicitEnvironment, candidates) {
     const parsedExplicitEnvironment = parseTaskforceCloudEnvironment(explicitEnvironment);
@@ -140,13 +169,13 @@ export function StandaloneLayout(props) {
     // State
     activeTab, setActiveTab, activeCategories, groupBy, setGroupBy, activeWorkspaceModule, setActiveWorkspaceModule, emptyColumnMode, setEmptyColumnMode, zenMode, setZenMode, filterStatus, setFilterStatus, 
     // Data & Actions
-    tasks, handleEdit, handleSubmit, resetForm, handleUpdateTask, 
+    tasks, handleEdit, handleSubmit, resetForm, handleUpdateTask, handleSetStatus: handleSetStatusDurably, 
     // Form State (destructure all needed for TaskForm)
-    editingTaskId, loading, error, title, setTitle, description, setDescription, checklistItems, setChecklistItems, category, setCategory, type, setType, priority, setPriority, complexity, setComplexity, setStatus, approach, setApproach, assignee, setAssignee, scheduledDate, setScheduledDate, dueDate, setDueDate, workstreamInput, setWorkstreamInput, manualComplexityEnabled, checklistDropdownEnabled, showTaskCardStatusLabel, formTaxonomies, setFormTaxonomies, comments, newCommentText, setNewCommentText, attachments, setAttachments, setAttachmentsDirty, descriptionFocused, setDescriptionFocused, showMarkdownHelp, setShowMarkdownHelp, showChecklist, setShowChecklist, showComments, setShowComments, 
+    editingTaskId, loading, error, title, setTitle, setTitleDraft, description, setDescription, setDescriptionDraft, checklistItems, setChecklistItems, category, setCategory, type, setType, priority, setPriority, complexity, setComplexity, status, setStatus, assignee, setAssignee, scheduledDate, setScheduledDate, dueDate, setDueDate, workstreamInput, setWorkstreamInput, manualComplexityEnabled, checklistDropdownEnabled, showTaskCardStatusLabel, formTaxonomies, setFormTaxonomies, comments, newCommentText, setNewCommentText, attachments, setAttachments, setAttachmentsDirty, descriptionFocused, setDescriptionFocused, showMarkdownHelp, setShowMarkdownHelp, 
     // Form Actions
     handleAddComment, handleSetWorkstreamForCurrentTask, handleOpenTaskById, 
     // Other Props for Form
-    taxonomies, activeTypes, priorities, taxonomyDisplayLabels, approaches, copiedId, handleCopyId, handleToggleInProgress, handleToggleComplete, handleToggleReview, handleToggleCancel, handleArchiveTask, handleDelete, handleUnarchive, handleRestoreDeletedTask, handlePermanentlyDeleteDeletedTask, handleEmptyDeletedTasks, fetchTasks, searchQuery, setSearchQuery, filterCategories, setFilterCategories, filterTypes, setFilterTypes, filterPriorities, setFilterPriorities, filterAssignees, setFilterAssignees, hasInitedFilters, assigneeOptions, taskScope, setTaskScope, 
+    taxonomies, activeTypes, priorities, taxonomyDisplayLabels, copiedId, handleCopyId, handleToggleInProgress, handleToggleComplete, handleToggleReview, handleToggleCancel, handleArchiveTask, handleDelete, handleUnarchive, handleRestoreDeletedTask, handleRestoreSelectedDeletedTasks, handlePermanentlyDeleteDeletedTask, handleEmptyDeletedTasks, fetchTasks, searchQuery, setSearchQuery, filterCategories, setFilterCategories, filterTypes, setFilterTypes, filterPriorities, setFilterPriorities, filterAssignees, setFilterAssignees, hasInitedFilters, assigneeOptions, taskScope, setTaskScope, compressedCards, setCompressedCards, 
     // filterStatus, setFilterStatus, // This was duplicated, removed one instance
     sortBy, setSortBy, clearFilters, // setSearchQuery, // This was duplicated, removed one instance
     // filterCategories, setFilterCategories, // This was duplicated, removed one instance
@@ -157,19 +186,18 @@ export function StandaloneLayout(props) {
     // clearFilters, // This was duplicated, removed one instance
     // activeTypes, // This was duplicated, removed one instance
     // Settings State & Props
-    settingsModel, configLoaded, currentTheme, setCurrentTheme, pathSaved, saveSettings, keyShortcut, setKeyShortcut, globalWeekStartsOn, locale, jsonBackupEnabled, setJsonBackupEnabled, mcpHostRoot, setMcpHostRoot, settingsSection, setSettingsSection, runtimeMode, workspaceSwitchingEnabled, cloudAuthConfigured, authRequiredForApi, authBlocked, isAuthenticated, authUserId, authWorkspaceId, authUserEmail, authUserDisplayName, authUserAvatarUrl, authSessionResolved, realtimeSyncEnabled, realtimeSyncFlagSource, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, saveWorkspaceCloudSyncSettings, pushNotice, userGlobalSyncStatus, workspaceLastSuccessfulSyncAt, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, userGlobalSyncError, workspaceLastErrorMessage, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics, currentWorkspaceId, currentWorkspaceRole, availableWorkspaces, switchWorkspace, updateCurrentUserProfile, resolveCloudAuthUrl = resolveSameOriginTaskforcePath, logout, fetchLoginMethods, unlinkLoginMethod, addPasswordToAccount, beginOAuthLogin, beginOAuthLink, availableAuthProviders, projectRoot, projectName, mcpScriptPath, serverHostRoot, 
+    settingsModel, configLoaded, currentTheme, setCurrentTheme, pathSaved, saveSettings, keyShortcut, setKeyShortcut, globalWeekStartsOn, locale, jsonBackupEnabled, setJsonBackupEnabled, mcpHostRoot, setMcpHostRoot, settingsSection, setSettingsSection, runtimeMode, workspaceSwitchingEnabled, cloudAuthConfigured, authRequiredForApi, authBlocked, isAuthenticated, authUserId, authWorkspaceId, authUserEmail, authUserDisplayName, authUserAvatarUrl, authSessionResolved, realtimeSyncEnabled, realtimeSyncFlagSource, workspaceCloudSyncEnabled, workspaceSyncPhase, workspaceSyncStatus, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncBusy, workspaceSyncPendingChanges, localCoordinatorStatus, transferLocalCoordinatorOwnership, saveWorkspaceCloudSyncSettings, pushNotice, userGlobalSyncStatus, workspaceLastSuccessfulSyncAt, workspaceLastPullAt, workspaceLastPushAt, workspaceLastErrorAt, userGlobalSyncError, workspaceLastErrorMessage, retryWorkspaceCloudSync, resetWorkspaceSyncCursorAndPull, getWorkspaceSyncDiagnostics, currentWorkspaceId, currentWorkspaceRole, availableWorkspaces, switchWorkspace, updateCurrentUserProfile, resolveCloudAuthUrl = resolveSameOriginTaskforcePath, logout, fetchLoginMethods, unlinkLoginMethod, addPasswordToAccount, changePassword, beginOAuthLogin, beginOAuthLink, availableAuthProviders, projectRoot, projectName, mcpScriptPath, serverHostRoot, 
     // Browser Props
     showFolderBrowser, setShowFolderBrowser, folders, files, currentBrowsePath, fetchFolders, browserTarget, setBrowserTarget, handleSelectPath, handleAddPath, handleRemovePath, 
     // Settings Managers
-    handleUpdateCategory, handleRemoveCategory, handleSaveCategory, handleUpdateCategoryIcon, handleUpdateCategoryColor, handleSaveType, handleRemoveType, handleUpdateTaxonomies, handleUpdatePriorities, pathValidation, 
-    // Exports
-    exportEnvironment, setExportEnvironment, exportWorkflowsPath, setExportWorkflowsPath, exportResult, exportingResource, availableWorkflows, onExportWorkflows, fetchWorkflows, availableEnvironments, initiativeTemplates, fetchInitiativeTemplates, createInitiativeFromTemplate, 
+    handleUpdateCategory, handleRemoveCategory, handleSaveCategory, handleUpdateCategoryIcon, handleUpdateCategoryColor, handleSaveType, handleRemoveType, handleUpdateTaxonomies, handleUpdatePriorities, pathValidation, taskforceAgentId, setTaskforceAgentId, taskforceAgentConversationId, setTaskforceAgentConversationId, taskforceAgentConversationByAgentId, setTaskforceAgentConversationByAgentId, uiStateReady, initiativeTemplates, fetchInitiativeTemplates, createInitiativeFromTemplate, 
     // Misc
-    uiNotice, clearNotice, taskReturnTrail, clearReturnToParentTask, returnToPreviousTask, tasksScrollRef, setTasksScrollPos, 
+    uiNotice, clearNotice, clearTaskError, taskReturnTrail, clearReturnToParentTask, returnToPreviousTask, tasksScrollRef, setTasksScrollPos, 
     // Refs
     commentsEndRef, 
     // Modals - Unsaved Changes
     autoSaveState, unsavedModalOpen, setUnsavedModalOpen, pendingNavigation, handleNavigation, currentTask, currentTaskWorkstream, currentTaskInitiative, scheduleWarningPrompt, confirmScheduleWarning, cancelScheduleWarning } = props;
+    const taskReferences = useTaskReferenceContract(tasks, handleOpenTaskById);
     const resolvedLocale = locale || getLocale();
     useEffect(() => {
         const normalizedProject = String(projectName || '').trim();
@@ -198,8 +226,6 @@ export function StandaloneLayout(props) {
             pendingNavigation();
         }
     };
-    // State for Card Compression
-    const [compressedCards, setCompressedCards] = useState(false);
     const [scheduleShowWeekends, setScheduleShowWeekends] = useState(false);
     const [scheduleShowBacklog, setScheduleShowBacklog] = useState(true);
     const [scheduleOnlyExpired, setScheduleOnlyExpired] = useState(false);
@@ -213,17 +239,32 @@ export function StandaloneLayout(props) {
     const [showFilters, setShowFilters] = useState(false);
     const [taskModalFullscreen, setTaskModalFullscreen] = useState(false);
     const [planningDrawerOpen, setPlanningDrawerOpen] = useState(false);
+    const planningDrawerLauncherRef = useRef(null);
     const [documentTrayOpen, setDocumentTrayOpen] = useState(true);
     const [imageTrayOpen, setImageTrayOpen] = useState(true);
     const [agentTrayOpen, setAgentTrayOpen] = useState(true);
+    const [taskforceAgentRosterTrayOpen, setTaskforceAgentRosterTrayOpen] = useState(true);
+    const [workflowLibraryTrayOpen, setWorkflowLibraryTrayOpen] = useState(true);
+    const [workflowManagerHasUnsavedChanges, setWorkflowManagerHasUnsavedChanges] = useState(false);
+    const [pendingWorkflowDiscardAction, setPendingWorkflowDiscardAction] = useState(null);
+    const workflowDiscardBypassRef = useRef(false);
+    const appShellHeaderRef = useRef(null);
+    const [taskforceAgentDrawerTop, setTaskforceAgentDrawerTop] = useState(TASKFORCE_AGENT_DRAWER_FALLBACK_TOP);
     const [planningTreeCollapsed, setPlanningTreeCollapsed] = useState(false);
     const [planningPrimaryCollapsed, setPlanningPrimaryCollapsed] = useState(false);
     const [planningSecondaryCollapsed, setPlanningSecondaryCollapsed] = useState(false);
+    const [planningFavoritesSectionCollapsed, setPlanningFavoritesSectionCollapsed] = useState(false);
+    const [planningInitiativesSectionCollapsed, setPlanningInitiativesSectionCollapsed] = useState(false);
+    const [planningWorkstreamsSectionCollapsed, setPlanningWorkstreamsSectionCollapsed] = useState(false);
+    const [planningNavigatorSort, setPlanningNavigatorSort] = useState('default');
+    const [planningTaskArrangeMode, setPlanningTaskArrangeMode] = useState('execution');
+    const [planningFavorites, setPlanningFavorites] = useState([]);
     const [selectedPlanningInitiativeId, setSelectedPlanningInitiativeId] = useState('');
     const [selectedPlanningWorkstreamId, setSelectedPlanningWorkstreamId] = useState('');
     const [expandedPlanningInitiativeIds, setExpandedPlanningInitiativeIds] = useState(new Set());
     const [planningDrawerDetail, setPlanningDrawerDetail] = useState(null);
     const [planningNestedWorkstreamDetailId, setPlanningNestedWorkstreamDetailId] = useState(null);
+    const [planningHydrationStateByEntity, setPlanningHydrationStateByEntity] = useState({});
     const [planningEditor, setPlanningEditor] = useState(null);
     const [planningSecondaryEditor, setPlanningSecondaryEditor] = useState(null);
     const [planningDraftTitle, setPlanningDraftTitle] = useState('');
@@ -235,21 +276,36 @@ export function StandaloneLayout(props) {
         taskId: null,
         attachments: [],
     });
+    const todayDateOnly = useMemo(() => toDateOnlyLocal(new Date()), []);
+    const normalizedAuthUserId = String(authUserId || '').trim();
+    const { taskHeaderQuickFilter, toggleTaskHeaderQuickFilter, clearTaskHeaderQuickFilter, } = useTaskHeaderQuickFilter({
+        authUserId: normalizedAuthUserId,
+        workspaceId: currentWorkspaceId,
+        taskScope,
+    });
     const planningContextAttachmentDraftsRef = useRef(new Map());
     const planningContextAttachmentUpdateQueueRef = useRef(new Map());
     const [documentTypeFilters, setDocumentTypeFilters] = useState(() => DOCUMENT_TYPE_FILTER_OPTIONS.map((option) => option.value));
     const [documentAttachmentFilters, setDocumentAttachmentFilters] = useState(() => DOCUMENT_ATTACHMENT_FILTER_OPTIONS.map((option) => option.value));
+    const [documentSortField, setDocumentSortField] = useState('updated');
+    const [documentSortOrder, setDocumentSortOrder] = useState('desc');
+    const [documentPinnedDocIds, setDocumentPinnedDocIds] = useState([]);
+    const [documentSearchQuery, setDocumentSearchQuery] = useState('');
+    const [documentSelectedDocId, setDocumentSelectedDocId] = useState(null);
+    const [documentScrollByDocId, setDocumentScrollByDocId] = useState({});
+    const [documentListScrollTop, setDocumentListScrollTop] = useState(0);
     const [requestedDocPath, setRequestedDocPath] = useState(null);
     const [requestedDocAssetId, setRequestedDocAssetId] = useState(null);
     const [requestedAnnotatedTarget, setRequestedAnnotatedTarget] = useState(null);
     const [requestedAnnotatedSessionId, setRequestedAnnotatedSessionId] = useState(null);
+    const [annotatedViewportByContextKey, setAnnotatedViewportByContextKey] = useState({});
     const [requestedAnnotatedOpenVersion, setRequestedAnnotatedOpenVersion] = useState(0);
+    const handledEntityDeepLinkRef = useRef(null);
     const [canonicalAnnotatedImageReferenceLabels, setCanonicalAnnotatedImageReferenceLabels] = useState({});
-    const [layoutStateReady, setLayoutStateReady] = useState(false);
     const planningEditorSubmitInFlightRef = useRef(false);
-    const loadedLayoutStateWorkspaceRef = useRef('');
     const requestedAnnotatedTargetRef = useRef(null);
     const requestedAnnotatedSessionIdRef = useRef(null);
+    const lastHydratedAnnotatedContextIdentityRef = useRef(null);
     const annotatedImageReferenceFetchesRef = useRef(new Set());
     useEffect(() => {
         taskContextAttachmentDraftRef.current = {
@@ -269,7 +325,15 @@ export function StandaloneLayout(props) {
         setAttachments(nextAttachments);
         setAttachmentsDirty(true);
         if (taskId) {
-            void handleUpdateTask(taskId, { attachments: nextAttachments });
+            void handleUpdateTask(taskId, { attachments: nextAttachments }).then((saved) => {
+                const latestDraft = taskContextAttachmentDraftRef.current;
+                if (saved !== false && latestDraft.taskId === taskId
+                    && latestDraft.attachments === nextAttachments) {
+                    setAttachmentsDirty(false);
+                }
+            }).catch(() => {
+                // Keep the attachment draft dirty so the editor can retry it.
+            });
         }
     }, [attachments, editingTaskId, handleUpdateTask, setAttachments, setAttachmentsDirty]);
     const workspaceUiStateHeaders = useMemo(() => {
@@ -280,8 +344,15 @@ export function StandaloneLayout(props) {
         }
         return headers;
     }, [runtimeMode, currentWorkspaceId]);
-    const layoutStateWorkspaceKey = useMemo(() => `${runtimeMode}:${String(currentWorkspaceId || 'default').trim() || 'default'}`, [runtimeMode, currentWorkspaceId]);
-    const annotatedLayoutCacheKey = useMemo(() => `taskforce:annotate-layout:${layoutStateWorkspaceKey}`, [layoutStateWorkspaceKey]);
+    const layoutStateWorkspaceKey = useMemo(() => buildLayoutUiStateLoadKey({
+        runtimeMode,
+        workspaceId: currentWorkspaceId,
+        userId: normalizedAuthUserId,
+    }), [currentWorkspaceId, normalizedAuthUserId, runtimeMode]);
+    const annotatedContextScopeRef = useRef(layoutStateWorkspaceKey);
+    const annotatedContextMatchesLayoutScope = annotatedContextScopeRef.current === layoutStateWorkspaceKey;
+    const scopedRequestedAnnotatedTarget = annotatedContextMatchesLayoutScope ? requestedAnnotatedTarget : null;
+    const scopedRequestedAnnotatedSessionId = annotatedContextMatchesLayoutScope ? requestedAnnotatedSessionId : null;
     const taskOriginWorkspaceModuleKey = useMemo(() => `taskforce:task-origin-workspace-module:${layoutStateWorkspaceKey}`, [layoutStateWorkspaceKey]);
     const annotatedWorkspaceReady = useMemo(() => (runtimeMode === 'cloud' ? authSessionResolved : configLoaded), [authSessionResolved, configLoaded, runtimeMode]);
     const openedTaskOriginWorkspaceModuleRef = useRef(false);
@@ -315,6 +386,16 @@ export function StandaloneLayout(props) {
     useEffect(() => {
         requestedAnnotatedSessionIdRef.current = requestedAnnotatedSessionId;
     }, [requestedAnnotatedSessionId]);
+    useEffect(() => {
+        if (annotatedContextScopeRef.current === layoutStateWorkspaceKey)
+            return;
+        annotatedContextScopeRef.current = layoutStateWorkspaceKey;
+        requestedAnnotatedTargetRef.current = null;
+        requestedAnnotatedSessionIdRef.current = null;
+        lastHydratedAnnotatedContextIdentityRef.current = null;
+        setRequestedAnnotatedTarget(null);
+        setRequestedAnnotatedSessionId(null);
+    }, [layoutStateWorkspaceKey]);
     const workspaceFeatureAccess = useMemo(() => ({
         [DOCUMENT_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
             featureKey: DOCUMENT_WORKSPACE_FEATURE_KEY,
@@ -324,25 +405,75 @@ export function StandaloneLayout(props) {
             featureKey: ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY,
             runtimeMode,
         }),
-        [WORKFLOWS_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
-            featureKey: WORKFLOWS_WORKSPACE_FEATURE_KEY,
+        [WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
+            featureKey: WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY,
             runtimeMode,
         }),
-        [AGENTS_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
-            featureKey: AGENTS_WORKSPACE_FEATURE_KEY,
+        [TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
+            featureKey: TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY,
             runtimeMode,
         }),
-        [INITIATIVES_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
-            featureKey: INITIATIVES_WORKSPACE_FEATURE_KEY,
+        [AI_PROFILES_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
+            featureKey: AI_PROFILES_WORKSPACE_FEATURE_KEY,
+            runtimeMode,
+        }),
+        [PLANNING_WORKSPACE_FEATURE_KEY]: resolveFeatureAccess({
+            featureKey: PLANNING_WORKSPACE_FEATURE_KEY,
             runtimeMode,
         }),
     }), [runtimeMode]);
     const workspaceModules = useMemo(() => getWorkspaceModuleDefinitions({ featureAccess: workspaceFeatureAccess }), [workspaceFeatureAccess]);
     const resolvedWorkspaceModule = useMemo(() => resolveWorkspaceModule(activeWorkspaceModule, workspaceModules), [activeWorkspaceModule, workspaceModules]);
+    const planningSurfaceVisible = planningDrawerOpen || resolvedWorkspaceModule === 'planning';
+    useEffect(() => {
+        if (!planningSurfaceVisible)
+            return;
+        void props.ensureArchiveHydrated(true);
+    }, [planningSurfaceVisible, props.ensureArchiveHydrated, currentWorkspaceId]);
+    const [taskforceAgentDrawerOpen, setTaskforceAgentDrawerOpen] = useState(false);
+    const [taskforceAgentPanelCollapsed, setTaskforceAgentPanelCollapsed] = useState(false);
+    const [taskforceAgentsLaunchContext, setTaskforceAgentsLaunchContext] = useState(null);
+    const [taskforceAgentDrawerHeaderContent, setTaskforceAgentDrawerHeaderContent] = useState(null);
+    const handleRenderTaskforceAgentDrawerHeader = useCallback((content) => {
+        setTaskforceAgentDrawerHeaderContent(content);
+    }, []);
+    const handleRememberTaskforceAgentSelection = useCallback((selection) => {
+        const nextAgentId = String(selection.agentId || '').trim();
+        const nextConversationId = String(selection.conversationId || '').trim();
+        setTaskforceAgentId(nextAgentId);
+        setTaskforceAgentConversationId(nextConversationId);
+        if (!nextAgentId)
+            return;
+        setTaskforceAgentConversationByAgentId((current) => {
+            if (nextConversationId) {
+                if (current[nextAgentId] === nextConversationId)
+                    return current;
+                return { ...current, [nextAgentId]: nextConversationId };
+            }
+            if (!current[nextAgentId])
+                return current;
+            const next = { ...current };
+            delete next[nextAgentId];
+            return next;
+        });
+    }, [setTaskforceAgentConversationByAgentId, setTaskforceAgentConversationId, setTaskforceAgentId]);
     const documentsWorkspaceEnabled = workspaceFeatureAccess[DOCUMENT_WORKSPACE_FEATURE_KEY]?.allowed ?? false;
     const annotatedAttachmentsWorkspaceEnabled = workspaceFeatureAccess[ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY]?.allowed ?? false;
+    const taskforceAgentsWorkspaceEnabled = workspaceFeatureAccess[TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY]?.allowed ?? false;
     const documentsWorkspaceUnavailableMessage = 'Documents is not available in this build yet.';
     const annotatedAttachmentsWorkspaceUnavailableMessage = 'Annotate is not available in this build yet.';
+    const handoffTaskModalToWorkspace = useCallback((action) => {
+        if (activeTab !== 'add') {
+            action();
+            return;
+        }
+        void handleNavigation(() => {
+            setTaskModalFullscreen(false);
+            resetForm();
+            setActiveTab('tasks');
+            action();
+        });
+    }, [activeTab, handleNavigation, resetForm, setActiveTab]);
     useEffect(() => {
         const handleOpenMarkdownDocument = (event) => {
             const customEvent = event;
@@ -355,16 +486,18 @@ export function StandaloneLayout(props) {
                 pushNotice(documentsWorkspaceUnavailableMessage, 'error');
                 return;
             }
-            rememberTaskOriginWorkspaceModule(customEvent.detail?.taskId);
-            setRequestedDocPath(fsPath || null);
-            setRequestedDocAssetId(assetId);
-            setActiveWorkspaceModule('docs');
+            handoffTaskModalToWorkspace(() => {
+                rememberTaskOriginWorkspaceModule(customEvent.detail?.taskId);
+                setRequestedDocPath(fsPath || null);
+                setRequestedDocAssetId(assetId);
+                setActiveWorkspaceModule('docs');
+            });
         };
         window.addEventListener('taskforce:open-markdown-document', handleOpenMarkdownDocument);
         return () => {
             window.removeEventListener('taskforce:open-markdown-document', handleOpenMarkdownDocument);
         };
-    }, [documentsWorkspaceEnabled, documentsWorkspaceUnavailableMessage, pushNotice, rememberTaskOriginWorkspaceModule, setActiveWorkspaceModule]);
+    }, [documentsWorkspaceEnabled, documentsWorkspaceUnavailableMessage, handoffTaskModalToWorkspace, pushNotice, rememberTaskOriginWorkspaceModule, setActiveWorkspaceModule]);
     useEffect(() => {
         if (resolvedWorkspaceModule !== activeWorkspaceModule) {
             setActiveWorkspaceModule(resolvedWorkspaceModule);
@@ -376,25 +509,6 @@ export function StandaloneLayout(props) {
         setRequestedDocPath(null);
         setRequestedDocAssetId(null);
     }, [documentsWorkspaceEnabled, resolvedWorkspaceModule]);
-    useEffect(() => {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            const cachedRaw = window.sessionStorage.getItem(annotatedLayoutCacheKey);
-            if (!cachedRaw)
-                return;
-            const cached = JSON.parse(cachedRaw);
-            if (cached?.annotatedTarget && typeof cached.annotatedTarget === 'object') {
-                setRequestedAnnotatedTarget(cached.annotatedTarget);
-            }
-            if (typeof cached?.annotatedSessionId === 'string') {
-                setRequestedAnnotatedSessionId(cached.annotatedSessionId.trim() || null);
-            }
-        }
-        catch {
-            // ignore cache read failure
-        }
-    }, [annotatedLayoutCacheKey]);
     useEffect(() => {
         if (taskOriginWorkspaceModuleRestoreHandledRef.current)
             return;
@@ -418,161 +532,126 @@ export function StandaloneLayout(props) {
         taskOriginWorkspaceModuleRestoreHandledRef.current = false;
         openedTaskOriginWorkspaceModuleRef.current = false;
     }, [taskOriginWorkspaceModuleKey]);
-    useEffect(() => {
-        if (loadedLayoutStateWorkspaceRef.current === layoutStateWorkspaceKey)
-            return;
-        loadedLayoutStateWorkspaceRef.current = layoutStateWorkspaceKey;
-        setLayoutStateReady(false);
-        let cancelled = false;
-        const loadLayoutUiState = async () => {
-            try {
-                const res = await fetch('/api/taskforce/ui-state?key=layout', {
-                    method: 'GET',
-                    credentials: 'include',
-                    headers: workspaceUiStateHeaders
-                });
-                if (!res.ok)
-                    return;
-                const data = await res.json().catch(() => ({}));
-                const state = (data?.state && typeof data.state === 'object')
-                    ? data.state
-                    : null;
-                if (!state || cancelled)
-                    return;
-                if (typeof state.scheduleShowWeekends === 'boolean')
-                    setScheduleShowWeekends(state.scheduleShowWeekends);
-                if (typeof state.scheduleShowBacklog === 'boolean')
-                    setScheduleShowBacklog(state.scheduleShowBacklog);
-                if (typeof state.scheduleOnlyExpired === 'boolean')
-                    setScheduleOnlyExpired(state.scheduleOnlyExpired);
-                if (typeof state.scheduleSidebarOpen === 'boolean')
-                    setScheduleSidebarOpen(state.scheduleSidebarOpen);
-                if (typeof state.scheduleSelectedDate === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(state.scheduleSelectedDate)) {
-                    setScheduleSelectedDate(state.scheduleSelectedDate);
-                }
-                if (typeof state.scheduleCalendarMonth === 'string' && /^\d{4}-\d{2}$/.test(state.scheduleCalendarMonth)) {
-                    setScheduleCalendarMonth(state.scheduleCalendarMonth);
-                }
-                if (typeof state.scheduleScrollLeft === 'number' && Number.isFinite(state.scheduleScrollLeft) && state.scheduleScrollLeft >= 0) {
-                    setScheduleScrollLeft(state.scheduleScrollLeft);
-                }
-                if (typeof state.showFilters === 'boolean')
-                    setShowFilters(state.showFilters);
-                if (Array.isArray(state.documentTypeFilters)) {
-                    setDocumentTypeFilters(state.documentTypeFilters);
-                }
-                if (Array.isArray(state.documentAttachmentFilters)) {
-                    setDocumentAttachmentFilters(state.documentAttachmentFilters);
-                }
-                if (typeof state.planningDrawerOpen === 'boolean') {
-                    setPlanningDrawerOpen(state.planningDrawerOpen);
-                }
-                if (typeof state.documentTrayOpen === 'boolean') {
-                    setDocumentTrayOpen(state.documentTrayOpen);
-                }
-                if (typeof state.imageTrayOpen === 'boolean') {
-                    setImageTrayOpen(state.imageTrayOpen);
-                }
-                if (typeof state.agentTrayOpen === 'boolean') {
-                    setAgentTrayOpen(state.agentTrayOpen);
-                }
-                if (typeof state.planningTreeCollapsed === 'boolean') {
-                    setPlanningTreeCollapsed(state.planningTreeCollapsed);
-                }
-                if (typeof state.planningPrimaryCollapsed === 'boolean') {
-                    setPlanningPrimaryCollapsed(state.planningPrimaryCollapsed);
-                }
-                if (typeof state.planningSecondaryCollapsed === 'boolean') {
-                    setPlanningSecondaryCollapsed(state.planningSecondaryCollapsed);
-                }
-                if (Array.isArray(state.planningExpandedInitiativeIds)) {
-                    setExpandedPlanningInitiativeIds(new Set(state.planningExpandedInitiativeIds
-                        .map((value) => String(value || '').trim())
-                        .filter(Boolean)));
-                }
-                if (state.planningDrawerDetail
-                    && typeof state.planningDrawerDetail === 'object'
-                    && (state.planningDrawerDetail.type === 'initiative' || state.planningDrawerDetail.type === 'workstream')
-                    && typeof state.planningDrawerDetail.id === 'string') {
-                    const detailId = state.planningDrawerDetail.id.trim();
-                    setPlanningDrawerDetail(detailId ? { type: state.planningDrawerDetail.type, id: detailId } : null);
-                }
-                else if (state.planningDrawerDetail === null) {
-                    setPlanningDrawerDetail(null);
-                }
-                if (typeof state.planningNestedWorkstreamDetailId === 'string') {
-                    setPlanningNestedWorkstreamDetailId(state.planningNestedWorkstreamDetailId.trim() || null);
-                }
-                else if (state.planningNestedWorkstreamDetailId === null) {
-                    setPlanningNestedWorkstreamDetailId(null);
-                }
-                const annotatedTarget = state.annotatedTarget;
-                if (annotatedTarget && typeof annotatedTarget === 'object') {
-                    if (!requestedAnnotatedTargetRef.current) {
-                        setRequestedAnnotatedTarget(annotatedTarget);
-                    }
-                }
-                if (typeof state.annotatedSessionId === 'string') {
-                    if (!requestedAnnotatedSessionIdRef.current) {
-                        setRequestedAnnotatedSessionId(state.annotatedSessionId.trim() || null);
-                    }
-                }
-            }
-            catch {
-                // ignore read failure
-            }
-            finally {
-                if (!cancelled)
-                    setLayoutStateReady(true);
-            }
-        };
-        loadLayoutUiState();
-        return () => {
-            cancelled = true;
-        };
-    }, [layoutStateWorkspaceKey, workspaceUiStateHeaders]);
-    useEffect(() => {
-        if (!layoutStateReady)
-            return;
-        const timeoutId = window.setTimeout(async () => {
-            try {
-                await persistRemoteUiState({
-                    stateKey: 'layout',
-                    workspaceId: currentWorkspaceId,
-                    headers: workspaceUiStateHeaders,
-                    patch: {
-                        scheduleShowWeekends,
-                        scheduleShowBacklog,
-                        scheduleOnlyExpired,
-                        scheduleSidebarOpen,
-                        scheduleSelectedDate,
-                        scheduleCalendarMonth,
-                        scheduleScrollLeft,
-                        showFilters,
-                        documentTypeFilters,
-                        documentAttachmentFilters,
-                        documentTrayOpen,
-                        imageTrayOpen,
-                        agentTrayOpen,
-                        planningDrawerOpen,
-                        planningTreeCollapsed,
-                        planningPrimaryCollapsed,
-                        planningSecondaryCollapsed,
-                        planningExpandedInitiativeIds: Array.from(expandedPlanningInitiativeIds),
-                        planningDrawerDetail,
-                        planningNestedWorkstreamDetailId,
-                        annotatedTarget: requestedAnnotatedTarget,
-                        annotatedSessionId: requestedAnnotatedSessionId
-                    }
-                });
-            }
-            catch {
-                // ignore write failure
-            }
-        }, 250);
-        return () => window.clearTimeout(timeoutId);
-    }, [
-        layoutStateReady,
+    const applyPersistedLayoutState = useCallback((state) => {
+        if (typeof state.scheduleShowWeekends === 'boolean')
+            setScheduleShowWeekends(state.scheduleShowWeekends);
+        if (typeof state.scheduleShowBacklog === 'boolean')
+            setScheduleShowBacklog(state.scheduleShowBacklog);
+        if (typeof state.scheduleOnlyExpired === 'boolean')
+            setScheduleOnlyExpired(state.scheduleOnlyExpired);
+        if (typeof state.scheduleSidebarOpen === 'boolean')
+            setScheduleSidebarOpen(state.scheduleSidebarOpen);
+        if (typeof state.scheduleSelectedDate === 'string')
+            setScheduleSelectedDate(state.scheduleSelectedDate);
+        if (typeof state.scheduleCalendarMonth === 'string')
+            setScheduleCalendarMonth(state.scheduleCalendarMonth);
+        if (typeof state.scheduleScrollLeft === 'number')
+            setScheduleScrollLeft(state.scheduleScrollLeft);
+        if (typeof state.showFilters === 'boolean')
+            setShowFilters(state.showFilters);
+        if (Array.isArray(state.documentTypeFilters)) {
+            setDocumentTypeFilters(state.documentTypeFilters);
+        }
+        if (Array.isArray(state.documentAttachmentFilters)) {
+            setDocumentAttachmentFilters(state.documentAttachmentFilters);
+        }
+        if (state.documentSortField === 'updated'
+            || state.documentSortField === 'reference'
+            || state.documentSortField === 'name'
+            || state.documentSortField === 'size'
+            || state.documentSortField === 'created') {
+            setDocumentSortField(state.documentSortField);
+        }
+        if (state.documentSortOrder === 'asc' || state.documentSortOrder === 'desc') {
+            setDocumentSortOrder(state.documentSortOrder);
+        }
+        if (Array.isArray(state.documentPinnedDocIds)) {
+            setDocumentPinnedDocIds(state.documentPinnedDocIds);
+        }
+        if (typeof state.documentSearchQuery === 'string') {
+            setDocumentSearchQuery(state.documentSearchQuery);
+        }
+        if (typeof state.documentSelectedDocId === 'string' || state.documentSelectedDocId === null) {
+            setDocumentSelectedDocId(state.documentSelectedDocId);
+        }
+        setDocumentScrollByDocId(state.documentScrollByDocId && typeof state.documentScrollByDocId === 'object'
+            ? state.documentScrollByDocId
+            : {});
+        if (typeof state.documentListScrollTop === 'number') {
+            setDocumentListScrollTop(state.documentListScrollTop);
+        }
+        if (typeof state.planningDrawerOpen === 'boolean') {
+            setPlanningDrawerOpen(state.planningDrawerOpen);
+        }
+        if (typeof state.documentTrayOpen === 'boolean') {
+            setDocumentTrayOpen(state.documentTrayOpen);
+        }
+        if (typeof state.imageTrayOpen === 'boolean') {
+            setImageTrayOpen(state.imageTrayOpen);
+        }
+        if (typeof state.agentTrayOpen === 'boolean') {
+            setAgentTrayOpen(state.agentTrayOpen);
+        }
+        if (typeof state.taskforceAgentRosterTrayOpen === 'boolean') {
+            setTaskforceAgentRosterTrayOpen(state.taskforceAgentRosterTrayOpen);
+        }
+        if (typeof state.taskforceAgentDrawerOpen === 'boolean') {
+            setTaskforceAgentDrawerOpen(state.taskforceAgentDrawerOpen);
+        }
+        if (typeof state.taskforceAgentPanelCollapsed === 'boolean') {
+            setTaskforceAgentPanelCollapsed(state.taskforceAgentPanelCollapsed);
+        }
+        if (typeof state.planningTreeCollapsed === 'boolean') {
+            setPlanningTreeCollapsed(state.planningTreeCollapsed);
+        }
+        if (typeof state.planningPrimaryCollapsed === 'boolean') {
+            setPlanningPrimaryCollapsed(state.planningPrimaryCollapsed);
+        }
+        if (typeof state.planningSecondaryCollapsed === 'boolean') {
+            setPlanningSecondaryCollapsed(state.planningSecondaryCollapsed);
+        }
+        setPlanningFavoritesSectionCollapsed(Boolean(state.planningFavoritesSectionCollapsed));
+        setPlanningInitiativesSectionCollapsed(Boolean(state.planningInitiativesSectionCollapsed));
+        setPlanningWorkstreamsSectionCollapsed(Boolean(state.planningWorkstreamsSectionCollapsed));
+        if (state.planningNavigatorSort === 'default'
+            || state.planningNavigatorSort === 'title'
+            || state.planningNavigatorSort === 'owner'
+            || state.planningNavigatorSort === 'progress') {
+            setPlanningNavigatorSort(state.planningNavigatorSort);
+        }
+        setPlanningTaskArrangeMode(normalizePlanningTaskArrangeMode(state.planningTaskArrangeMode));
+        setPlanningFavorites(Array.isArray(state.planningFavorites) ? state.planningFavorites : []);
+        if (Array.isArray(state.planningExpandedInitiativeIds)) {
+            setExpandedPlanningInitiativeIds(new Set(state.planningExpandedInitiativeIds));
+        }
+        if (state.planningDrawerDetail !== undefined) {
+            setPlanningDrawerDetail(state.planningDrawerDetail);
+        }
+        if (typeof state.planningNestedWorkstreamDetailId === 'string' || state.planningNestedWorkstreamDetailId === null) {
+            setPlanningNestedWorkstreamDetailId(state.planningNestedWorkstreamDetailId);
+        }
+        const annotatedTarget = state.annotatedTarget && typeof state.annotatedTarget === 'object'
+            ? state.annotatedTarget
+            : null;
+        const annotatedSessionId = annotatedTarget && typeof state.annotatedSessionId === 'string'
+            ? state.annotatedSessionId
+            : null;
+        if (shouldApplyPersistedAnnotatedAttachmentContext({
+            currentTarget: requestedAnnotatedTargetRef.current,
+            currentSessionId: requestedAnnotatedSessionIdRef.current,
+            lastHydratedIdentity: lastHydratedAnnotatedContextIdentityRef.current,
+        })) {
+            requestedAnnotatedTargetRef.current = annotatedTarget;
+            requestedAnnotatedSessionIdRef.current = annotatedSessionId;
+            lastHydratedAnnotatedContextIdentityRef.current = getAnnotatedAttachmentContextIdentity(annotatedTarget, annotatedSessionId);
+            setRequestedAnnotatedTarget(annotatedTarget);
+            setRequestedAnnotatedSessionId(annotatedSessionId);
+        }
+        setAnnotatedViewportByContextKey(state.annotatedViewportByContextKey && typeof state.annotatedViewportByContextKey === 'object'
+            ? state.annotatedViewportByContextKey
+            : {});
+    }, []);
+    const layoutUiStateSnapshot = useMemo(() => ({
         scheduleShowWeekends,
         scheduleShowBacklog,
         scheduleOnlyExpired,
@@ -583,33 +662,92 @@ export function StandaloneLayout(props) {
         showFilters,
         documentTypeFilters,
         documentAttachmentFilters,
+        documentSortField,
+        documentSortOrder,
+        documentPinnedDocIds,
+        documentSearchQuery,
+        documentSelectedDocId,
+        documentScrollByDocId,
+        documentListScrollTop,
         documentTrayOpen,
         imageTrayOpen,
         agentTrayOpen,
+        taskforceAgentRosterTrayOpen,
+        taskforceAgentDrawerOpen,
+        taskforceAgentPanelCollapsed,
         planningDrawerOpen,
         planningTreeCollapsed,
         planningPrimaryCollapsed,
         planningSecondaryCollapsed,
+        planningFavoritesSectionCollapsed,
+        planningInitiativesSectionCollapsed,
+        planningWorkstreamsSectionCollapsed,
+        planningNavigatorSort,
+        planningTaskArrangeMode,
+        planningFavorites,
+        planningExpandedInitiativeIds: Array.from(expandedPlanningInitiativeIds),
+        planningDrawerDetail,
+        planningNestedWorkstreamDetailId,
+        annotatedTarget: scopedRequestedAnnotatedTarget,
+        annotatedSessionId: scopedRequestedAnnotatedSessionId,
+        annotatedViewportByContextKey,
+    }), [
+        scheduleShowWeekends,
+        scheduleShowBacklog,
+        scheduleOnlyExpired,
+        scheduleSidebarOpen,
+        scheduleSelectedDate,
+        scheduleCalendarMonth,
+        scheduleScrollLeft,
+        showFilters,
+        documentTypeFilters,
+        documentAttachmentFilters,
+        documentSortField,
+        documentSortOrder,
+        documentPinnedDocIds,
+        documentSearchQuery,
+        documentSelectedDocId,
+        documentScrollByDocId,
+        documentListScrollTop,
+        documentTrayOpen,
+        imageTrayOpen,
+        agentTrayOpen,
+        taskforceAgentRosterTrayOpen,
+        taskforceAgentDrawerOpen,
+        taskforceAgentPanelCollapsed,
+        planningDrawerOpen,
+        planningTreeCollapsed,
+        planningPrimaryCollapsed,
+        planningSecondaryCollapsed,
+        planningFavoritesSectionCollapsed,
+        planningInitiativesSectionCollapsed,
+        planningWorkstreamsSectionCollapsed,
+        planningNavigatorSort,
+        planningTaskArrangeMode,
+        planningFavorites,
         expandedPlanningInitiativeIds,
         planningDrawerDetail,
         planningNestedWorkstreamDetailId,
-        requestedAnnotatedTarget,
-        requestedAnnotatedSessionId,
-        workspaceUiStateHeaders
+        scopedRequestedAnnotatedTarget,
+        scopedRequestedAnnotatedSessionId,
+        annotatedViewportByContextKey,
     ]);
     useEffect(() => {
-        if (typeof window === 'undefined')
-            return;
-        try {
-            window.sessionStorage.setItem(annotatedLayoutCacheKey, JSON.stringify({
-                annotatedTarget: requestedAnnotatedTarget,
-                annotatedSessionId: requestedAnnotatedSessionId,
-            }));
-        }
-        catch {
-            // ignore cache write failure
-        }
-    }, [annotatedLayoutCacheKey, requestedAnnotatedSessionId, requestedAnnotatedTarget]);
+        setPlanningFavorites([]);
+    }, [layoutStateWorkspaceKey]);
+    const { ready: layoutUiStateReady } = usePersistedLayoutUiState({
+        currentWorkspaceId,
+        loadKey: layoutStateWorkspaceKey,
+        enabled: runtimeMode !== 'cloud' || authSessionResolved,
+        headers: workspaceUiStateHeaders,
+        remotePlanningFavoritesAuthoritative: Boolean(normalizedAuthUserId)
+            && normalizedAuthUserId !== 'anonymous',
+        useCloudProxy: runtimeMode === 'local'
+            && Boolean(normalizedAuthUserId)
+            && normalizedAuthUserId !== 'anonymous',
+        snapshot: layoutUiStateSnapshot,
+        onApplyState: applyPersistedLayoutState,
+    });
     useEffect(() => {
         if (groupBy === 'schedule') {
             setScheduleSidebarOpen(true);
@@ -660,11 +798,16 @@ export function StandaloneLayout(props) {
                 pushNotice(annotatedAttachmentsWorkspaceUnavailableMessage, 'error');
                 return;
             }
-            setRequestedAnnotatedTarget(detail);
-            setRequestedAnnotatedSessionId(null);
-            setRequestedAnnotatedOpenVersion((current) => current + 1);
-            rememberTaskOriginWorkspaceModule(detail.taskId);
-            setActiveWorkspaceModule('annotate');
+            handoffTaskModalToWorkspace(() => {
+                requestedAnnotatedTargetRef.current = detail;
+                const sessionId = String(detail.sessionId || '').trim() || null;
+                requestedAnnotatedSessionIdRef.current = sessionId;
+                setRequestedAnnotatedTarget(detail);
+                setRequestedAnnotatedSessionId(sessionId);
+                setRequestedAnnotatedOpenVersion((current) => current + 1);
+                rememberTaskOriginWorkspaceModule(detail.taskId);
+                setActiveWorkspaceModule('annotate');
+            });
         };
         window.addEventListener('taskforce:open-annotated-attachment', handleOpenAnnotatedAttachment);
         return () => {
@@ -674,21 +817,22 @@ export function StandaloneLayout(props) {
         annotatedAttachmentTasks,
         annotatedAttachmentsWorkspaceEnabled,
         annotatedAttachmentsWorkspaceUnavailableMessage,
+        handoffTaskModalToWorkspace,
         pushNotice,
         rememberTaskOriginWorkspaceModule,
         setActiveWorkspaceModule
     ]);
     useEffect(() => {
-        if (!requestedAnnotatedTarget)
+        if (!scopedRequestedAnnotatedTarget)
             return;
-        const resolvedTarget = resolveAnnotatedAttachmentDetail(requestedAnnotatedTarget, annotatedAttachmentTasks);
+        const resolvedTarget = resolveAnnotatedAttachmentDetail(scopedRequestedAnnotatedTarget, annotatedAttachmentTasks);
         if (!resolvedTarget)
             return;
-        if (resolvedTarget.taskReferenceLabel === requestedAnnotatedTarget.taskReferenceLabel
-            && resolvedTarget.imageReferenceLabel === requestedAnnotatedTarget.imageReferenceLabel)
+        if (resolvedTarget.taskReferenceLabel === scopedRequestedAnnotatedTarget.taskReferenceLabel
+            && resolvedTarget.imageReferenceLabel === scopedRequestedAnnotatedTarget.imageReferenceLabel)
             return;
         setRequestedAnnotatedTarget(resolvedTarget);
-    }, [annotatedAttachmentTasks, requestedAnnotatedTarget]);
+    }, [annotatedAttachmentTasks, scopedRequestedAnnotatedTarget]);
     useEffect(() => {
         const activeTarget = requestedAnnotatedTargetRef.current;
         const normalizedAssetId = String(activeTarget?.assetId || '').trim();
@@ -707,11 +851,11 @@ export function StandaloneLayout(props) {
                 imageReferenceLabel: canonicalReferenceLabel,
             };
         });
-    }, [canonicalAnnotatedImageReferenceLabels, requestedAnnotatedTarget]);
+    }, [canonicalAnnotatedImageReferenceLabels, scopedRequestedAnnotatedTarget]);
     useEffect(() => {
         if (!annotatedWorkspaceReady)
             return;
-        const activeTarget = requestedAnnotatedTarget;
+        const activeTarget = scopedRequestedAnnotatedTarget;
         const normalizedAssetId = String(activeTarget?.assetId || '').trim();
         if (!normalizedAssetId)
             return;
@@ -756,11 +900,13 @@ export function StandaloneLayout(props) {
         return () => {
             cancelled = true;
         };
-    }, [annotatedWorkspaceReady, canonicalAnnotatedImageReferenceLabels, currentWorkspaceId, requestedAnnotatedTarget, workspaceUiStateHeaders]);
+    }, [annotatedWorkspaceReady, canonicalAnnotatedImageReferenceLabels, currentWorkspaceId, scopedRequestedAnnotatedTarget, workspaceUiStateHeaders]);
     const deletedScopeAllTasks = useMemo(() => props.deletedTasks.map((entry) => ({
         ...entry.taskSnapshot,
         isDeleted: true,
-        deletedRecordId: entry.id
+        deletedRecordId: entry.id,
+        deletedAt: entry.deletedAt,
+        deletedExpiresAt: getDeletedTaskExpiresAt(entry.deletedAt),
     })), [props.deletedTasks]);
     const deletedTaskRecordByTaskId = useMemo(() => {
         const map = new Map();
@@ -825,18 +971,26 @@ export function StandaloneLayout(props) {
             .map((type) => ({ value: type.value, label: `${type.label} (Retired)` }));
         return [...activeTypeOptions, ...retiredTypesInUse];
     }, [activeTypes, taskFilterRecords]);
+    const applyTaskHeaderQuickFilter = useCallback((candidateTasks) => {
+        if (!taskHeaderQuickFilter)
+            return candidateTasks;
+        return candidateTasks.filter((task) => matchesTaskHeaderQuickFilter(task, taskHeaderQuickFilter, normalizedAuthUserId, todayDateOnly));
+    }, [normalizedAuthUserId, taskHeaderQuickFilter, todayDateOnly]);
+    const quickFilteredOpenTasks = useMemo(() => applyTaskHeaderQuickFilter(props.filteredTasks), [applyTaskHeaderQuickFilter, props.filteredTasks]);
     const kanbanTasks = useMemo(() => {
         if (taskScope === 'archived')
             return archivedScopeTasks;
         if (taskScope === 'deleted')
             return filteredDeletedTasks;
         if (!showArchive)
-            return props.filteredTasks;
-        return [...props.filteredTasks, ...archivedScopeTasks];
-    }, [archivedScopeTasks, filteredDeletedTasks, props.filteredTasks, showArchive, taskScope]);
+            return quickFilteredOpenTasks;
+        return [...quickFilteredOpenTasks, ...archivedScopeTasks];
+    }, [archivedScopeTasks, filteredDeletedTasks, quickFilteredOpenTasks, showArchive, taskScope]);
     const scheduleBaseTasks = useMemo(() => taskScope === 'open'
-        ? props.tasks.filter(task => !task.isArchived)
-        : kanbanTasks, [kanbanTasks, props.tasks, taskScope]);
+        ? (taskHeaderQuickFilter
+            ? quickFilteredOpenTasks
+            : props.tasks.filter(task => !task.isArchived))
+        : kanbanTasks, [kanbanTasks, props.tasks, quickFilteredOpenTasks, taskHeaderQuickFilter, taskScope]);
     const scheduleFilteredTaskIds = useMemo(() => new Set(kanbanTasks.map(task => task.id)), [kanbanTasks]);
     const kanbanAllTasks = useMemo(() => {
         if (taskScope === 'archived')
@@ -875,16 +1029,34 @@ export function StandaloneLayout(props) {
         return map;
     }, [assigneeOptions, authUserDisplayName, authUserEmail, authUserId]);
     const planningStructure = useMemo(() => {
-        const planningScopedTasks = taskScope === 'archived'
-            ? archivedScopeAllTasks
-            : taskScope === 'deleted'
-                ? deletedScopeAllTasks
-                : props.tasks.filter((task) => !task.isArchived);
-        const planningPreviewTasks = taskScope === 'deleted'
-            ? deletedScopeAllTasks
-            : Array.from([...props.tasks, ...archivedScopeAllTasks]
-                .reduce((map, task) => map.set(task.id, task), new Map())
-                .values());
+        const prerequisiteTaskIdsByTaskId = new Map();
+        props.workspaceTaskRelationships.forEach((relationship) => {
+            if (relationship.deletedAt || relationship.kind !== 'dependency')
+                return;
+            const current = prerequisiteTaskIdsByTaskId.get(relationship.sourceTaskId) || [];
+            current.push(relationship.targetTaskId);
+            prerequisiteTaskIdsByTaskId.set(relationship.sourceTaskId, current);
+        });
+        const planningLifetimeTasks = mergePlanningLifetimeTasks(props.tasks, archivedScopeAllTasks);
+        const planningLifetimeTaskById = new Map(planningLifetimeTasks.map((task) => [task.id, task]));
+        const getDependencyState = (taskId) => {
+            const prerequisiteIds = prerequisiteTaskIdsByTaskId.get(taskId) || [];
+            if (prerequisiteIds.length === 0)
+                return 'ready';
+            let invalid = false;
+            for (const prerequisiteId of prerequisiteIds) {
+                const prerequisite = planningLifetimeTaskById.get(prerequisiteId);
+                if (!prerequisite || getStatusDefinition(prerequisite.status).value === 'cancelled') {
+                    invalid = true;
+                    continue;
+                }
+                if (getStatusDefinition(prerequisite.status).value !== 'done')
+                    return 'blocked';
+            }
+            return invalid ? 'invalid' : 'ready';
+        };
+        const planningProgressTasks = planningLifetimeTasks;
+        const planningPreviewTasks = planningLifetimeTasks;
         const summarizeTaskCounts = (taskCount, completedTaskCount) => {
             return {
                 progressPercent: taskCount > 0 ? Math.round((completedTaskCount / taskCount) * 100) : 0,
@@ -892,19 +1064,53 @@ export function StandaloneLayout(props) {
                 completedTaskCount,
             };
         };
-        const useBootstrapTaskSummaries = taskScope === 'open'
-            && props.planningBootstrapTaskSummaries.length > 0
-            && (props.loadingTasks || props.tasks.length === 0);
+        const summarizeTaskStatuses = (tasks) => {
+            const counts = {
+                task: 0,
+                'on-hold': 0,
+                'in-progress': 0,
+                review: 0,
+                done: 0,
+                cancelled: 0,
+            };
+            tasks.forEach((task) => {
+                counts[getStatusDefinition(task.status).value] += 1;
+            });
+            return counts;
+        };
+        const combineTaskStatuses = (workstreams) => {
+            const counts = summarizeTaskStatuses([]);
+            workstreams.forEach((workstream) => {
+                Object.entries(workstream.statusCounts || {}).forEach(([status, count]) => {
+                    counts[status] += Number(count) || 0;
+                });
+            });
+            return counts;
+        };
+        const useBootstrapTaskSummaries = shouldUsePlanningBootstrapTaskSummaries({
+            taskScope,
+            summaryCount: props.planningBootstrapTaskSummaries.length,
+            loadingTasks: props.loadingTasks,
+            activeTaskCount: props.tasks.length,
+            archiveHydrated: props.archiveHydratedWorkspaceId === currentWorkspaceId,
+        });
         const workstreamTaskSummaryById = new Map();
         const workstreamTaskPreviewsById = new Map();
+        const workstreamStatusCountsById = new Map();
         if (useBootstrapTaskSummaries) {
             props.planningBootstrapTaskSummaries.forEach((summary) => {
-                workstreamTaskSummaryById.set(summary.workstreamId, summary);
-                workstreamTaskPreviewsById.set(summary.workstreamId, summary.tasks || []);
+                const tasks = (summary.tasks || []).map((task) => ({
+                    ...task,
+                    prerequisiteTaskIds: prerequisiteTaskIdsByTaskId.get(task.id) || [],
+                    dependencyState: getDependencyState(task.id),
+                }));
+                workstreamTaskSummaryById.set(summary.workstreamId, { ...summary, tasks });
+                workstreamTaskPreviewsById.set(summary.workstreamId, tasks);
+                workstreamStatusCountsById.set(summary.workstreamId, summarizeTaskStatuses(tasks));
             });
         }
         else {
-            planningScopedTasks.forEach((task) => {
+            planningProgressTasks.forEach((task) => {
                 const workstreamId = String(task.workstreamId || '').trim();
                 if (!workstreamId)
                     return;
@@ -915,9 +1121,12 @@ export function StandaloneLayout(props) {
                     tasks: [],
                 };
                 current.taskCount += 1;
-                if (task.isArchived || task.status === 'done' || task.status === 'cancelled') {
+                if (task.status === 'done' || task.status === 'cancelled') {
                     current.completedTaskCount += 1;
                 }
+                const statusCounts = workstreamStatusCountsById.get(workstreamId) || summarizeTaskStatuses([]);
+                statusCounts[getStatusDefinition(task.status).value] += 1;
+                workstreamStatusCountsById.set(workstreamId, statusCounts);
                 workstreamTaskSummaryById.set(workstreamId, current);
             });
             planningPreviewTasks.forEach((task) => {
@@ -928,8 +1137,17 @@ export function StandaloneLayout(props) {
                 current.push({
                     id: task.id,
                     referenceNumber: task.referenceNumber ?? null,
+                    localReferenceNumber: task.localReferenceNumber ?? null,
+                    referenceLabel: task.referenceLabel,
                     title: task.title,
+                    createdAt: task.createdAt,
                     status: task.status || null,
+                    priority: Number(task.priority) || 0,
+                    workstreamOrder: task.workstreamOrder ?? null,
+                    prerequisiteTaskIds: prerequisiteTaskIdsByTaskId.get(task.id) || [],
+                    dependencyState: getDependencyState(task.id),
+                    assignee: task.assignee || null,
+                    attachmentCount: Array.isArray(task.attachments) ? task.attachments.length : 0,
                     isArchived: Boolean(task.isArchived),
                 });
                 workstreamTaskPreviewsById.set(workstreamId, current);
@@ -942,6 +1160,12 @@ export function StandaloneLayout(props) {
         const buildWorkstreamSummary = (workstream) => {
             const taskSummary = workstreamTaskSummaryById.get(workstream.id);
             const taskPreviews = workstreamTaskPreviewsById.get(workstream.id) || taskSummary?.tasks || [];
+            const taskCounts = summarizeTaskCounts(taskSummary?.taskCount || 0, taskSummary?.completedTaskCount || 0);
+            const archiveReadiness = resolveWorkstreamArchiveReadiness({
+                isArchived: Boolean(workstream.isArchived),
+                tasks: taskPreviews,
+                dataReady: !useBootstrapTaskSummaries,
+            });
             const summary = {
                 id: workstream.id,
                 referenceNumber: workstream.referenceNumber ?? null,
@@ -949,12 +1173,18 @@ export function StandaloneLayout(props) {
                 description: String(workstream.description || '').trim() || undefined,
                 ownerId: workstream.ownerId ? String(workstream.ownerId) : null,
                 ownerLabel: workstream.ownerId ? assigneeLabelByValue.get(String(workstream.ownerId)) || String(workstream.ownerId) : null,
-                ...summarizeTaskCounts(taskSummary?.taskCount || 0, taskSummary?.completedTaskCount || 0),
+                ...taskCounts,
+                statusCounts: workstreamStatusCountsById.get(workstream.id) || summarizeTaskStatuses([]),
                 initiativeId: workstream.initiativeId || null,
                 commentCount: Array.isArray(workstream.comments) ? workstream.comments.length : 0,
+                comments: Array.isArray(workstream.comments) ? workstream.comments : [],
+                activity: Array.isArray(workstream.activity) ? workstream.activity : [],
+                entityEvents: Array.isArray(workstream.entityEvents) ? workstream.entityEvents : [],
                 attachmentCount: Array.isArray(workstream.attachments) ? workstream.attachments.length : 0,
                 attachments: Array.isArray(workstream.attachments) ? workstream.attachments : [],
                 isArchived: Boolean(workstream.isArchived),
+                archiveReady: archiveReadiness.archiveReady,
+                archiveActiveTaskCount: archiveReadiness.activeTaskCount,
                 tasks: taskPreviews,
             };
             workstreamTaskIds.set(workstream.id, taskPreviews.map((task) => task.id));
@@ -972,8 +1202,14 @@ export function StandaloneLayout(props) {
             const allWorkstreamsForInitiative = workstreamsByInitiativeId.get(initiative.id) || [];
             const workstreams = allWorkstreamsForInitiative
                 .filter((workstream) => isPlanningEntityVisibleForScope(taskScope, Boolean(workstream.isArchived)));
-            const taskCount = workstreams.reduce((sum, workstream) => sum + workstream.taskCount, 0);
-            const completedTaskCount = workstreams.reduce((sum, workstream) => sum + workstream.completedTaskCount, 0);
+            const taskCount = allWorkstreamsForInitiative.reduce((sum, workstream) => sum + workstream.taskCount, 0);
+            const completedTaskCount = allWorkstreamsForInitiative.reduce((sum, workstream) => sum + workstream.completedTaskCount, 0);
+            const initiativeTaskCounts = summarizeTaskCounts(taskCount, completedTaskCount);
+            const archiveReadiness = resolveInitiativeArchiveReadiness({
+                isArchived: Boolean(initiative.isArchived),
+                workstreams: allWorkstreamsForInitiative,
+                dataReady: !useBootstrapTaskSummaries,
+            });
             const initiativeSummary = {
                 id: initiative.id,
                 referenceNumber: initiative.referenceNumber ?? null,
@@ -981,14 +1217,21 @@ export function StandaloneLayout(props) {
                 description: String(initiative.description || '').trim() || undefined,
                 ownerId: initiative.ownerId ? String(initiative.ownerId) : null,
                 ownerLabel: initiative.ownerId ? assigneeLabelByValue.get(String(initiative.ownerId)) || String(initiative.ownerId) : null,
-                ...summarizeTaskCounts(taskCount, completedTaskCount),
+                ...initiativeTaskCounts,
+                statusCounts: combineTaskStatuses(allWorkstreamsForInitiative),
                 workstreamCount: workstreams.length,
                 workstreams,
                 allWorkstreams: allWorkstreamsForInitiative,
                 commentCount: Array.isArray(initiative.comments) ? initiative.comments.length : 0,
+                comments: Array.isArray(initiative.comments) ? initiative.comments : [],
+                activity: Array.isArray(initiative.activity) ? initiative.activity : [],
+                entityEvents: Array.isArray(initiative.entityEvents) ? initiative.entityEvents : [],
                 attachmentCount: Array.isArray(initiative.attachments) ? initiative.attachments.length : 0,
                 attachments: Array.isArray(initiative.attachments) ? initiative.attachments : [],
                 isArchived: Boolean(initiative.isArchived),
+                archiveReady: archiveReadiness.archiveReady,
+                archiveActiveTaskCount: archiveReadiness.activeTaskCount,
+                archiveActiveWorkstreamCount: archiveReadiness.activeWorkstreamCount,
             };
             return initiativeSummary;
         });
@@ -1000,7 +1243,10 @@ export function StandaloneLayout(props) {
         return {
             initiatives,
             standaloneWorkstreams,
+            allInitiatives,
             allStandaloneWorkstreams,
+            allInitiativeById: new Map(allInitiatives.map((initiative) => [initiative.id, initiative])),
+            allWorkstreamById: new Map(allWorkstreamSummaries.map((workstream) => [workstream.id, workstream])),
             workstreamTaskIds,
             workstreamInitiativeIds,
             initiativeTaskIds,
@@ -1009,11 +1255,13 @@ export function StandaloneLayout(props) {
         };
     }, [
         archivedScopeAllTasks,
+        currentWorkspaceId,
+        props.archiveHydratedWorkspaceId,
         assigneeLabelByValue,
-        deletedScopeAllTasks,
         props.initiatives,
         props.loadingTasks,
         props.planningBootstrapTaskSummaries,
+        props.workspaceTaskRelationships,
         props.tasks,
         props.workstreams,
         taskScope,
@@ -1025,6 +1273,41 @@ export function StandaloneLayout(props) {
             label: referenceLabel || initiative.title,
         };
     }), [planningStructure.initiatives]);
+    const planningLinkOptions = useMemo(() => {
+        const sortByTitle = (left, right) => (left.title.localeCompare(right.title, undefined, { sensitivity: 'base' }));
+        const initiatives = Array.from(planningStructure.allInitiativeById.values())
+            .filter((initiative) => !initiative.isArchived)
+            .map((initiative) => ({
+            id: initiative.id,
+            referenceLabel: formatInitiativeReference(initiative) || initiative.id,
+            title: initiative.title,
+            meta: `${initiative.workstreamCount || 0} workstream${initiative.workstreamCount === 1 ? '' : 's'}`,
+        }))
+            .sort(sortByTitle);
+        const workstreams = Array.from(planningStructure.allWorkstreamById.values())
+            .filter((workstream) => !workstream.isArchived)
+            .map((workstream) => ({
+            id: workstream.id,
+            referenceLabel: formatWorkstreamReference(workstream) || workstream.id,
+            title: workstream.title,
+            meta: workstream.initiativeId
+                ? `In ${planningStructure.allInitiativeById.get(workstream.initiativeId)?.title || 'another initiative'}`
+                : 'Standalone workstream',
+        }))
+            .sort(sortByTitle);
+        const tasks = hierarchyTasks
+            .filter((task) => !task.isArchived && !task.isDeleted)
+            .map((task) => ({
+            id: task.id,
+            referenceLabel: getTaskReferenceLabel(task) || task.id,
+            title: task.title,
+            meta: task.workstreamId
+                ? `In ${planningStructure.allWorkstreamById.get(task.workstreamId)?.title || 'another workstream'}`
+                : 'Unassigned to a workstream',
+        }))
+            .sort(sortByTitle);
+        return { initiatives, workstreams, tasks };
+    }, [hierarchyTasks, planningStructure.allInitiativeById, planningStructure.allWorkstreamById]);
     const workstreamFilterOptions = useMemo(() => {
         const visibleInitiativeWorkstreams = selectedPlanningInitiativeId
             ? (planningStructure.initiativeById.get(selectedPlanningInitiativeId)?.workstreams || [])
@@ -1065,22 +1348,20 @@ export function StandaloneLayout(props) {
         if (!planningDrawerDetail)
             return null;
         if (planningDrawerDetail.type === 'initiative') {
-            const item = planningStructure.initiativeById.get(planningDrawerDetail.id);
+            const item = planningStructure.allInitiativeById.get(planningDrawerDetail.id);
             return item ? { type: 'initiative', item } : null;
         }
-        const item = planningStructure.workstreamById.get(planningDrawerDetail.id)
-            || planningStructure.standaloneWorkstreams.find((workstream) => workstream.id === planningDrawerDetail.id);
+        const item = planningStructure.allWorkstreamById.get(planningDrawerDetail.id);
         return item ? { type: 'workstream', item } : null;
-    }, [planningDrawerDetail, planningStructure.initiativeById, planningStructure.standaloneWorkstreams, planningStructure.workstreamById]);
+    }, [planningDrawerDetail, planningStructure.allInitiativeById, planningStructure.allWorkstreamById]);
     const planningNestedWorkstreamItem = useMemo(() => {
         if (!planningNestedWorkstreamDetailId)
             return null;
-        const item = planningStructure.workstreamById.get(planningNestedWorkstreamDetailId)
-            || planningStructure.standaloneWorkstreams.find((workstream) => workstream.id === planningNestedWorkstreamDetailId);
+        const item = planningStructure.allWorkstreamById.get(planningNestedWorkstreamDetailId);
         return item ? { type: 'workstream', item } : null;
-    }, [planningNestedWorkstreamDetailId, planningStructure.standaloneWorkstreams, planningStructure.workstreamById]);
+    }, [planningNestedWorkstreamDetailId, planningStructure.allWorkstreamById]);
     const planningSecondaryPane = useMemo(() => {
-        if (planningSecondaryEditor) {
+        if (planningSecondaryEditor?.mode === 'create') {
             return { kind: 'editor', editor: planningSecondaryEditor };
         }
         if (planningNestedWorkstreamItem) {
@@ -1088,15 +1369,22 @@ export function StandaloneLayout(props) {
         }
         return null;
     }, [planningNestedWorkstreamItem, planningSecondaryEditor]);
-    const planningDrawerWidthPx = getPlanningDrawerWidthPx(planningTreeCollapsed, Boolean(planningDrawerItem || planningEditor), planningPrimaryCollapsed, Boolean(planningSecondaryPane), planningSecondaryCollapsed);
+    const primaryPlanningHydrationState = planningDrawerDetail
+        ? planningHydrationStateByEntity[`${planningDrawerDetail.type}:${planningDrawerDetail.id}`]
+        : undefined;
+    const secondaryPlanningHydrationState = planningNestedWorkstreamDetailId
+        ? planningHydrationStateByEntity[`workstream:${planningNestedWorkstreamDetailId}`]
+        : undefined;
+    const planningDrawerEstimatedWidthPx = getPlanningDrawerWidthPx(planningTreeCollapsed, Boolean(planningDrawerItem || planningEditor), planningPrimaryCollapsed, Boolean(planningSecondaryPane), planningSecondaryCollapsed);
+    const [planningDrawerWidthPx, setPlanningDrawerWidthPx] = useState(planningDrawerEstimatedWidthPx);
     const planningDraftInitiativeSummary = useMemo(() => {
         if (!planningDraftInitiativeId.trim())
             return null;
-        const exactInitiative = planningStructure.initiativeById.get(planningDraftInitiativeId);
+        const exactInitiative = planningStructure.allInitiativeById.get(planningDraftInitiativeId);
         if (exactInitiative)
             return exactInitiative;
-        return resolveInitiativeReference(planningStructure.initiatives, planningDraftInitiativeId);
-    }, [planningDraftInitiativeId, planningStructure.initiativeById, planningStructure.initiatives]);
+        return resolveInitiativeReference(planningStructure.allInitiatives, planningDraftInitiativeId);
+    }, [planningDraftInitiativeId, planningStructure.allInitiativeById, planningStructure.allInitiatives]);
     useEffect(() => {
         if (selectedPlanningInitiativeId && !planningStructure.initiativeById.has(selectedPlanningInitiativeId)) {
             setSelectedPlanningInitiativeId('');
@@ -1115,13 +1403,6 @@ export function StandaloneLayout(props) {
             return scheduleBaseTasks;
         return kanbanTasks;
     }, [groupBy, kanbanTasks, scheduleBaseTasks]);
-    const todayDateOnly = useMemo(() => {
-        const now = new Date();
-        const y = now.getFullYear();
-        const m = String(now.getMonth() + 1).padStart(2, '0');
-        const d = String(now.getDate()).padStart(2, '0');
-        return `${y}-${m}-${d}`;
-    }, []);
     const boardVisibleTasks = useMemo(() => {
         if (groupBy !== 'schedule' || !scheduleOnlyExpired)
             return hierarchyVisibleTasks;
@@ -1137,9 +1418,46 @@ export function StandaloneLayout(props) {
     const scopedBoardVisibleTasks = useMemo(() => {
         return scopeTasksToPlanningSelection(boardVisibleTasks, selectedPlanningTaskIds);
     }, [boardVisibleTasks, selectedPlanningTaskIds]);
+    const trashSelection = useTrashSelection(props.deletedTasks, scopedBoardVisibleTasks.map((task) => task.id), taskScope === 'deleted');
     const scopedKanbanAllTasks = useMemo(() => {
         return scopeTasksToPlanningSelection(kanbanAllTasks, selectedPlanningTaskIds);
     }, [kanbanAllTasks, selectedPlanningTaskIds]);
+    const scheduleFilteredTaskIdList = useMemo(() => Array.from(scheduleFilteredTaskIds), [scheduleFilteredTaskIds]);
+    const handleBoardScheduleDaySelected = useCallback((dateOnly) => {
+        setScheduleSelectedDate(dateOnly);
+        const parsed = parseDateOnlyLocal(dateOnly);
+        if (parsed) {
+            setScheduleCalendarMonth(`${parsed.getFullYear()}-${String(parsed.getMonth() + 1).padStart(2, '0')}`);
+        }
+    }, []);
+    const handleBoardScrollLeftChange = useCallback((scrollLeft) => {
+        if (groupBy !== 'schedule')
+            return;
+        setScheduleScrollLeft(scrollLeft);
+    }, [groupBy]);
+    const handleBoardUnarchive = useCallback((taskId) => {
+        if (taskScope === 'deleted') {
+            const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
+            if (!deletedRecord)
+                return;
+            void handleRestoreDeletedTask(deletedRecord.id, deletedRecord.taskId);
+            return;
+        }
+        void handleUnarchive(taskId);
+    }, [deletedTaskRecordByTaskId, handleRestoreDeletedTask, handleUnarchive, taskScope]);
+    const handleBoardDelete = useCallback((taskId) => {
+        if (taskScope === 'deleted') {
+            const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
+            if (!deletedRecord)
+                return;
+            const confirmed = window.confirm('Permanently delete this task? This cannot be undone.');
+            if (!confirmed)
+                return;
+            void handlePermanentlyDeleteDeletedTask(deletedRecord.id);
+            return;
+        }
+        void handleDelete(taskId);
+    }, [deletedTaskRecordByTaskId, handleDelete, handlePermanentlyDeleteDeletedTask, taskScope]);
     const expiredRecoveryCandidates = useMemo(() => {
         if (groupBy !== 'schedule')
             return [];
@@ -1172,7 +1490,6 @@ export function StandaloneLayout(props) {
             return !!task.dueDate && task.dueDate < todayDateOnly;
         }).length;
     }, [groupBy, hierarchyVisibleTasks, todayDateOnly]);
-    const normalizedAuthUserId = String(authUserId || '').trim();
     const assignedTaskCount = useMemo(() => {
         if (!normalizedAuthUserId || normalizedAuthUserId === 'anonymous')
             return 0;
@@ -1225,35 +1542,179 @@ export function StandaloneLayout(props) {
             setTaskModalFullscreen(false);
         }
     }, [activeTab]);
-    const handleSetStatus = useCallback((task, status) => {
-        if (task.status === status)
+    const handleSetStatus = useCallback(async (task, status, options) => {
+        if (task.status === status && !options?.allowSameStatus)
             return;
-        if (status === 'in-progress') {
-            void handleToggleInProgress(task);
+        await handleSetStatusDurably(task, status);
+    }, [handleSetStatusDurably]);
+    const handleSetPlanningTaskStatus = useCallback(async (taskId, status) => {
+        const task = hierarchyTaskById.get(taskId);
+        if (!task) {
+            pushNotice('Task details are still loading.', 'info');
             return;
         }
-        if (status === 'review') {
-            void handleToggleReview(task);
-            return;
+        await handleSetStatus(task, status);
+        await props.fetchPlanningEntities();
+    }, [handleSetStatus, hierarchyTaskById, props.fetchPlanningEntities, pushNotice]);
+    const handleChangePlanningTaskAssignee = useCallback(async (taskId, assignee) => {
+        const saved = await handleUpdateTask(taskId, { assignee });
+        if (saved !== false)
+            await props.fetchPlanningEntities();
+    }, [handleUpdateTask, props.fetchPlanningEntities]);
+    const archivePlanningTaskById = useCallback(async (taskId) => {
+        const task = hierarchyTaskById.get(taskId);
+        if (!task) {
+            pushNotice('Task details are still loading.', 'info');
+            return false;
         }
-        if (status === 'done') {
-            void handleToggleComplete(task);
-            return;
+        if (task.isArchived)
+            return true;
+        if (task.status !== 'done' && task.status !== 'cancelled') {
+            pushNotice('Only completed or cancelled tasks can be archived from Planning.', 'error');
+            return false;
         }
-        if (status === 'cancelled') {
-            void handleToggleCancel(task);
-            return;
+        return handleArchiveTask(task);
+    }, [handleArchiveTask, hierarchyTaskById, pushNotice]);
+    const handleArchivePlanningTask = useCallback(async (taskId) => {
+        const archived = await archivePlanningTaskById(taskId);
+        if (archived) {
+            await props.fetchPlanningEntities();
+            pushNotice('Task archived', 'success');
         }
-        void handleUpdateTask(task.id, {
-            status,
-            completedAt: null
+        return archived;
+    }, [archivePlanningTaskById, props.fetchPlanningEntities, pushNotice]);
+    const handleArchiveResolvedWorkstream = useCallback(async (workstreamId) => {
+        const workstream = planningStructure.allWorkstreamById.get(workstreamId);
+        if (!workstream?.archiveReady) {
+            pushNotice('This workstream is no longer ready to archive.', 'error');
+            return false;
+        }
+        try {
+            const archived = await archiveResolvedWorkstreamHierarchy({
+                workstream,
+                archiveTask: archivePlanningTaskById,
+                archiveWorkstream: props.archiveWorkstream,
+            });
+            if (!archived) {
+                pushNotice('Workstream archive stopped safely. Resolve any remaining tasks and retry.', 'error');
+                return false;
+            }
+            pushNotice('Completed tasks and workstream archived', 'success');
+            return true;
+        }
+        catch (error) {
+            pushNotice(error instanceof Error
+                ? `Workstream archive stopped safely: ${error.message}`
+                : 'Workstream archive stopped safely. Retry to archive the remaining items.', 'error');
+            return false;
+        }
+    }, [archivePlanningTaskById, planningStructure.allWorkstreamById, props.archiveWorkstream, pushNotice]);
+    const handleArchiveResolvedInitiative = useCallback(async (initiativeId) => {
+        const initiative = planningStructure.allInitiativeById.get(initiativeId);
+        if (!initiative?.archiveReady) {
+            pushNotice('This initiative is no longer ready to archive.', 'error');
+            return false;
+        }
+        try {
+            const archived = await archiveResolvedInitiativeHierarchy({
+                initiativeId: initiative.id,
+                workstreams: initiative.allWorkstreams || initiative.workstreams,
+                archiveTask: archivePlanningTaskById,
+                archiveWorkstream: props.archiveWorkstream,
+                archiveInitiative: props.archiveInitiative,
+            });
+            if (!archived) {
+                pushNotice('Initiative archive stopped safely. Resolve any remaining tasks and retry.', 'error');
+                return false;
+            }
+            pushNotice('Completed tasks, workstreams, and initiative archived', 'success');
+            return true;
+        }
+        catch (error) {
+            pushNotice(error instanceof Error
+                ? `Initiative archive stopped safely: ${error.message}`
+                : 'Initiative archive stopped safely. Retry to archive the remaining items.', 'error');
+            return false;
+        }
+    }, [
+        archivePlanningTaskById,
+        planningStructure.allInitiativeById,
+        props.archiveInitiative,
+        props.archiveWorkstream,
+        pushNotice,
+    ]);
+    const handleArchivePlanningEntity = useCallback(async (entityType, entityId) => {
+        const item = entityType === 'initiative'
+            ? planningStructure.allInitiativeById.get(entityId)
+            : planningStructure.allWorkstreamById.get(entityId);
+        if (!item) {
+            pushNotice(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} not found.`, 'error');
+            return false;
+        }
+        const archiveState = resolvePlanningArchiveDetailState({
+            entityType,
+            isArchived: item.isArchived,
+            taskCount: item.taskCount,
+            completedTaskCount: item.completedTaskCount,
+            archiveReady: item.archiveReady,
+            activeWorkstreamCount: item.archiveActiveWorkstreamCount,
         });
-    }, [handleToggleInProgress, handleToggleReview, handleToggleComplete, handleToggleCancel, handleUpdateTask]);
+        if (archiveState.mode === 'archived')
+            return true;
+        if (archiveState.mode === 'ready') {
+            return entityType === 'initiative'
+                ? handleArchiveResolvedInitiative(entityId)
+                : handleArchiveResolvedWorkstream(entityId);
+        }
+        if (archiveState.mode !== 'empty') {
+            pushNotice(archiveState.mode === 'blocked'
+                ? `Archive unavailable while active ${archiveState.remainingKind === 'task' ? 'tasks' : 'workstreams'} remain.`
+                : 'Archive availability is still loading.', 'error');
+            return false;
+        }
+        try {
+            if (entityType === 'initiative') {
+                await props.archiveInitiative(entityId);
+            }
+            else {
+                await props.archiveWorkstream(entityId);
+            }
+            pushNotice(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} archived`, 'success');
+            return true;
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : `Failed to archive ${entityType}.`, 'error');
+            return false;
+        }
+    }, [
+        handleArchiveResolvedInitiative,
+        handleArchiveResolvedWorkstream,
+        planningStructure.allInitiativeById,
+        planningStructure.allWorkstreamById,
+        props.archiveInitiative,
+        props.archiveWorkstream,
+        pushNotice,
+    ]);
+    const handleUnarchivePlanningEntity = useCallback(async (entityType, entityId) => {
+        try {
+            if (entityType === 'initiative') {
+                await props.unarchiveInitiative(entityId);
+            }
+            else {
+                await props.unarchiveWorkstream(entityId);
+            }
+            pushNotice(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} unarchived`, 'success');
+            return true;
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : `Failed to unarchive ${entityType}.`, 'error');
+            return false;
+        }
+    }, [props.unarchiveInitiative, props.unarchiveWorkstream, pushNotice]);
     const handleAddTaskToColumn = useCallback((groupField, value) => {
         resetForm();
         const defaults = resolveDraftDefaultsForGrouping(groupField, value, {
-            categories: activeCategories,
-            approaches
+            categories: activeCategories
         });
         if (defaults.category)
             setCategory(defaults.category);
@@ -1263,12 +1724,6 @@ export function StandaloneLayout(props) {
             setPriority(defaults.priority);
         if (typeof defaults.complexity === 'number')
             setComplexity(defaults.complexity);
-        if (defaults.approach)
-            setApproach(defaults.approach);
-        const taxonomyApproach = defaults.taxonomyApproach;
-        if (typeof taxonomyApproach === 'string' && taxonomyApproach.length > 0) {
-            setFormTaxonomies(prev => ({ ...prev, approach: taxonomyApproach }));
-        }
         if (defaults.assignee)
             setAssignee(defaults.assignee);
         if (defaults.status)
@@ -1276,7 +1731,7 @@ export function StandaloneLayout(props) {
         if (defaults.scheduledDate)
             setScheduledDate(defaults.scheduledDate);
         setActiveTab('add');
-    }, [resetForm, activeCategories, approaches, setCategory, setType, setPriority, setComplexity, setStatus, setApproach, setAssignee, setScheduledDate, setFormTaxonomies, setActiveTab]);
+    }, [resetForm, activeCategories, setCategory, setType, setPriority, setComplexity, setStatus, setAssignee, setScheduledDate, setActiveTab]);
     // Ensure 'done' status is shown by default as requested
     React.useEffect(() => {
         if (filterStatus && !filterStatus.includes('done')) {
@@ -1286,8 +1741,8 @@ export function StandaloneLayout(props) {
     // Local state for filter toolbar
     const [showHelpModal, setShowHelpModal] = useState(false);
     const [showAccountMenu, setShowAccountMenu] = useState(false);
-    const [showAccountHub, setShowAccountHub] = useState(false);
-    const [showEditProfileModal, setShowEditProfileModal] = useState(false);
+    const [showAccountSettings, setShowAccountSettings] = useState(false);
+    const accountSettingsWasOpenRef = useRef(false);
     const [showAvatarPhotoManager, setShowAvatarPhotoManager] = useState(false);
     const [workspaceActionBusy, setWorkspaceActionBusy] = useState(false);
     const [workspaceActionError, setWorkspaceActionError] = useState('');
@@ -1353,9 +1808,17 @@ export function StandaloneLayout(props) {
     const canManageCloudWorkspaces = runtimeMode === 'cloud' && workspaceSwitchingEnabled && isAuthenticated;
     const canAccessCloudTeamManagement = isAuthenticated && (runtimeMode === 'cloud' || cloudAuthConfigured);
     const canManageWorkspaceSync = runtimeMode === 'local' && isAuthenticated;
+    const serverCoordinatorSyncEnabled = (localCoordinatorStatus?.phase === 'ready'
+        && localCoordinatorStatus.snapshot?.state.ownershipMode === 'server')
+        ? localCoordinatorStatus.snapshot.workspace?.runner?.checkpoint
+            ?.checkpoint.syncEnabled
+        : null;
+    const effectiveWorkspaceCloudSyncEnabled = typeof serverCoordinatorSyncEnabled === 'boolean'
+        ? serverCoordinatorSyncEnabled
+        : workspaceCloudSyncEnabled;
     const { showSyncStatusModal, showSyncEnableWarning, workspaceSyncError, syncControlBusy, openSyncStatusModal, closeSyncStatusModal, handleWorkspaceSyncToggle, cancelSyncEnableWarning, confirmSyncEnableWarning, } = useSyncStatusControls({
         canManageWorkspaceSync,
-        workspaceCloudSyncEnabled,
+        workspaceCloudSyncEnabled: effectiveWorkspaceCloudSyncEnabled,
         saveWorkspaceCloudSyncSettings,
     });
     const currentWorkspaceLabel = useMemo(() => {
@@ -1410,14 +1873,15 @@ export function StandaloneLayout(props) {
     ]);
     const isAuthBootstrapPending = cloudAuthConfigured && !authSessionResolved;
     useEffect(() => {
-        if (!showEditProfileModal)
-            return;
-        setProfileDisplayNameDraft(authDisplayName);
-        setProfileAvatarPreviewUrl(authAvatarUrl);
-        setProfileAvatarDraftId(null);
-        setProfileSaveError(null);
-        setProfileSaveNotice(null);
-    }, [authAvatarUrl, authDisplayName, showEditProfileModal]);
+        if (showAccountSettings && !accountSettingsWasOpenRef.current) {
+            setProfileDisplayNameDraft(authDisplayName);
+            setProfileAvatarPreviewUrl(authAvatarUrl);
+            setProfileAvatarDraftId(null);
+            setProfileSaveError(null);
+            setProfileSaveNotice(null);
+        }
+        accountSettingsWasOpenRef.current = showAccountSettings;
+    }, [authAvatarUrl, authDisplayName, showAccountSettings]);
     const discardProfileAvatarDraft = useCallback(async (draftId) => {
         const normalizedDraftId = String(draftId || '').trim();
         if (!normalizedDraftId || !cloudAuthConfigured)
@@ -1434,9 +1898,9 @@ export function StandaloneLayout(props) {
             // Best-effort cleanup only.
         }
     }, [cloudAuthConfigured, resolveCloudAuthUrl]);
-    const closeEditProfileModal = useCallback(() => {
+    const closeAccountSettingsModal = useCallback(() => {
         const pendingDraftId = profileAvatarDraftId;
-        setShowEditProfileModal(false);
+        setShowAccountSettings(false);
         setShowAvatarPhotoManager(false);
         setProfileSaveError(null);
         setProfileSaveNotice(null);
@@ -1574,7 +2038,6 @@ export function StandaloneLayout(props) {
         setProfileAvatarPreviewUrl('');
         setProfileSaveBusy(false);
         setShowAvatarPhotoManager(false);
-        setShowEditProfileModal(false);
     }, [authAvatarUrl, profileAvatarDraftId, profileAvatarPreviewUrl, profileDisplayNameDraft, updateCurrentUserProfile]);
     const teamAdminHeaders = useCallback(() => {
         const headers = {};
@@ -1592,7 +2055,7 @@ export function StandaloneLayout(props) {
     }, [currentWorkspaceRole, teamManagementWorkspaceId, teamWorkspaceRole]);
     const startAccountSurfaceTiming = useCallback((surface) => {
         const expectsBilling = isAuthenticated;
-        const expectsTeamManagement = canAccessCloudTeamManagement;
+        const expectsTeamManagement = surface === 'account_menu' && canAccessCloudTeamManagement;
         accountSurfaceOpenStartedAtRef.current = getTimingNow();
         accountSurfacePendingRef.current = {
             billing: expectsBilling,
@@ -1622,13 +2085,13 @@ export function StandaloneLayout(props) {
         if (startedAt === null)
             return;
         logBootstrapDebug('account_surface_ready', {
-            surface: showAccountHub ? 'account_hub' : (showAccountMenu ? 'account_menu' : 'closed'),
+            surface: showAccountSettings ? 'account_settings' : (showAccountMenu ? 'account_menu' : 'closed'),
             durationMs: Math.round(getTimingNow() - startedAt),
             teamManagementVisible: canOpenTeamManagement,
             billingPlanId: String(accountProfileSummary?.planId || '').trim() || null
         });
         accountSurfaceOpenStartedAtRef.current = null;
-    }, [accountProfileSummary?.planId, canOpenTeamManagement, showAccountHub, showAccountMenu]);
+    }, [accountProfileSummary?.planId, canOpenTeamManagement, showAccountMenu, showAccountSettings]);
     const loadAccountProfileSummary = useCallback(async (options) => {
         const accountProfileSummaryUrl = resolveCloudAuthUrl(ACCOUNT_PROFILE_SUMMARY_PATH);
         if (!isAuthenticated) {
@@ -1798,10 +2261,10 @@ export function StandaloneLayout(props) {
         void loadAccountProfileSummary();
     }, [authSessionResolved, isAuthenticated, loadAccountProfileSummary]);
     useEffect(() => {
-        if (!showAccountHub && !showAccountMenu)
+        if (!showAccountSettings && !showAccountMenu)
             return;
         void loadAccountProfileSummary();
-    }, [loadAccountProfileSummary, showAccountHub, showAccountMenu]);
+    }, [loadAccountProfileSummary, showAccountMenu, showAccountSettings]);
     const loadTeamUsers = useCallback(async () => {
         if (!canManageTeamWorkspace)
             return;
@@ -1891,7 +2354,7 @@ export function StandaloneLayout(props) {
         const targetRaw = `${location.pathname}${location.search}${location.hash}`;
         const target = (!targetRaw || targetRaw === '/login' || !targetRaw.startsWith('/')) ? '/' : targetRaw;
         setShowAccountMenu(false);
-        setShowAccountHub(false);
+        setShowAccountSettings(false);
         closeSyncStatusModal();
         navigate(`/login?mode=${mode}&next=${encodeURIComponent(target)}`);
     }, [closeSyncStatusModal, location.hash, location.pathname, location.search, navigate]);
@@ -1984,9 +2447,28 @@ export function StandaloneLayout(props) {
         setActiveTab,
         setActiveWorkspaceModule,
     ]);
+    const handleTaskHeaderQuickFilter = useCallback((filter) => {
+        toggleTaskHeaderQuickFilter(filter);
+        setTaskScope('open');
+        setShowArchive(false);
+        setActiveWorkspaceModule('tasks');
+        if (isPlansScreen)
+            closePlansScreen();
+    }, [
+        closePlansScreen,
+        isPlansScreen,
+        setActiveWorkspaceModule,
+        setShowArchive,
+        setTaskScope,
+        toggleTaskHeaderQuickFilter,
+    ]);
     const handleSwitchWorkspace = useCallback(async (workspaceId) => {
         if (!workspaceId || workspaceActionBusy)
             return;
+        if (workflowManagerHasUnsavedChanges && !workflowDiscardBypassRef.current) {
+            setPendingWorkflowDiscardAction(() => () => { void handleSwitchWorkspace(workspaceId); });
+            return;
+        }
         setWorkspaceActionError('');
         setWorkspaceActionBusy(true);
         try {
@@ -2005,7 +2487,7 @@ export function StandaloneLayout(props) {
         finally {
             setWorkspaceActionBusy(false);
         }
-    }, [switchWorkspace, workspaceActionBusy, fetchTasks, openWorkspaceSetup]);
+    }, [switchWorkspace, workspaceActionBusy, fetchTasks, openWorkspaceSetup, workflowManagerHasUnsavedChanges]);
     const openTeamManagementModal = useCallback(async () => {
         setShowAccountMenu(false);
         setShowTeamManagementModal(true);
@@ -2094,6 +2576,7 @@ export function StandaloneLayout(props) {
         const hasPriorityFilter = filterPriorities.length !== priorities.length;
         const hasStatusFilter = filterStatus.length !== STATUS_OPTIONS.length;
         const hasAssigneeFilter = filterAssignees.length !== assigneeOptions.length;
+        const hasHeaderQuickFilter = taskHeaderQuickFilter !== null;
         const hasInitiativeScopeFilter = selectedPlanningInitiativeId.length > 0;
         const hasWorkstreamScopeFilter = selectedPlanningWorkstreamId.length > 0;
         return hasCategoryFilter
@@ -2101,6 +2584,7 @@ export function StandaloneLayout(props) {
             || hasPriorityFilter
             || hasStatusFilter
             || hasAssigneeFilter
+            || hasHeaderQuickFilter
             || hasInitiativeScopeFilter
             || hasWorkstreamScopeFilter;
     }, [
@@ -2115,25 +2599,41 @@ export function StandaloneLayout(props) {
         priorities.length,
         selectedPlanningInitiativeId,
         selectedPlanningWorkstreamId,
+        taskHeaderQuickFilter,
     ]);
-    const hasDocumentDropdownFilters = useMemo(() => (documentTypeFilters.length !== DOCUMENT_TYPE_FILTER_OPTIONS.length
-        || documentAttachmentFilters.length !== DOCUMENT_ATTACHMENT_FILTER_OPTIONS.length), [documentAttachmentFilters.length, documentTypeFilters.length]);
     const workspaceChromeMode = resolvedWorkspaceModule;
     const workspaceChromeDefinition = useMemo(() => getWorkspaceChromeDefinition(workspaceChromeMode), [workspaceChromeMode]);
-    const hasActiveWorkspaceFilterControls = useMemo(() => {
-        switch (workspaceChromeDefinition.filterBar.kind) {
-            case 'task-filters':
-                return hasDropdownFilters;
-            case 'document-filters':
-                return hasDocumentDropdownFilters;
-            default:
-                return false;
+    useLayoutEffect(() => {
+        if (!taskforceAgentDrawerOpen && activeTab !== 'add')
+            return;
+        const updateDrawerTop = () => {
+            const appHeader = appShellHeaderRef.current;
+            const headerBottom = appHeader
+                ? Math.ceil(appHeader.getBoundingClientRect().bottom)
+                : TASKFORCE_AGENT_DRAWER_FALLBACK_TOP;
+            setTaskforceAgentDrawerTop(Math.max(TASKFORCE_AGENT_DRAWER_FALLBACK_TOP, headerBottom));
+        };
+        updateDrawerTop();
+        window.addEventListener('resize', updateDrawerTop);
+        const appHeader = appShellHeaderRef.current;
+        const resizeObserver = typeof ResizeObserver !== 'undefined'
+            ? new ResizeObserver(updateDrawerTop)
+            : null;
+        if (resizeObserver) {
+            if (appHeader)
+                resizeObserver.observe(appHeader);
         }
-    }, [
-        hasDocumentDropdownFilters,
-        hasDropdownFilters,
-        workspaceChromeDefinition.filterBar.kind,
-    ]);
+        return () => {
+            window.removeEventListener('resize', updateDrawerTop);
+            resizeObserver?.disconnect();
+        };
+    }, [activeTab, taskforceAgentDrawerOpen]);
+    useEffect(() => {
+        if (!taskforceAgentsWorkspaceEnabled) {
+            setTaskforceAgentDrawerOpen(false);
+        }
+    }, [taskforceAgentsWorkspaceEnabled]);
+    const hasActiveWorkspaceFilterControls = workspaceChromeDefinition.moduleId === 'tasks' && hasDropdownFilters;
     // Check if any filters are set (search + dropdown filters)
     const isFiltered = hasSearchFilter || hasDropdownFilters;
     const totalActiveCount = taskScope === 'archived'
@@ -2145,11 +2645,13 @@ export function StandaloneLayout(props) {
         ? archivedScopeTasks.length
         : taskScope === 'deleted'
             ? filteredDeletedTasks.length
-            : props.filteredTasks.length;
+            : quickFilteredOpenTasks.length;
     const activeCountLabel = isFiltered ? `${visibleActiveCount}/${totalActiveCount}` : `${totalActiveCount}`;
     const activeCountTitle = isFiltered
         ? `${taskScope.charAt(0).toUpperCase() + taskScope.slice(1)} tasks matching current filters`
-        : `${taskScope.charAt(0).toUpperCase() + taskScope.slice(1)} tasks`;
+        : taskScope === 'deleted'
+            ? 'Trash tasks — automatically deleted after 90 days'
+            : `${taskScope.charAt(0).toUpperCase() + taskScope.slice(1)} tasks`;
     const shouldShowSyncStatus = runtimeMode === 'local' && isAuthenticated;
     const formatSyncTimestamp = useCallback((value) => {
         if (!value)
@@ -2164,7 +2666,9 @@ export function StandaloneLayout(props) {
     const formattedLastPushTime = useMemo(() => formatSyncTimestamp(workspaceLastPushAt), [formatSyncTimestamp, workspaceLastPushAt]);
     const rawSyncLastError = workspaceSyncError || workspaceLastErrorMessage || userGlobalSyncError || 'None';
     const workspaceSyncDiagnostics = getWorkspaceSyncDiagnostics();
-    const headerSyncPresentation = useMemo(() => resolveHeaderWorkspaceSyncPresentation({
+    const coordinatorRecoveryObligations = localCoordinatorStatus?.snapshot
+        ?.permits.recoveryObligations || 0;
+    const browserHeaderSyncPresentation = useMemo(() => resolveHeaderWorkspaceSyncPresentation({
         runtimeMode,
         isAuthenticated,
         workspaceSyncStatus,
@@ -2172,6 +2676,7 @@ export function StandaloneLayout(props) {
         workspaceSyncSummary,
         workspaceSyncRecommendedAction,
         workspaceSyncError: rawSyncLastError,
+        coordinatorRecoveryObligations,
         pushBlockedReason: workspaceSyncDiagnostics.pushBlockedReason || null,
         pullBlockedReason: workspaceSyncDiagnostics.pullBlockedReason || null,
         retryBlockedReason: workspaceSyncDiagnostics.retryBlockedReason || null
@@ -2183,13 +2688,73 @@ export function StandaloneLayout(props) {
         workspaceSyncSummary,
         workspaceSyncRecommendedAction,
         rawSyncLastError,
+        coordinatorRecoveryObligations,
         workspaceSyncDiagnostics.pushBlockedReason,
         workspaceSyncDiagnostics.pullBlockedReason,
         workspaceSyncDiagnostics.retryBlockedReason
     ]);
+    const coordinatorSyncPresentation = useMemo(() => resolveCoordinatorWorkspaceSyncPresentation(localCoordinatorStatus), [localCoordinatorStatus]);
+    const headerSyncPresentation = coordinatorSyncPresentation?.header
+        || browserHeaderSyncPresentation;
+    const effectivePendingLocalChanges = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.pendingLocalChanges
+        : workspaceSyncPendingChanges;
+    const effectiveLastPullAt = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.lastPullAt
+        : workspaceLastPullAt;
+    const effectiveLastPushAt = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.lastPushAt
+        : workspaceLastPushAt;
+    const effectiveLastSyncedAt = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.lastSyncedAt
+        : workspaceLastSuccessfulSyncAt;
+    const effectiveFormattedLastPullTime = formatSyncTimestamp(effectiveLastPullAt);
+    const effectiveFormattedLastPushTime = formatSyncTimestamp(effectiveLastPushAt);
+    const effectiveFormattedLastSyncTime = formatSyncTimestamp(effectiveLastSyncedAt);
+    const effectiveWorkspaceSyncBusy = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.busy
+        : workspaceSyncBusy;
+    const coordinatorOwnershipState = localCoordinatorStatus?.snapshot
+        ?.state.ownershipMode || null;
+    const coordinatorOwnershipMode = (coordinatorOwnershipState === 'server'
+        || coordinatorOwnershipState === 'browser-gateway') ? coordinatorOwnershipState : null;
+    const [coordinatorOwnershipTransferBusy, setCoordinatorOwnershipTransferBusy] = useState(false);
+    const coordinatorOwnershipTransferDisabled = (localCoordinatorStatus?.phase !== 'ready'
+        || !localCoordinatorStatus.snapshot
+        || localCoordinatorStatus.snapshot.state.transitionState !== 'idle'
+        || localCoordinatorStatus.snapshot.permits.active > 0
+        || coordinatorRecoveryObligations > 0);
+    const handleCoordinatorOwnershipTransfer = useCallback(async () => {
+        if (!coordinatorOwnershipMode || coordinatorOwnershipTransferBusy)
+            return;
+        setCoordinatorOwnershipTransferBusy(true);
+        try {
+            const targetMode = coordinatorOwnershipMode === 'server'
+                ? 'browser-gateway'
+                : 'server';
+            await transferLocalCoordinatorOwnership(targetMode);
+            pushNotice(targetMode === 'server'
+                ? 'The local Taskforce server now owns background synchronization.'
+                : 'This browser now owns background synchronization.', 'success');
+        }
+        catch (error) {
+            pushNotice(error instanceof Error && error.message.trim()
+                ? error.message
+                : 'Sync ownership could not be transferred.', 'error');
+        }
+        finally {
+            setCoordinatorOwnershipTransferBusy(false);
+        }
+    }, [
+        coordinatorOwnershipMode,
+        coordinatorOwnershipTransferBusy,
+        pushNotice,
+        transferLocalCoordinatorOwnership,
+    ]);
     const syncLastError = headerSyncPresentation.lastError;
     const [headerSyncStatus, setHeaderSyncStatus] = useState(headerSyncPresentation.status);
-    const syncDiagnosticsSummary = useMemo(() => buildSyncDiagnosticsSummary(workspaceSyncDiagnostics), [workspaceSyncDiagnostics]);
+    const syncDiagnosticsSummary = useMemo(() => coordinatorSyncPresentation?.diagnostics
+        || buildSyncDiagnosticsSummary({ ...workspaceSyncDiagnostics, coordinatorRecoveryObligations }), [coordinatorSyncPresentation, workspaceSyncDiagnostics, coordinatorRecoveryObligations]);
     const { syncRecentEvents, syncRecentEventsLoading, syncRecentEventsError, syncEventsListRef, loadRecentSyncEvents, } = useRecentSyncEvents({
         isOpen: showSyncStatusModal,
         workspaceId: currentWorkspaceId,
@@ -2203,7 +2768,7 @@ export function StandaloneLayout(props) {
     const shouldDelayHeaderSyncing = headerSyncPresentation.actionable
         && workspaceSyncStatus === 'syncing'
         && workspaceSyncPhase === 'active'
-        && workspaceSyncPendingChanges === 0;
+        && effectivePendingLocalChanges === 0;
     useEffect(() => {
         if (!shouldDelayHeaderSyncing) {
             setHeaderSyncStatus(headerSyncPresentation.status);
@@ -2222,16 +2787,17 @@ export function StandaloneLayout(props) {
     const referenceMismatchCount = useMemo(() => getActiveReferenceMismatchCount(syncRecentEvents), [syncRecentEvents]);
     const activeReferenceMismatchSummaries = useMemo(() => buildReferenceMismatchSummaries(syncRecentEvents), [syncRecentEvents]);
     const syncStatusMeta = useMemo(() => resolveSyncStatusMeta(headerSyncStatus), [headerSyncStatus]);
+    const headerSyncStatusMeta = useMemo(() => resolveHeaderSyncStatusMeta(headerSyncStatus, effectiveWorkspaceCloudSyncEnabled), [effectiveWorkspaceCloudSyncEnabled, headerSyncStatus]);
     const { workspaceSyncRepairBusy, workspaceSyncRepairQueued, workspaceSyncCopied, handleCopySyncDetails, handleQueueOrRunRepairSync, } = useSyncStatusActions({
         currentWorkspaceId,
         syncStatusLabel: syncStatusMeta.label,
         workspaceSyncSummary: headerSyncPresentation.summary,
         workspaceSyncRecommendedAction: headerSyncPresentation.recommendedAction,
-        formattedLastSyncTime,
-        formattedLastPullTime,
-        formattedLastPushTime,
+        formattedLastSyncTime: effectiveFormattedLastSyncTime,
+        formattedLastPullTime: effectiveFormattedLastPullTime,
+        formattedLastPushTime: effectiveFormattedLastPushTime,
         workspaceSyncDiagnostics,
-        workspaceSyncPendingChanges,
+        workspaceSyncPendingChanges: effectivePendingLocalChanges,
         syncLastError,
         workspaceSyncPhase,
         referenceMismatchCount,
@@ -2239,9 +2805,14 @@ export function StandaloneLayout(props) {
         loadRecentSyncEvents,
         pushNotice,
         resetWorkspaceSyncCursorAndPull,
-        workspaceSyncBusy,
+        workspaceSyncBusy: effectiveWorkspaceSyncBusy,
+        durableRepairQueueAvailable: coordinatorOwnershipMode === 'server',
     });
-    const syncStageLabel = useMemo(() => resolveSyncStageLabel(workspaceSyncPhase, workspaceSyncRepairBusy, workspaceSyncBusy), [workspaceSyncBusy, workspaceSyncPhase, workspaceSyncRepairBusy]);
+    const effectiveWorkspaceSyncRepairBusy = coordinatorSyncPresentation
+        ? coordinatorSyncPresentation.repairBusy
+        : workspaceSyncRepairBusy;
+    const syncStageLabel = useMemo(() => coordinatorSyncPresentation?.stage
+        || resolveSyncStageLabel(workspaceSyncPhase, workspaceSyncRepairBusy, workspaceSyncBusy), [coordinatorSyncPresentation, workspaceSyncBusy, workspaceSyncPhase, workspaceSyncRepairBusy]);
     const selectedDateObj = useMemo(() => parseDateOnlyLocal(scheduleSelectedDate) || new Date(), [scheduleSelectedDate]);
     const scheduleWeekStart = useMemo(() => startOfWeek(selectedDateObj, globalWeekStartsOn), [selectedDateObj, globalWeekStartsOn]);
     const scheduleDates = useMemo(() => {
@@ -2363,8 +2934,6 @@ export function StandaloneLayout(props) {
                     { value: 4, label: 'High', icon: 'Gauge', color: '#8b5cf6' },
                     { value: 5, label: 'Epic', icon: 'Gauge', color: '#d946ef' }
                 ];
-            case 'approach':
-                return approaches;
             case 'assignee':
                 return assigneeOptions.map((option) => ({
                     value: option.value,
@@ -2387,7 +2956,7 @@ export function StandaloneLayout(props) {
             default:
                 return activeCategories;
         }
-    }, [groupBy, activeCategories, activeTypes, priorities, approaches, assigneeOptions, scheduleColumns]);
+    }, [groupBy, activeCategories, activeTypes, priorities, assigneeOptions, scheduleColumns]);
     // === SECTION: AccountMenuControl ===
     // Not extracted: ~25 distinct props from local state would be needed.
     // References: isAuthenticated, authIdentityLabel, accountProfileSummary, runtimeLabel,
@@ -2420,21 +2989,12 @@ export function StandaloneLayout(props) {
                                     setShowAccountMenu(false);
                                 }, role: "menuitem", disabled: workspaceActionBusy, children: [_jsx(Plus, { size: 15 }), "Create Workspace"] }), workspaceActionError && (_jsx("div", { className: accountStyles.accountMenuError, children: workspaceActionError }))] })), teamManagementAccessLoading ? (_jsx("div", { className: accountStyles.accountMenuHint, children: "Resolving team management access..." })) : canOpenTeamManagement ? (_jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => { void openTeamManagementModal(); }, role: "menuitem", children: [_jsx(Users, { size: 15 }), "Team Management"] })) : teamManagementAccessError ? (_jsx("div", { className: accountStyles.accountMenuHint, children: "Team Management unavailable right now." })) : null, isAuthenticated && (_jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
                             setShowAccountMenu(false);
-                            setShowEditProfileModal(true);
-                        }, role: "menuitem", children: [_jsx(User, { size: 15 }), "Edit Profile"] })), _jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
-                            setShowAccountMenu(false);
-                            openPlansScreen();
-                        }, role: "menuitem", children: [_jsx(Layers, { size: 15 }), "Plans"] }), _jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
-                            setShowAccountMenu(false);
-                            startAccountSurfaceTiming('account_hub');
-                            setShowAccountHub(true);
-                        }, role: "menuitem", children: [_jsx(User, { size: 15 }), "Account Hub"] }), _jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
-                            setShowAccountMenu(false);
-                            setShowHelpModal(true);
-                        }, role: "menuitem", children: [_jsx(HelpCircle, { size: 15 }), "Help & Support"] }), _jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
+                            startAccountSurfaceTiming('account_settings');
+                            setShowAccountSettings(true);
+                        }, role: "menuitem", children: [_jsx(Settings, { size: 15 }), "Account Settings"] })), _jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
                             setShowAccountMenu(false);
                             setShowHelpModal(true);
-                        }, role: "menuitem", children: [_jsx(Mail, { size: 15 }), "Contact Support"] }), runtimeMode === 'local' && !isAuthenticated && !isAuthBootstrapPending && (_jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
+                        }, role: "menuitem", children: [_jsx(HelpCircle, { size: 15 }), "Help & Support"] }), runtimeMode === 'local' && !isAuthenticated && !isAuthBootstrapPending && (_jsxs("button", { className: accountStyles.accountMenuItem, onClick: () => {
                             openSharedLoginRoute('login');
                         }, role: "menuitem", children: [_jsx(User, { size: 15 }), "Sign In / Register"] })), isAuthenticated && (_jsxs("button", { className: accountStyles.accountMenuItem, onClick: async () => {
                             setShowAccountMenu(false);
@@ -2517,6 +3077,9 @@ export function StandaloneLayout(props) {
         const activeEditor = planningSecondaryEditor || planningEditor;
         if (!activeEditor || planningEditorSubmitInFlightRef.current)
             return;
+        const title = planningDraftTitle.trim();
+        if (!title)
+            return;
         planningEditorSubmitInFlightRef.current = true;
         setIsSubmittingPlanningEditor(true);
         const isSecondaryEditor = Boolean(planningSecondaryEditor);
@@ -2525,17 +3088,15 @@ export function StandaloneLayout(props) {
             if (activeEditor.entityType === 'initiative') {
                 if (activeEditor.mode === 'edit') {
                     await props.updateInitiative(activeEditor.targetId, {
-                        title: planningDraftTitle.trim() || 'Untitled Initiative',
+                        title,
                         description: planningDraftDescription.trim() || null,
-                        ownerId,
                     });
                     setPlanningDrawerDetail({ type: 'initiative', id: activeEditor.targetId });
-                    setPlanningNestedWorkstreamDetailId(null);
                     pushNotice('Initiative updated', 'success');
                 }
                 else {
                     const created = await props.createInitiative({
-                        title: planningDraftTitle.trim() || 'Untitled Initiative',
+                        title,
                         description: planningDraftDescription.trim() || null,
                         ownerId,
                     });
@@ -2545,19 +3106,16 @@ export function StandaloneLayout(props) {
                 }
             }
             else {
-                const nextInitiativeRaw = planningDraftInitiativeId.trim();
-                const resolvedInitiative = nextInitiativeRaw.length === 0
-                    ? null
-                    : resolveInitiativeReference(planningStructure.initiatives, nextInitiativeRaw);
-                if (nextInitiativeRaw.length > 0 && !resolvedInitiative) {
+                const resolvedInitiative = resolveWorkstreamCreateInitiativeId(planningStructure.allInitiatives, activeEditor.mode === 'create' ? activeEditor.initiativeId : null, planningDraftInitiativeId);
+                if (resolvedInitiative.invalid) {
                     pushNotice('Initiative not found by that reference.', 'error');
                     return;
                 }
                 const patch = {
-                    title: planningDraftTitle.trim() || 'Untitled Workstream',
+                    title,
                     description: planningDraftDescription.trim() || null,
-                    ownerId,
-                    initiativeId: resolvedInitiative?.id || null,
+                    initiativeId: resolvedInitiative.initiativeId,
+                    ...(activeEditor.mode === 'create' ? { ownerId } : {}),
                 };
                 if (activeEditor.mode === 'edit') {
                     await props.updateWorkstream(activeEditor.targetId, patch);
@@ -2605,7 +3163,7 @@ export function StandaloneLayout(props) {
         planningDraftTitle,
         planningEditor,
         planningSecondaryEditor,
-        planningStructure.initiatives,
+        planningStructure.allInitiatives,
         props,
         pushNotice,
     ]);
@@ -2653,9 +3211,193 @@ export function StandaloneLayout(props) {
         setPlanningSecondaryCollapsed(false);
         setPlanningNestedWorkstreamDetailId(workstreamId);
     }, []);
+    const handleCanonicalEntityReference = useCallback((reference) => {
+        if (reference.kind === 'initiative' || reference.kind === 'workstream') {
+            const entity = reference.kind === 'initiative'
+                ? props.initiatives.find((initiative) => initiative.referenceNumber === reference.referenceNumber)
+                : props.workstreams.find((workstream) => workstream.referenceNumber === reference.referenceNumber);
+            if (!entity) {
+                pushNotice(`${reference.token} could not be found.`, 'error');
+                return;
+            }
+            handoffTaskModalToWorkspace(() => {
+                setActiveWorkspaceModule('planning');
+                setPlanningDrawerOpen(true);
+                if (reference.kind === 'initiative')
+                    openInitiativeDetails(entity.id);
+                else
+                    openWorkstreamDetails(entity.id);
+            });
+            return;
+        }
+        const workspaceId = String(currentWorkspaceId || 'default').trim() || 'default';
+        const preview = (attachment) => {
+            dispatchPreviewContextAttachment(attachment, {
+                ownerType: 'task',
+                ownerId: editingTaskId,
+                ownerReferenceLabel: getTaskReferenceLabel(currentTask),
+                workspaceId,
+            });
+        };
+        void resolveCanonicalAttachmentReference(reference, {
+            workspaceId,
+            headers: workspaceUiStateHeaders,
+        }).then(preview).catch(() => {
+            pushNotice(`${reference.token} could not be opened.`, 'error');
+        });
+    }, [
+        currentTask,
+        currentWorkspaceId,
+        editingTaskId,
+        handoffTaskModalToWorkspace,
+        openInitiativeDetails,
+        openWorkstreamDetails,
+        props.initiatives,
+        props.workstreams,
+        pushNotice,
+        setActiveWorkspaceModule,
+        workspaceUiStateHeaders,
+    ]);
+    const taskTextReferences = useMemo(() => ({
+        ...taskReferences,
+        entityReferences: {
+            resolve: parseCanonicalEntityReference,
+            activate: handleCanonicalEntityReference,
+        },
+    }), [handleCanonicalEntityReference, taskReferences]);
+    useEffect(() => {
+        const initiativeId = String(routeQuery.get(TASK_DEEP_LINK_QUERY_KEYS.initiative) || '').trim();
+        const workstreamId = String(routeQuery.get(TASK_DEEP_LINK_QUERY_KEYS.workstream) || '').trim();
+        const documentAssetId = String(routeQuery.get(TASK_DEEP_LINK_QUERY_KEYS.document) || '').trim();
+        const imageReference = String(routeQuery.get(TASK_DEEP_LINK_QUERY_KEYS.image) || '').trim();
+        const target = initiativeId
+            ? `initiative:${initiativeId}`
+            : workstreamId
+                ? `workstream:${workstreamId}`
+                : documentAssetId
+                    ? `document:${documentAssetId}`
+                    : imageReference
+                        ? `image:${imageReference}`
+                        : '';
+        if (!target || handledEntityDeepLinkRef.current === target)
+            return;
+        if (initiativeId || workstreamId) {
+            const entity = initiativeId
+                ? props.initiatives.find((initiative) => initiative.id === initiativeId)
+                : props.workstreams.find((workstream) => workstream.id === workstreamId);
+            if (!entity)
+                return;
+            handledEntityDeepLinkRef.current = target;
+            handoffTaskModalToWorkspace(() => {
+                setActiveWorkspaceModule('planning');
+                setPlanningDrawerOpen(true);
+                if (initiativeId)
+                    openInitiativeDetails(entity.id);
+                else
+                    openWorkstreamDetails(entity.id);
+            });
+            return;
+        }
+        if (documentAssetId) {
+            if (!documentsWorkspaceEnabled)
+                return;
+            handledEntityDeepLinkRef.current = target;
+            handoffTaskModalToWorkspace(() => {
+                setRequestedDocPath(null);
+                setRequestedDocAssetId(documentAssetId);
+                setActiveWorkspaceModule('docs');
+            });
+            return;
+        }
+        if (!annotatedAttachmentsWorkspaceEnabled)
+            return;
+        handledEntityDeepLinkRef.current = target;
+        const workspaceId = String(currentWorkspaceId || 'default').trim() || 'default';
+        const query = new URLSearchParams({ workspaceId });
+        void fetch(`/api/taskforce/annotated-attachments/images/${encodeURIComponent(imageReference)}?${query.toString()}`, { credentials: 'include', headers: workspaceUiStateHeaders }).then(async (response) => {
+            if (!response.ok)
+                throw new Error('Image not found');
+            const payload = await response.json();
+            if (!payload.target?.assetId || !payload.target.path)
+                throw new Error('Image target is unavailable');
+            handoffTaskModalToWorkspace(() => {
+                const target = payload.target;
+                requestedAnnotatedTargetRef.current = target;
+                requestedAnnotatedSessionIdRef.current = null;
+                setRequestedAnnotatedTarget(target);
+                setRequestedAnnotatedSessionId(null);
+                setRequestedAnnotatedOpenVersion((current) => current + 1);
+                setActiveWorkspaceModule('annotate');
+            });
+        }).catch(() => {
+            pushNotice(`Image ${imageReference} could not be opened.`, 'error');
+        });
+    }, [
+        annotatedAttachmentsWorkspaceEnabled,
+        currentWorkspaceId,
+        documentsWorkspaceEnabled,
+        handoffTaskModalToWorkspace,
+        openInitiativeDetails,
+        openWorkstreamDetails,
+        props.initiatives,
+        props.workstreams,
+        pushNotice,
+        routeQuery,
+        setActiveWorkspaceModule,
+        workspaceUiStateHeaders,
+    ]);
+    const hydratePlanningEntity = useCallback(async (target) => {
+        const key = `${target.type}:${target.id}`;
+        setPlanningHydrationStateByEntity((current) => ({
+            ...current,
+            [key]: { status: 'loading', error: null },
+        }));
+        try {
+            await props.fetchPlanningEntityDetail(target.type, target.id);
+            setPlanningHydrationStateByEntity((current) => ({
+                ...current,
+                [key]: { status: 'ready', error: null },
+            }));
+        }
+        catch (error) {
+            setPlanningHydrationStateByEntity((current) => ({
+                ...current,
+                [key]: {
+                    status: 'error',
+                    error: error instanceof Error ? error.message : 'Failed to load the latest planning details.',
+                },
+            }));
+        }
+    }, [props.fetchPlanningEntityDetail]);
+    useEffect(() => {
+        const targets = new Map();
+        if (planningDrawerDetail?.id) {
+            targets.set(`${planningDrawerDetail.type}:${planningDrawerDetail.id}`, planningDrawerDetail);
+        }
+        if (planningNestedWorkstreamDetailId) {
+            targets.set(`workstream:${planningNestedWorkstreamDetailId}`, {
+                type: 'workstream',
+                id: planningNestedWorkstreamDetailId,
+            });
+        }
+        if (targets.size === 0)
+            return;
+        for (const target of targets.values()) {
+            void hydratePlanningEntity(target);
+        }
+    }, [
+        hydratePlanningEntity,
+        planningDrawerDetail?.id,
+        planningDrawerDetail?.type,
+        planningNestedWorkstreamDetailId,
+    ]);
     const openPlanningCreateEditor = useCallback((type, initiativeId) => {
         if (type === 'workstream' && initiativeId) {
-            openPlanningSecondaryEditor({ mode: 'create', entityType: 'workstream' }, initiativeId);
+            openPlanningSecondaryEditor({
+                mode: 'create',
+                entityType: 'workstream',
+                initiativeId,
+            }, initiativeId);
             return;
         }
         openPlanningEditor({ mode: 'create', entityType: type });
@@ -2667,30 +3409,59 @@ export function StandaloneLayout(props) {
         }
     }, [openPlanningEditor, openPlanningSecondaryEditor, planningStructure.initiativeById, selectedPlanningInitiativeId]);
     const openPlanningEditDialog = useCallback((type, id) => {
+        planningEditorSubmitInFlightRef.current = false;
+        setIsSubmittingPlanningEditor(false);
         if (type === 'initiative') {
-            const item = planningStructure.initiativeById.get(id);
+            const item = planningStructure.allInitiativeById.get(id);
             if (!item)
                 return;
+            setPlanningSecondaryEditor(null);
             setPlanningEditor({ mode: 'edit', entityType: 'initiative', targetId: id });
             setPlanningDraftTitle(item.title);
             setPlanningDraftDescription(item.description || '');
             setPlanningDraftOwner(item.ownerId ? String(item.ownerId) : '');
             setPlanningDraftInitiativeId('');
+            return;
         }
         else {
-            const item = planningStructure.workstreamById.get(id)
-                || planningStructure.standaloneWorkstreams.find((workstream) => workstream.id === id);
+            const item = planningStructure.allWorkstreamById.get(id);
             if (!item)
                 return;
-            setPlanningEditor({ mode: 'edit', entityType: 'workstream', targetId: id });
+            const isNestedDetail = planningNestedWorkstreamDetailId === id;
+            if (isNestedDetail) {
+                setPlanningEditor(null);
+                setPlanningSecondaryEditor({ mode: 'edit', entityType: 'workstream', targetId: id });
+            }
+            else {
+                setPlanningSecondaryEditor(null);
+                setPlanningEditor({ mode: 'edit', entityType: 'workstream', targetId: id });
+            }
             setPlanningDraftTitle(item.title);
             setPlanningDraftDescription(item.description || '');
             setPlanningDraftOwner(item.ownerId ? String(item.ownerId) : '');
-            const initiative = item.initiativeId ? planningStructure.initiativeById.get(item.initiativeId) || null : null;
+            const initiative = item.initiativeId ? planningStructure.allInitiativeById.get(item.initiativeId) || null : null;
             setPlanningDraftInitiativeId(initiative ? formatInitiativeReference(initiative) : '');
+            if (isNestedDetail)
+                return;
         }
         setPlanningNestedWorkstreamDetailId(null);
-    }, [planningStructure.initiativeById, planningStructure.standaloneWorkstreams, planningStructure.workstreamById]);
+    }, [planningNestedWorkstreamDetailId, planningStructure.allInitiativeById, planningStructure.allWorkstreamById]);
+    const handleChangePlanningOwner = useCallback(async (entityType, entityId, nextOwnerId) => {
+        const ownerId = nextOwnerId.trim() || null;
+        try {
+            if (entityType === 'initiative') {
+                await props.updateInitiative(entityId, { ownerId });
+            }
+            else {
+                await props.updateWorkstream(entityId, { ownerId });
+            }
+            pushNotice(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} owner updated`, 'success');
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : 'Failed to update owner.', 'error');
+            throw error;
+        }
+    }, [props, pushNotice]);
     const handleAssignInitiativeToWorkstream = useCallback(async (workstreamId, initiativeReferenceOverride) => {
         const workstream = props.workstreams.find((item) => item.id === workstreamId);
         if (!workstream) {
@@ -2704,7 +3475,7 @@ export function StandaloneLayout(props) {
                 : planningDraftInitiativeId.trim();
         const resolvedInitiative = nextInitiativeRaw.length === 0
             ? null
-            : resolveInitiativeReference(planningStructure.initiatives, nextInitiativeRaw);
+            : resolveInitiativeReference(planningStructure.allInitiatives, nextInitiativeRaw);
         if (nextInitiativeRaw.length > 0 && !resolvedInitiative) {
             pushNotice('Initiative not found by that reference.', 'error');
             return false;
@@ -2724,7 +3495,7 @@ export function StandaloneLayout(props) {
             pushNotice('Failed to set initiative.', 'error');
             return false;
         }
-    }, [planningDraftInitiativeId, planningStructure.initiatives, props, pushNotice]);
+    }, [planningDraftInitiativeId, planningStructure.allInitiatives, props, pushNotice]);
     const handleAssignTaskToWorkstream = useCallback(async (taskId, workstreamId) => {
         const task = hierarchyTaskById.get(taskId);
         if (!task) {
@@ -2745,18 +3516,10 @@ export function StandaloneLayout(props) {
             return false;
         }
         try {
-            const res = await fetch(`/api/taskforce/task/${taskId}`, {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ workstreamId: normalizedWorkstreamId })
-            });
-            if (!res.ok) {
-                const data = await res.json().catch(() => ({}));
-                pushNotice(data?.error || 'Failed to set workstream.', 'error');
+            const saved = await props.handleUpdateTask(taskId, { workstreamId: normalizedWorkstreamId });
+            if (saved === false)
                 return false;
-            }
-            await res.json().catch(() => null);
-            await fetchTasks(true);
+            await props.fetchPlanningEntities();
             pushNotice(normalizedWorkstreamId ? 'Workstream set' : 'Workstream removed', 'success');
             return true;
         }
@@ -2764,7 +3527,7 @@ export function StandaloneLayout(props) {
             pushNotice('Failed to set workstream.', 'error');
             return false;
         }
-    }, [fetchTasks, hierarchyTaskById, planningStructure.initiativeById, planningStructure.workstreamById, pushNotice]);
+    }, [hierarchyTaskById, planningStructure.initiativeById, planningStructure.workstreamById, props, pushNotice]);
     const handleAttachTaskToWorkstreamByReference = useCallback(async (workstreamId, taskReference) => {
         const needle = taskReference.trim();
         if (!needle) {
@@ -2787,7 +3550,7 @@ export function StandaloneLayout(props) {
             pushNotice('Enter a workstream reference.', 'error');
             return false;
         }
-        const initiative = planningStructure.initiativeById.get(initiativeId);
+        const initiative = planningStructure.allInitiativeById.get(initiativeId);
         if (!initiative) {
             pushNotice('Initiative not found.', 'error');
             return false;
@@ -2801,7 +3564,7 @@ export function StandaloneLayout(props) {
             return false;
         }
         return handleAssignInitiativeToWorkstream(matchedWorkstream.id, formatInitiativeReference(initiative));
-    }, [handleAssignInitiativeToWorkstream, planningStructure.initiativeById, props.workstreams, pushNotice]);
+    }, [handleAssignInitiativeToWorkstream, planningStructure.allInitiativeById, props.workstreams, pushNotice]);
     const getPlanningContextAttachmentDraft = useCallback((entityType, entityId) => {
         const key = `${entityType}:${entityId}`;
         const draft = planningContextAttachmentDraftsRef.current.get(key);
@@ -2865,12 +3628,21 @@ export function StandaloneLayout(props) {
             pushNotice(`${unavailableLabel} is not available in this build yet.`, 'error');
             return;
         }
+        if (resolvedWorkspaceModule === 'workflowManager'
+            && nextModule !== 'workflowManager'
+            && workflowManagerHasUnsavedChanges
+            && !workflowDiscardBypassRef.current) {
+            setPendingWorkflowDiscardAction(() => () => handleModuleChange(nextModuleId));
+            return;
+        }
         clearTaskOriginWorkspaceModule();
         setActiveWorkspaceModule(nextModule);
     }, [
         clearTaskOriginWorkspaceModule,
         pushNotice,
+        resolvedWorkspaceModule,
         setActiveWorkspaceModule,
+        workflowManagerHasUnsavedChanges,
         workspaceModules,
     ]);
     const handlePlanningToolToggle = useCallback(() => {
@@ -2905,13 +3677,87 @@ export function StandaloneLayout(props) {
         setImageTrayOpen((current) => !current);
     }, [resolvedWorkspaceModule, setActiveWorkspaceModule]);
     const handleAgentTrayToggle = useCallback(() => {
-        if (resolvedWorkspaceModule !== 'agents') {
-            setActiveWorkspaceModule('agents');
+        if (resolvedWorkspaceModule !== 'aiProfiles') {
+            setActiveWorkspaceModule('aiProfiles');
             setAgentTrayOpen(true);
             return;
         }
         setAgentTrayOpen((current) => !current);
     }, [resolvedWorkspaceModule, setActiveWorkspaceModule]);
+    const handleTaskforceAgentRosterTrayToggle = useCallback(() => {
+        if (resolvedWorkspaceModule !== 'taskforceAgents') {
+            setActiveWorkspaceModule('taskforceAgents');
+            setTaskforceAgentRosterTrayOpen(true);
+            return;
+        }
+        setTaskforceAgentRosterTrayOpen((current) => !current);
+    }, [resolvedWorkspaceModule, setActiveWorkspaceModule]);
+    const handleWorkflowLibraryTrayToggle = useCallback(() => {
+        if (resolvedWorkspaceModule !== 'workflowManager') {
+            setActiveWorkspaceModule('workflowManager');
+            setWorkflowLibraryTrayOpen(true);
+            return;
+        }
+        setWorkflowLibraryTrayOpen((current) => !current);
+    }, [resolvedWorkspaceModule, setActiveWorkspaceModule]);
+    const handleCloseTaskforceAgentDrawer = useCallback(() => {
+        setTaskforceAgentDrawerOpen(false);
+        setTaskforceAgentsLaunchContext(null);
+        setTaskforceAgentDrawerHeaderContent(null);
+    }, []);
+    const handleAskTaskforceAgentForTask = useCallback((task) => {
+        if (!workspaceFeatureAccess[TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY]?.allowed) {
+            pushNotice('Taskforce Agents are unavailable for this workspace.', 'error');
+            return;
+        }
+        const taskReference = getTaskReferenceLabel(task) || task.id;
+        setTaskforceAgentsLaunchContext({
+            taskId: task.id,
+            taskReference,
+            taskTitle: task.title,
+        });
+        setTaskforceAgentPanelCollapsed(false);
+        setTaskforceAgentDrawerOpen(true);
+        setTaskModalFullscreen(false);
+    }, [
+        pushNotice,
+        workspaceFeatureAccess,
+    ]);
+    const handleOpenTaskforceAgentDrawer = useCallback(() => {
+        if (currentTask && editingTaskId) {
+            handleAskTaskforceAgentForTask(currentTask);
+            return;
+        }
+        if (!workspaceFeatureAccess[TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY]?.allowed) {
+            pushNotice('Taskforce Agents are unavailable for this workspace.', 'error');
+            return;
+        }
+        setTaskforceAgentsLaunchContext(null);
+        setTaskforceAgentPanelCollapsed(false);
+        setTaskforceAgentDrawerOpen(true);
+    }, [
+        currentTask,
+        editingTaskId,
+        handleAskTaskforceAgentForTask,
+        pushNotice,
+        workspaceFeatureAccess,
+    ]);
+    const handleOpenTaskforceAgentConversation = useCallback((agentId) => {
+        const normalizedAgentId = String(agentId || '').trim();
+        if (!normalizedAgentId)
+            return;
+        handleRememberTaskforceAgentSelection({
+            agentId: normalizedAgentId,
+            conversationId: taskforceAgentConversationByAgentId[normalizedAgentId] || null,
+        });
+        setTaskforceAgentsLaunchContext(null);
+        setTaskforceAgentPanelCollapsed(false);
+        setTaskforceAgentDrawerOpen(true);
+    }, [handleRememberTaskforceAgentSelection, taskforceAgentConversationByAgentId]);
+    const handleOpenTaskforceAgentTaskContext = useCallback((taskId) => {
+        handleOpenTaskById(taskId);
+        setTaskModalFullscreen(false);
+    }, [handleOpenTaskById]);
     const handleBackToTaskFromAnnotatedAttachment = useCallback((taskId) => {
         clearTaskOriginWorkspaceModule();
         setActiveWorkspaceModule('tasks');
@@ -2923,12 +3769,17 @@ export function StandaloneLayout(props) {
         handleOpenTaskById(taskId);
     }, [clearTaskOriginWorkspaceModule, handleOpenTaskById, setActiveWorkspaceModule]);
     const handleAnnotatedAttachmentOpenTarget = useCallback((target, options) => {
+        const sessionId = options?.sessionId ?? null;
+        requestedAnnotatedTargetRef.current = target;
+        requestedAnnotatedSessionIdRef.current = sessionId;
         setRequestedAnnotatedTarget(target);
-        setRequestedAnnotatedSessionId(options?.sessionId ?? null);
+        setRequestedAnnotatedSessionId(sessionId);
         setRequestedAnnotatedOpenVersion((current) => current + 1);
         setActiveWorkspaceModule('annotate');
     }, [setActiveWorkspaceModule]);
     const handleAnnotatedAttachmentContextChange = useCallback(({ target, sessionId }) => {
+        requestedAnnotatedTargetRef.current = target;
+        requestedAnnotatedSessionIdRef.current = sessionId;
         setRequestedAnnotatedTarget((current) => {
             if (!current && !target)
                 return current;
@@ -2946,6 +3797,41 @@ export function StandaloneLayout(props) {
         });
         setRequestedAnnotatedSessionId((current) => (current === sessionId ? current : sessionId));
     }, []);
+    const handleDocumentScrollChange = useCallback((docId, scrollTop) => {
+        const normalizedDocId = docId.trim();
+        const normalizedScrollTop = Math.max(0, Math.round(scrollTop));
+        if (!normalizedDocId)
+            return;
+        setDocumentScrollByDocId((current) => {
+            if (current[normalizedDocId] === normalizedScrollTop)
+                return current;
+            return withBoundedRecordEntry(current, normalizedDocId, normalizedScrollTop);
+        });
+    }, []);
+    const handleDocumentListScrollChange = useCallback((scrollTop) => {
+        const normalizedScrollTop = Math.max(0, Math.round(scrollTop));
+        setDocumentListScrollTop((current) => (current === normalizedScrollTop ? current : normalizedScrollTop));
+    }, []);
+    const handleAnnotatedViewportChange = useCallback((contextKey, viewport) => {
+        const normalizedContextKey = contextKey.trim();
+        if (!normalizedContextKey)
+            return;
+        const normalizedViewport = {
+            zoomLevel: Math.min(4, Math.max(0.25, viewport.zoomLevel)),
+            scrollLeft: Math.max(0, Math.round(viewport.scrollLeft)),
+            scrollTop: Math.max(0, Math.round(viewport.scrollTop)),
+        };
+        setAnnotatedViewportByContextKey((current) => {
+            const currentViewport = current[normalizedContextKey];
+            if (currentViewport
+                && currentViewport.zoomLevel === normalizedViewport.zoomLevel
+                && currentViewport.scrollLeft === normalizedViewport.scrollLeft
+                && currentViewport.scrollTop === normalizedViewport.scrollTop) {
+                return current;
+            }
+            return withBoundedRecordEntry(current, normalizedContextKey, normalizedViewport);
+        });
+    }, []);
     const sortOptions = useMemo(() => [
         { value: 'created', label: t('standalone.sortCreated') },
         { value: 'updated', label: t('standalone.sortUpdated') },
@@ -2994,59 +3880,73 @@ export function StandaloneLayout(props) {
         cycleEmptyColumnVisibility,
         emptyColumnMode,
     ]);
-    const universalFilterActions = useMemo(() => [{
-            key: 'filter-toggle',
-            icon: _jsx(Filter, { size: 16 }),
-            title: t('standalone.toggleFilters'),
-            onClick: () => setShowFilters(!showFilters),
-            active: showFilters,
-            className: hasActiveWorkspaceFilterControls ? styles.filterGlow : '',
-        }], [hasActiveWorkspaceFilterControls, setShowFilters, showFilters]);
-    const workspaceFilterBar = useMemo(() => {
-        switch (workspaceChromeDefinition.filterBar.kind) {
-            case 'task-filters':
-                return (_jsx(FilterToolbar, { categoryFilterOptions: categoryFilterOptions, typeFilterOptions: typeFilterOptions, priorities: priorities, taxonomyDisplayLabels: taxonomyDisplayLabels, filterCategories: filterCategories, setFilterCategories: setFilterCategories, filterTypes: filterTypes, setFilterTypes: setFilterTypes, filterPriorities: filterPriorities, setFilterPriorities: setFilterPriorities, filterStatus: filterStatus, setFilterStatus: setFilterStatus, filterAssignees: filterAssignees, setFilterAssignees: setFilterAssignees, assigneeOptions: assigneeOptions, initiativeFilterOptions: initiativeFilterOptions, selectedInitiativeId: selectedPlanningInitiativeId, setSelectedInitiativeId: handleInitiativeFilterChange, workstreamFilterOptions: workstreamFilterOptions, selectedWorkstreamId: selectedPlanningWorkstreamId, setSelectedWorkstreamId: handleWorkstreamFilterChange, taskScope: taskScope, setTaskScope: setTaskScope, showArchive: showArchive, setShowArchive: setShowArchive, fetchArchive: fetchArchive, onDeleteAllDeleted: () => {
-                        const deletedCount = deletedScopeAllTasks.length;
-                        if (deletedCount === 0)
-                            return;
-                        const confirmed = window.confirm(`Permanently delete ${deletedCount} deleted task${deletedCount === 1 ? '' : 's'}? This cannot be undone.`);
-                        if (!confirmed)
-                            return;
-                        void handleEmptyDeletedTasks();
-                    }, clearFilters: () => {
-                        clearFilters();
-                        setSelectedPlanningInitiativeId('');
-                        setSelectedPlanningWorkstreamId('');
-                    } }));
-            case 'document-filters':
-                return (_jsx(DocumentFilterToolbar, { typeFilters: documentTypeFilters, setTypeFilters: setDocumentTypeFilters, attachmentFilters: documentAttachmentFilters, setAttachmentFilters: setDocumentAttachmentFilters, clearFilters: () => {
-                        setDocumentTypeFilters(DOCUMENT_TYPE_FILTER_OPTIONS.map((option) => option.value));
-                        setDocumentAttachmentFilters(DOCUMENT_ATTACHMENT_FILTER_OPTIONS.map((option) => option.value));
-                    } }));
-            case 'empty':
-            default:
-                return _jsx(EmptyWorkspaceFilterBar, {});
+    const taskFilterActions = useMemo(() => {
+        if (workspaceChromeDefinition.moduleId !== 'tasks')
+            return [];
+        return [
+            {
+                key: 'filter-toggle',
+                icon: _jsx(Filter, { size: 16 }),
+                title: t('standalone.toggleFilters'),
+                onClick: () => setShowFilters(!showFilters),
+                active: showFilters,
+                ariaExpanded: showFilters,
+                ariaControls: 'task-workspace-filters',
+                className: hasActiveWorkspaceFilterControls ? styles.filterGlow : '',
+            },
+        ];
+    }, [
+        hasActiveWorkspaceFilterControls,
+        setShowFilters,
+        showFilters,
+        workspaceChromeDefinition.moduleId,
+    ]);
+    const universalAgentActions = useMemo(() => {
+        const actions = [];
+        if (taskforceAgentsWorkspaceEnabled) {
+            actions.push({
+                key: 'ask-agent',
+                icon: _jsx(Bot, { size: 16 }),
+                title: taskforceAgentDrawerOpen ? 'Close Taskforce Agent' : 'Ask Taskforce Agent',
+                onClick: taskforceAgentDrawerOpen ? handleCloseTaskforceAgentDrawer : handleOpenTaskforceAgentDrawer,
+                active: taskforceAgentDrawerOpen,
+            });
         }
+        return actions;
+    }, [
+        handleCloseTaskforceAgentDrawer,
+        handleOpenTaskforceAgentDrawer,
+        taskforceAgentDrawerOpen,
+        taskforceAgentsWorkspaceEnabled,
+    ]);
+    const taskFilterBar = useMemo(() => {
+        return (_jsx(FilterToolbar, { id: "task-workspace-filters", categoryFilterOptions: categoryFilterOptions, typeFilterOptions: typeFilterOptions, priorities: priorities, taxonomyDisplayLabels: taxonomyDisplayLabels, filterCategories: filterCategories, setFilterCategories: setFilterCategories, filterTypes: filterTypes, setFilterTypes: setFilterTypes, filterPriorities: filterPriorities, setFilterPriorities: setFilterPriorities, filterStatus: filterStatus, setFilterStatus: setFilterStatus, filterAssignees: filterAssignees, setFilterAssignees: setFilterAssignees, assigneeOptions: assigneeOptions, initiativeFilterOptions: initiativeFilterOptions, selectedInitiativeId: selectedPlanningInitiativeId, setSelectedInitiativeId: handleInitiativeFilterChange, workstreamFilterOptions: workstreamFilterOptions, selectedWorkstreamId: selectedPlanningWorkstreamId, setSelectedWorkstreamId: handleWorkstreamFilterChange, taskScope: taskScope, setTaskScope: setTaskScope, showArchive: showArchive, setShowArchive: setShowArchive, clearFiltersDisabled: !hasSearchFilter
+                && !hasDropdownFilters
+                && sortBy === 'created'
+                && props.sortOrder === 'desc', clearFilters: () => {
+                clearFilters();
+                clearTaskHeaderQuickFilter();
+                setSelectedPlanningInitiativeId('');
+                setSelectedPlanningWorkstreamId('');
+            } }));
     }, [
         assigneeOptions,
         categoryFilterOptions,
         clearFilters,
-        deletedScopeAllTasks.length,
-        documentAttachmentFilters,
-        documentTypeFilters,
         filterAssignees,
         filterCategories,
         filterPriorities,
         filterStatus,
         filterTypes,
+        hasDropdownFilters,
+        hasSearchFilter,
         handleInitiativeFilterChange,
         handleWorkstreamFilterChange,
         initiativeFilterOptions,
         priorities,
+        props.sortOrder,
         selectedPlanningInitiativeId,
         selectedPlanningWorkstreamId,
-        setDocumentAttachmentFilters,
-        setDocumentTypeFilters,
         setFilterAssignees,
         setFilterCategories,
         setFilterPriorities,
@@ -3056,14 +3956,13 @@ export function StandaloneLayout(props) {
         setSelectedPlanningWorkstreamId,
         setShowArchive,
         setTaskScope,
+        sortBy,
+        clearTaskHeaderQuickFilter,
         showArchive,
         taskScope,
         taxonomyDisplayLabels,
         typeFilterOptions,
         workstreamFilterOptions,
-        workspaceChromeDefinition.filterBar.kind,
-        fetchArchive,
-        handleEmptyDeletedTasks,
     ]);
     const universalDisplayActions = useMemo(() => {
         const actions = [{
@@ -3075,8 +3974,8 @@ export function StandaloneLayout(props) {
             }];
         return actions;
     }, [
-        zenMode,
         setZenMode,
+        zenMode,
     ]);
     const headerSectionRegistry = useMemo(() => ({
         search: (_jsx(WorkspaceHeaderSearch, { value: searchQuery, placeholder: t('standalone.searchPlaceholder'), active: hasSearchFilter, onChange: setSearchQuery, onClear: () => setSearchQuery(''), clearTitle: t('standalone.clearSearchTitle') })),
@@ -3105,52 +4004,206 @@ export function StandaloneLayout(props) {
         'add-document': null,
     }), [openAddTaskModal]);
     const workspaceToolRail = useMemo(() => {
+        const workspaceToolButtonClass = `${shellStyles.workspaceToolButton} tf-control-icon tf-control-icon-quiet`;
+        const workspaceToolButtonActiveClass = `${workspaceToolButtonClass} tf-control-icon-active`;
         const moduleIcons = {
             tasks: _jsx(ClipboardCheck, { size: 18 }),
+            planning: _jsx(Layers, { size: 18 }),
             docs: _jsx(FileText, { size: 18 }),
             annotate: _jsx(Image, { size: 18 }),
-            workflows: _jsx(Workflow, { size: 18 }),
-            agents: _jsx(Bot, { size: 18 }),
+            workflowManager: _jsx(Workflow, { size: 18 }),
+            taskforceAgents: _jsx(Bot, { size: 18 }),
+            aiProfiles: _jsx(Users, { size: 18 }),
         };
-        const trayButtonDisabledClass = shellStyles.workspaceToolButtonDisabled || '';
         const workspaceTrayButton = (() => {
+            if (resolvedWorkspaceModule === 'planning') {
+                return _jsx("span", { className: shellStyles.workspaceToolButton, "aria-hidden": "true" });
+            }
             if (resolvedWorkspaceModule === 'docs') {
-                return (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${documentTrayOpen ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: handleDocumentTrayToggle, title: documentTrayOpen ? 'Collapse document tray' : 'Document tray', "aria-label": documentTrayOpen ? 'Collapse document tray' : 'Document tray', children: documentTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Folder, { size: 18 }) }));
+                return (_jsx("button", { type: "button", className: documentTrayOpen ? workspaceToolButtonActiveClass : workspaceToolButtonClass, onClick: handleDocumentTrayToggle, title: documentTrayOpen ? 'Collapse document tray' : 'Document tray', "aria-label": documentTrayOpen ? 'Collapse document tray' : 'Document tray', children: documentTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Folder, { size: 18 }) }));
             }
             if (resolvedWorkspaceModule === 'annotate') {
-                return (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${imageTrayOpen ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: handleImageTrayToggle, title: imageTrayOpen ? 'Collapse image tray' : 'Image tray', "aria-label": imageTrayOpen ? 'Collapse image tray' : 'Image tray', children: imageTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Folder, { size: 18 }) }));
+                return (_jsx("button", { type: "button", className: imageTrayOpen ? workspaceToolButtonActiveClass : workspaceToolButtonClass, onClick: handleImageTrayToggle, title: imageTrayOpen ? 'Collapse image tray' : 'Image tray', "aria-label": imageTrayOpen ? 'Collapse image tray' : 'Image tray', children: imageTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Folder, { size: 18 }) }));
+            }
+            if (resolvedWorkspaceModule === 'aiProfiles') {
+                return (_jsx("button", { type: "button", className: agentTrayOpen ? workspaceToolButtonActiveClass : workspaceToolButtonClass, onClick: handleAgentTrayToggle, title: agentTrayOpen ? 'Collapse AI Profile tray' : 'MCP settings tray', "aria-label": agentTrayOpen ? 'Collapse AI Profile tray' : 'MCP settings tray', children: agentTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Plug, { size: 18 }) }));
             }
-            if (resolvedWorkspaceModule === 'agents') {
-                return (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${agentTrayOpen ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: handleAgentTrayToggle, title: agentTrayOpen ? 'Collapse agent tray' : 'MCP settings tray', "aria-label": agentTrayOpen ? 'Collapse agent tray' : 'MCP settings tray', children: agentTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Plug, { size: 18 }) }));
+            if (resolvedWorkspaceModule === 'taskforceAgents') {
+                return (_jsx("button", { type: "button", className: taskforceAgentRosterTrayOpen ? workspaceToolButtonActiveClass : workspaceToolButtonClass, onClick: handleTaskforceAgentRosterTrayToggle, title: taskforceAgentRosterTrayOpen ? 'Collapse builder library' : 'Builder library', "aria-label": taskforceAgentRosterTrayOpen ? 'Collapse builder library' : 'Builder library', children: taskforceAgentRosterTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Users, { size: 18 }) }));
             }
-            if (resolvedWorkspaceModule === 'workflows') {
-                return (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${trayButtonDisabledClass}`.trim(), title: "Workflow tray coming soon", "aria-label": "Workflow tray coming soon", disabled: true, children: _jsx(Workflow, { size: 18 }) }));
+            if (resolvedWorkspaceModule === 'workflowManager') {
+                return (_jsx("button", { type: "button", className: workflowLibraryTrayOpen ? workspaceToolButtonActiveClass : workspaceToolButtonClass, onClick: handleWorkflowLibraryTrayToggle, title: workflowLibraryTrayOpen ? 'Collapse workflow library' : 'Workflow library', "aria-label": workflowLibraryTrayOpen ? 'Collapse workflow library' : 'Workflow library', children: workflowLibraryTrayOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(Workflow, { size: 18 }) }));
             }
-            return (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${(resolvedWorkspaceModule === 'tasks' && planningDrawerOpen) ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: handlePlanningToolToggle, title: resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? 'Collapse planning trays' : 'Planning', "aria-label": resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? 'Collapse planning trays' : 'Planning', children: resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(NotebookTabs, { size: 18 }) }));
+            return (_jsx("button", { ref: planningDrawerLauncherRef, type: "button", className: resolvedWorkspaceModule === 'tasks' && planningDrawerOpen
+                    ? workspaceToolButtonActiveClass
+                    : workspaceToolButtonClass, onClick: handlePlanningToolToggle, title: resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? 'Collapse planning trays' : 'Planning', "aria-label": resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? 'Collapse planning trays' : 'Planning', children: resolvedWorkspaceModule === 'tasks' && planningDrawerOpen ? _jsx(ChevronLeft, { size: 18 }) : _jsx(NotebookTabs, { size: 18 }) }));
         })();
-        return (_jsxs("aside", { className: shellStyles.workspaceToolRail, "aria-label": "Workspace tools", children: [_jsxs("div", { className: shellStyles.workspaceToolRailMain, children: [workspaceTrayButton, _jsx("div", { className: shellStyles.workspaceToolRailDivider }), workspaceToolModules.map((module) => (_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${resolvedWorkspaceModule === module.id ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: () => handleModuleChange(module.id), title: module.label, "aria-label": module.label, children: moduleIcons[module.id] }, module.id)))] }), _jsxs("div", { className: shellStyles.workspaceToolRailBottom, children: [_jsx("div", { className: shellStyles.workspaceToolRailDivider }), _jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} ${activeTab === 'settings' ? shellStyles.workspaceToolButtonActive : ''}`.trim(), onClick: () => {
+        return (_jsxs("aside", { className: `${shellStyles.workspaceToolRail} ${shellStyles.workspaceToolRailLeft}`, "aria-label": "Workspace tools", children: [_jsxs("div", { className: shellStyles.workspaceToolRailMain, children: [workspaceTrayButton && (_jsxs(_Fragment, { children: [workspaceTrayButton, _jsx("div", { className: shellStyles.workspaceToolRailDivider })] })), workspaceToolModules.map((module) => (_jsx("button", { type: "button", className: resolvedWorkspaceModule === module.id
+                                ? workspaceToolButtonActiveClass
+                                : workspaceToolButtonClass, onClick: () => handleModuleChange(module.id), title: module.label, "aria-label": module.label, children: moduleIcons[module.id] }, module.id)))] }), _jsxs("div", { className: shellStyles.workspaceToolRailBottom, children: [_jsx("div", { className: shellStyles.workspaceToolRailDivider }), _jsx("button", { type: "button", className: activeTab === 'settings'
+                                ? workspaceToolButtonActiveClass
+                                : workspaceToolButtonClass, onClick: () => {
+                                if (resolvedWorkspaceModule === 'workflowManager' && workflowManagerHasUnsavedChanges && !workflowDiscardBypassRef.current) {
+                                    setPendingWorkflowDiscardAction(() => () => {
+                                        setSettingsSection('general');
+                                        setActiveTab('settings');
+                                    });
+                                    return;
+                                }
                                 setSettingsSection('general');
                                 setActiveTab('settings');
                             }, title: "Workspace Settings", "aria-label": "Workspace Settings", children: _jsx(Settings, { size: 18 }) })] })] }));
-    }, [activeTab, agentTrayOpen, documentTrayOpen, handleAgentTrayToggle, handleDocumentTrayToggle, handleImageTrayToggle, handleModuleChange, handlePlanningToolToggle, imageTrayOpen, planningDrawerOpen, resolvedWorkspaceModule, setSettingsSection, setActiveTab, workspaceToolModules]);
+    }, [activeTab, agentTrayOpen, documentTrayOpen, handleAgentTrayToggle, handleDocumentTrayToggle, handleImageTrayToggle, handleModuleChange, handlePlanningToolToggle, handleTaskforceAgentRosterTrayToggle, handleWorkflowLibraryTrayToggle, imageTrayOpen, planningDrawerOpen, resolvedWorkspaceModule, setSettingsSection, setActiveTab, taskforceAgentRosterTrayOpen, workflowLibraryTrayOpen, workflowManagerHasUnsavedChanges, workspaceToolModules]);
     const [planningDrawerPortalElement, setPlanningDrawerPortalElement] = useState(null);
     const setPlanningDrawerPortalRef = useCallback((node) => {
         setPlanningDrawerPortalElement(node);
     }, []);
-    const planningDrawerNode = (_jsx(PlanningDrawer, { open: planningDrawerOpen, leftOffset: WORKSPACE_TOOL_RAIL_WIDTH, initiatives: planningStructure.initiatives, standaloneWorkstreams: planningStructure.standaloneWorkstreams, allStandaloneWorkstreams: planningStructure.allStandaloneWorkstreams, activeInitiativeId: selectedPlanningInitiativeId, activeWorkstreamId: selectedPlanningWorkstreamId, expandedInitiativeIds: expandedPlanningInitiativeIds, detail: planningDrawerItem, editor: planningEditor, secondaryPane: planningSecondaryPane, currentWorkspaceId: currentWorkspaceId, assigneeOptions: assigneeOptions.map((option) => ({
+    const hydratePlanningWorkspaceEntity = useCallback((entityType, entityId) => hydratePlanningEntity({ type: entityType, id: entityId }), [hydratePlanningEntity]);
+    const createPlanningWorkspaceEntity = useCallback(async (entityType, input) => {
+        const title = input.title.trim();
+        if (!title)
+            throw new Error(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} title is required.`);
+        try {
+            if (entityType === 'initiative') {
+                const created = await props.createInitiative({
+                    title,
+                    description: input.description?.trim() || null,
+                    ownerId: input.ownerId?.trim() || null,
+                });
+                pushNotice('Initiative created', 'success');
+                return { id: created.id };
+            }
+            const created = await props.createWorkstream({
+                title,
+                description: input.description?.trim() || null,
+                ownerId: input.ownerId?.trim() || null,
+                initiativeId: input.initiativeId?.trim() || null,
+            });
+            pushNotice('Workstream created', 'success');
+            return { id: created.id };
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : 'Failed to create planning item.', 'error');
+            throw error;
+        }
+    }, [props.createInitiative, props.createWorkstream, pushNotice]);
+    const updatePlanningWorkspaceEntity = useCallback(async (entityType, entityId, input) => {
+        const title = input.title.trim();
+        if (!title)
+            throw new Error(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} title is required.`);
+        try {
+            const patch = { title, description: input.description?.trim() || null };
+            if (entityType === 'initiative') {
+                await props.updateInitiative(entityId, patch);
+                pushNotice('Initiative updated', 'success');
+                return;
+            }
+            await props.updateWorkstream(entityId, patch);
+            pushNotice('Workstream updated', 'success');
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : 'Failed to update planning item.', 'error');
+            throw error;
+        }
+    }, [props.updateInitiative, props.updateWorkstream, pushNotice]);
+    const reorderPlanningWorkstreamTasks = useCallback(async (workstreamId, taskIds) => {
+        try {
+            await props.reorderWorkstreamTasks(workstreamId, taskIds);
+        }
+        catch (error) {
+            pushNotice(error instanceof Error ? error.message : 'Failed to reorder workstream tasks.', 'error');
+            throw error;
+        }
+    }, [props.reorderWorkstreamTasks, pushNotice]);
+    const planningWorkspaceModel = useMemo(() => ({
+        initiatives: planningStructure.allInitiatives,
+        standaloneWorkstreams: planningStructure.allStandaloneWorkstreams,
+        assigneeOptions,
+        currentOwnerId: normalizedAuthUserId === 'anonymous' ? null : normalizedAuthUserId,
+        currentWorkspaceId,
+        theme: currentTheme,
+        taskReferences,
+        loadState: props.planningLoadState,
+        hydrationStateByEntity: planningHydrationStateByEntity,
+        hydrateEntity: hydratePlanningWorkspaceEntity,
+        retry: () => { void props.fetchPlanningEntities(); },
+        openTask: handleOpenTaskById,
+        setTaskStatus: handleSetPlanningTaskStatus,
+        setTaskAssignee: handleChangePlanningTaskAssignee,
+        linkOptions: planningLinkOptions,
+        assignWorkstreamToInitiative: handleAssignInitiativeToWorkstream,
+        assignTaskToWorkstream: handleAssignTaskToWorkstream,
+        attachWorkstreamToInitiative: handleAttachWorkstreamToInitiativeByReference,
+        attachTaskToWorkstream: handleAttachTaskToWorkstreamByReference,
+        archiveEntity: handleArchivePlanningEntity,
+        unarchiveEntity: handleUnarchivePlanningEntity,
+        changeOwner: handleChangePlanningOwner,
+        createEntity: createPlanningWorkspaceEntity,
+        updateEntity: updatePlanningWorkspaceEntity,
+        addContextFile: handleAddPlanningContextFile,
+        removeContextFile: handleRemovePlanningContextFile,
+        updateContextCaption: handleUpdatePlanningContextCaption,
+        showTaskCardStatusLabel,
+        taskArrangeMode: planningTaskArrangeMode,
+        setTaskArrangeMode: setPlanningTaskArrangeMode,
+        reorderWorkstreamTasks: reorderPlanningWorkstreamTasks,
+    }), [
+        currentWorkspaceId,
+        currentTheme,
+        handleChangePlanningOwner,
+        handleAssignInitiativeToWorkstream,
+        handleAssignTaskToWorkstream,
+        handleAttachTaskToWorkstreamByReference,
+        handleAttachWorkstreamToInitiativeByReference,
+        handleArchivePlanningEntity,
+        handleUnarchivePlanningEntity,
+        createPlanningWorkspaceEntity,
+        handleAddPlanningContextFile,
+        handleOpenTaskById,
+        handleRemovePlanningContextFile,
+        handleSetPlanningTaskStatus,
+        handleChangePlanningTaskAssignee,
+        handleUpdatePlanningContextCaption,
+        hydratePlanningWorkspaceEntity,
+        assigneeOptions,
+        normalizedAuthUserId,
+        planningStructure.allInitiatives,
+        planningStructure.allStandaloneWorkstreams,
+        planningLinkOptions,
+        planningHydrationStateByEntity,
+        props.fetchPlanningEntities,
+        props.planningLoadState,
+        showTaskCardStatusLabel,
+        planningTaskArrangeMode,
+        reorderPlanningWorkstreamTasks,
+        taskReferences,
+        updatePlanningWorkspaceEntity,
+    ]);
+    const planningDrawerNode = (_jsx(PlanningDrawer, { open: planningDrawerOpen, leftOffset: WORKSPACE_TOOL_RAIL_WIDTH, returnFocusRef: planningDrawerLauncherRef, theme: currentTheme, initiatives: planningWorkspaceModel.initiatives, standaloneWorkstreams: planningWorkspaceModel.standaloneWorkstreams, planningLoadState: planningWorkspaceModel.loadState, onRetryPlanning: planningWorkspaceModel.retry, taskScope: taskScope, activeInitiativeId: selectedPlanningInitiativeId, activeWorkstreamId: selectedPlanningWorkstreamId, navigatorSort: planningNavigatorSort, navigatorSortReady: layoutUiStateReady, onNavigatorSortChange: setPlanningNavigatorSort, taskArrangeMode: planningTaskArrangeMode, onTaskArrangeModeChange: setPlanningTaskArrangeMode, onReorderWorkstreamTasks: reorderPlanningWorkstreamTasks, planningFavorites: layoutUiStateReady ? planningFavorites : [], onTogglePlanningFavorite: (favorite) => {
+            setPlanningFavorites((current) => togglePlanningFavorite(current, favorite));
+        }, favoritesSectionCollapsed: planningFavoritesSectionCollapsed, initiativesSectionCollapsed: planningInitiativesSectionCollapsed, workstreamsSectionCollapsed: planningWorkstreamsSectionCollapsed, onToggleFavoritesSection: () => setPlanningFavoritesSectionCollapsed((current) => !current), onToggleInitiativesSection: () => setPlanningInitiativesSectionCollapsed((current) => !current), onToggleWorkstreamsSection: () => setPlanningWorkstreamsSectionCollapsed((current) => !current), expandedInitiativeIds: expandedPlanningInitiativeIds, detail: planningDrawerItem, editor: planningEditor, secondaryEditor: planningSecondaryEditor, secondaryPane: planningSecondaryPane, primaryHydrationState: primaryPlanningHydrationState, secondaryHydrationState: secondaryPlanningHydrationState, onRetryPrimaryHydration: planningDrawerDetail
+            ? () => { void hydratePlanningEntity(planningDrawerDetail); }
+            : undefined, onRetrySecondaryHydration: planningNestedWorkstreamDetailId
+            ? () => { void hydratePlanningEntity({ type: 'workstream', id: planningNestedWorkstreamDetailId }); }
+            : undefined, onWidthChange: setPlanningDrawerWidthPx, currentWorkspaceId: currentWorkspaceId, currentOwnerId: normalizedAuthUserId === 'anonymous' ? '' : normalizedAuthUserId, linkOptions: planningLinkOptions, showTaskCardStatusLabel: showTaskCardStatusLabel, assigneeOptions: assigneeOptions.map((option) => ({
             value: String(option.value),
             label: option.label,
+            icon: option.icon,
+            color: option.color,
             kind: option.kind,
+            avatarUrl: option.avatarUrl ?? null,
+            avatarRevision: option.avatarRevision ?? null,
+            avatarUpdatedAt: option.avatarUpdatedAt ?? null,
             username: option.username ?? null,
+            surfaceType: option.surfaceType ?? null,
+            providerMetadata: option.providerMetadata ?? null,
             archivedAt: option.archivedAt ?? null
         })), draftInitiativeSummary: planningDraftInitiativeSummary, draftTitle: planningDraftTitle, draftDescription: planningDraftDescription, draftOwner: planningDraftOwner, draftInitiativeId: planningDraftInitiativeId, onChangeDraftTitle: setPlanningDraftTitle, onChangeDraftDescription: setPlanningDraftDescription, onChangeDraftOwner: setPlanningDraftOwner, onChangeDraftInitiativeId: setPlanningDraftInitiativeId, onCollapseTreePane: () => setPlanningTreeCollapsed(true), onExpandTreePane: () => setPlanningTreeCollapsed(false), onCollapsePrimaryPane: () => setPlanningPrimaryCollapsed(true), onExpandPrimaryPane: () => setPlanningPrimaryCollapsed(false), onCollapseSecondaryPane: () => setPlanningSecondaryCollapsed(true), onExpandSecondaryPane: () => setPlanningSecondaryCollapsed(false), onBackFromSecondary: () => {
             planningEditorSubmitInFlightRef.current = false;
             setIsSubmittingPlanningEditor(false);
             setPlanningSecondaryEditor(null);
             setPlanningNestedWorkstreamDetailId(null);
-        }, treeCollapsed: planningTreeCollapsed, primaryCollapsed: planningPrimaryCollapsed, secondaryCollapsed: planningSecondaryCollapsed, onCancelEditor: closePlanningEditor, onSubmitEditor: submitPlanningEditor, isSubmittingEditor: isSubmittingPlanningEditor, onCreateInitiative: () => openPlanningCreateEditor('initiative'), onCreateWorkstream: () => openPlanningCreateEditor('workstream'), onCreateTaskInWorkstream: openAddTaskModalForWorkstream, onCreateWorkstreamInInitiative: (initiativeId) => openPlanningCreateEditor('workstream', initiativeId), onAssignInitiativeToWorkstream: handleAssignInitiativeToWorkstream, onOpenTaskById: handleOpenTaskById, onRemoveTaskFromWorkstream: (taskId) => {
-            void handleAssignTaskToWorkstream(taskId, null);
-        }, onAttachTaskToWorkstreamByReference: handleAttachTaskToWorkstreamByReference, onAttachWorkstreamToInitiativeByReference: handleAttachWorkstreamToInitiativeByReference, onAddPlanningContextFile: handleAddPlanningContextFile, onRemovePlanningContextFile: handleRemovePlanningContextFile, onUpdatePlanningContextCaption: handleUpdatePlanningContextCaption, onToggleInitiative: togglePlanningInitiative, onSelectInitiative: selectPlanningInitiative, onSelectWorkstream: selectPlanningWorkstream, onOpenInitiativeDetails: openInitiativeDetails, onOpenWorkstreamDetails: openWorkstreamDetails, onOpenNestedWorkstreamDetails: openNestedWorkstreamDetails, onEditInitiative: (initiativeId) => openPlanningEditDialog('initiative', initiativeId), onEditWorkstream: (workstreamId) => openPlanningEditDialog('workstream', workstreamId), onArchiveInitiative: (initiativeId) => {
+        }, treeCollapsed: planningTreeCollapsed, primaryCollapsed: planningPrimaryCollapsed, secondaryCollapsed: planningSecondaryCollapsed, onCancelEditor: closePlanningEditor, onCancelSecondaryEditor: closePlanningSecondaryEditor, onSubmitEditor: submitPlanningEditor, isSubmittingEditor: isSubmittingPlanningEditor, onCreateInitiative: () => openPlanningCreateEditor('initiative'), onCreateWorkstream: () => openPlanningCreateEditor('workstream'), onCreateTaskInWorkstream: openAddTaskModalForWorkstream, onCreateWorkstreamInInitiative: (initiativeId) => openPlanningCreateEditor('workstream', initiativeId), onAssignInitiativeToWorkstream: handleAssignInitiativeToWorkstream, onOpenTaskById: planningWorkspaceModel.openTask, onSetTaskStatus: handleSetPlanningTaskStatus, onChangeTaskAssignee: handleChangePlanningTaskAssignee, onArchivePlanningTask: handleArchivePlanningTask, onArchiveResolvedWorkstream: handleArchiveResolvedWorkstream, onArchiveResolvedInitiative: handleArchiveResolvedInitiative, taskReferences: taskReferences, onAssignTaskToWorkstream: handleAssignTaskToWorkstream, onAttachTaskToWorkstreamByReference: handleAttachTaskToWorkstreamByReference, onAttachWorkstreamToInitiativeByReference: handleAttachWorkstreamToInitiativeByReference, onAddPlanningContextFile: handleAddPlanningContextFile, onRemovePlanningContextFile: handleRemovePlanningContextFile, onUpdatePlanningContextCaption: handleUpdatePlanningContextCaption, onToggleInitiative: togglePlanningInitiative, onSelectInitiative: selectPlanningInitiative, onSelectWorkstream: selectPlanningWorkstream, onOpenInitiativeDetails: openInitiativeDetails, onOpenWorkstreamDetails: openWorkstreamDetails, onOpenNestedWorkstreamDetails: openNestedWorkstreamDetails, onEditInitiative: (initiativeId) => openPlanningEditDialog('initiative', initiativeId), onEditWorkstream: (workstreamId) => openPlanningEditDialog('workstream', workstreamId), onChangePlanningOwner: handleChangePlanningOwner, onArchiveInitiative: (initiativeId) => {
             void props.archiveInitiative(initiativeId).then(() => {
                 pushNotice('Initiative archived', 'success');
             }).catch((error) => {
@@ -3185,123 +4238,125 @@ export function StandaloneLayout(props) {
     const workspacePrimaryAction = workspaceChromeDefinition.primaryAction
         ? primaryActionRegistry[workspaceChromeDefinition.primaryAction]
         : null;
-    return (_jsxs("div", { className: `${shellStyles.standaloneWrapper} ${zenMode ? styles.zenModeEnabled : ''}`, "data-theme": currentTheme, children: [_jsx(AppShellHeader, { projectName: projectName, currentWorkspaceId: currentWorkspaceId, runtimeMode: runtimeMode, theme: currentTheme, onBrandClick: handleOpenKanbanFromBrand, meta: (_jsxs(_Fragment, { children: [_jsx("span", { className: styles.taskCountBadge, title: activeCountTitle, children: activeCountLabel }), normalizedAuthUserId && normalizedAuthUserId !== 'anonymous' && (_jsxs(_Fragment, { children: [_jsxs("span", { className: styles.taskCountBadge, title: "Tasks assigned to me", children: [_jsx(User, { size: 13, className: styles.taskCountBadgeIcon, "aria-hidden": "true" }), assignedTaskCount] }), _jsxs("span", { className: `${styles.taskCountBadge} ${assignedOverdueTaskCount > 0 ? styles.taskCountBadgeAlert : ''}`.trim(), title: "Tasks overdue", children: [_jsx(ClockAlert, { size: 13, className: styles.taskCountBadgeIcon, "aria-hidden": "true" }), assignedOverdueTaskCount] })] })), shouldShowSyncStatus && (_jsx("button", { className: "tf-control-icon", onClick: openSyncStatusModal, title: `Sync manager: ${syncStatusMeta.label} | Last success: ${formattedLastSyncTime}`, style: {
-                                marginLeft: '6px',
-                                height: '24px',
-                                width: '24px',
-                                padding: 0,
-                                borderRadius: '999px',
-                                border: `1px solid ${syncStatusMeta.border}`,
-                                background: syncStatusMeta.background,
-                                color: syncStatusMeta.color,
-                                display: 'inline-flex',
-                                alignItems: 'center',
-                                justifyContent: 'center'
-                            }, children: syncStatusMeta.icon === 'off' ? (_jsx(CloudOff, { size: 16 })) : (_jsx(Cloud, { size: 16 })) }))] })), actions: (_jsxs(_Fragment, { children: [isPlansScreen && (_jsxs(_Fragment, { children: [isAuthenticated && accountProfileSummary?.stripeCustomerId && (_jsx("button", { className: "tf-control-icon", onClick: () => { void handleOpenBillingPortal(); }, title: "Manage billing", disabled: billingActionBusy, children: "Manage billing" })), _jsx("button", { className: "tf-control-icon", onClick: () => {
-                                        if (hasActiveCommercialEntitlement) {
-                                            void handlePlansBack();
-                                            return;
-                                        }
-                                        closePlansScreen();
-                                    }, title: hasActiveCommercialEntitlement ? 'Continue to Taskforce' : 'Back', disabled: plansNavigationBusy, children: hasActiveCommercialEntitlement ? 'Take Me to Taskforce' : 'Back' })] })), !isPlansScreen && (_jsxs(_Fragment, { children: [workspaceHeaderSections, workspacePrimaryAction] })), _jsx(WorkspaceHeaderActions, { actions: universalDisplayActions }), !isPlansScreen && _jsx(WorkspaceHeaderActions, { actions: universalFilterActions }), accountMenuControl] })) }), _jsx(TopNoticeLayer, { notice: uiNotice, onDismiss: clearNotice }), authBlocked && (_jsx("div", { className: authStyles.authBlockedBanner, children: "Authentication required for this environment. Use the Account menu to sign in." })), !isPlansScreen && showFilters && workspaceFilterBar, isPlansScreen ? (_jsx("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent} ${styles.appScrollbar} tf-scrollbar`, style: {
-                    position: 'relative',
-                    display: 'flex',
-                    flex: 1,
-                    minHeight: 0,
-                    overflowY: 'auto',
-                    overflowX: 'hidden',
-                    scrollbarGutter: 'stable',
-                    background: 'var(--surface-page)'
-                }, children: _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(PlansPage, { ...props, currentTheme: currentTheme, projectName: projectName, currentWorkspaceId: currentWorkspaceId, authUserId: authUserId, apiBaseUrl: apiBaseUrl, connectedEnvironmentSource: props.config?.cloudAuthBaseUrl || props.config?.apiBaseUrl || '', resolveCloudAuthUrl: resolveCloudAuthUrl, embedded: true, shellOwnsScroll: true, onAccountProfileSummaryChange: applyPlansAccountProfileSummary, onContinueToTaskforce: handlePlansBack, continueBusy: plansNavigationBusy }) }) })) : resolvedWorkspaceModule === 'docs' && documentsWorkspaceEnabled ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(DocumentWorkspaceShell, { tasks: tasks, runtimeMode: runtimeMode, apiBaseUrl: props.config?.apiBaseUrl || '', cloudAuthBaseUrl: props.config?.cloudAuthBaseUrl || '', typeFilters: documentTypeFilters, attachmentFilters: documentAttachmentFilters, onTypeFiltersChange: setDocumentTypeFilters, onAttachmentFiltersChange: setDocumentAttachmentFilters, documentTrayOpen: documentTrayOpen, onCloseDocumentTray: () => setDocumentTrayOpen(false), requestedDocPath: requestedDocPath, requestedDocAssetId: requestedDocAssetId, onRequestedDocHandled: () => {
-                                setRequestedDocPath(null);
-                                setRequestedDocAssetId(null);
-                            }, onBackToTask: handleBackToTaskFromDocument, enableTaskGeneration: true }) })] })) : resolvedWorkspaceModule === 'annotate' && annotatedAttachmentsWorkspaceEnabled ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(AnnotatedAttachmentWorkspaceShell, { runtimeMode: runtimeMode, apiBaseUrl: props.config?.apiBaseUrl || '', cloudAuthBaseUrl: props.config?.cloudAuthBaseUrl || '', workspaceId: currentWorkspaceId, sessionLoadReady: annotatedWorkspaceReady, requestedTarget: requestedAnnotatedTarget, requestedSessionId: requestedAnnotatedSessionId, requestedOpenVersion: requestedAnnotatedOpenVersion, imageTrayOpen: imageTrayOpen, onCloseImageTray: () => setImageTrayOpen(false), resolveTaskReferenceLabel: resolveAnnotatedTaskReferenceLabel, resolveImageReferenceLabel: resolveAnnotatedImageReferenceLabel, onOpenTarget: handleAnnotatedAttachmentOpenTarget, onContextChange: handleAnnotatedAttachmentContextChange, onBackToTask: handleBackToTaskFromAnnotatedAttachment }) })] })) : resolvedWorkspaceModule === 'workflows' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(WorkflowsModule, { availableWorkflows: availableWorkflows, availableEnvironments: availableEnvironments, exportEnvironment: exportEnvironment, exportWorkflowsPath: props.exportWorkflowsPath, exportingResource: exportingResource, exportResult: exportResult, onExportEnvironmentChange: props.setExportEnvironment, onExportWorkflows: onExportWorkflows, onRefreshWorkflows: fetchWorkflows, onFetchWorkflowTemplate: props.fetchWorkflowTemplate, onFetchWorkflowOverrideNames: props.fetchWorkflowOverrideNames, onSaveWorkflowTemplateDraft: props.saveWorkflowTemplateDraft, onResetWorkflowTemplateDraft: props.resetWorkflowTemplateDraft }) })] })) : resolvedWorkspaceModule === 'agents' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(AgentsModule, { workspaceId: currentWorkspaceId, cloudAuthConfigured: cloudAuthConfigured, authSessionResolved: authSessionResolved, isAuthenticated: isAuthenticated, cloudAiProfileSeatUsage: accountProfileSummary?.aiProfileSeatUsage ?? null, agentTrayOpen: agentTrayOpen, onCloseAgentTray: () => setAgentTrayOpen(false), mcpSettingsNode: _jsx(TaskSettings, { settingsModel: {
-                                    ...settingsModel,
-                                    initialSection: 'mcp',
-                                    onOpenCloudAuth: openSharedLoginRoute
-                                }, renderMode: "mcp-only" }) }) })] })) : (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent} `, style: {
-                    position: 'relative',
-                    opacity: props.loadingTasks ? 0.7 : 1,
-                    transition: 'opacity 0.2s ease, padding 220ms cubic-bezier(0.4, 0, 0.2, 1)',
-                    display: 'flex',
-                    flex: 1,
-                    minHeight: 0,
-                    paddingLeft: planningDrawerOpen
-                        ? `${WORKSPACE_TOOL_RAIL_WIDTH + planningDrawerWidthPx + WORKSPACE_CONTENT_GUTTER}px`
-                        : `${WORKSPACE_TOOL_RAIL_WIDTH + WORKSPACE_CONTENT_GUTTER}px`,
-                    paddingRight: (groupBy === 'schedule' && scheduleSidebarOpen) ? `${SCHEDULE_SIDEBAR_WIDTH_PX}px` : 0
-                }, children: [workspaceToolRail, _jsx("div", { ref: setPlanningDrawerPortalRef, style: {
-                            position: 'absolute',
-                            inset: 0,
-                            zIndex: 35,
-                            pointerEvents: 'none',
-                        } }), _jsxs("div", { style: { position: 'relative', width: '100%', minWidth: 0, flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column', overflow: 'hidden' }, children: [props.loadingTasks && boardVisibleTasks.length > 0 && (_jsx("div", { className: styles.boardRefreshIndicator, "aria-live": "polite", "aria-label": "Refreshing tasks", children: _jsx(Loader2, { size: 14, className: styles.spinner }) })), _jsx(TaskKanban, { tasks: scopedBoardVisibleTasks, allTasks: scopedKanbanAllTasks, columns: kanbanColumns, groupBy: groupBy, scheduleDates: scheduleDates, searchQuery: searchQuery, filterCategories: filterCategories, filterTypes: filterTypes, filterPriorities: filterPriorities, filterStatus: filterStatus, filterAssignees: filterAssignees, filtersReady: hasInitedFilters, assigneeOptions: assigneeOptions, scheduleFilteredTaskIds: Array.from(scheduleFilteredTaskIds), copiedId: copiedId, taxonomies: taxonomies, types: activeTypes, priorities: priorities, onUpdateTask: handleUpdateTask, onTaskClick: (task) => handleEdit(task), onOpenTaskById: handleOpenTaskById, onCopyId: handleCopyId, onToggleInProgress: handleToggleInProgress, onToggleReview: handleToggleReview, onToggleComplete: handleToggleComplete, onToggleCancel: handleToggleCancel, onSetStatus: handleSetStatus, onArchiveTask: handleArchiveTask, onAddTaskToColumn: handleAddTaskToColumn, showTaskCardStatusLabel: showTaskCardStatusLabel, onScheduleDaySelected: (dateOnly) => {
-                                    setScheduleSelectedDate(dateOnly);
-                                    const parsed = parseDateOnlyLocal(dateOnly);
-                                    if (parsed) {
-                                        setScheduleCalendarMonth(`${parsed.getFullYear()}-${String(parsed.getMonth() + 1).padStart(2, '0')}`);
-                                    }
-                                }, persistedScrollLeft: groupBy === 'schedule' ? scheduleScrollLeft : undefined, onScrollLeftChange: (scrollLeft) => {
-                                    if (groupBy !== 'schedule')
-                                        return;
-                                    setScheduleScrollLeft(scrollLeft);
-                                }, emptyColumnMode: emptyColumnMode, categories: activeCategories, compressed: compressedCards, readOnlyMode: taskScope === 'deleted' ? 'deleted' : taskScope === 'archived' ? 'archived' : null, recentlyChangedTaskIds: props.recentlyChangedTaskIds, sortBy: sortBy, sortOrder: props.sortOrder, planningDropTargets: planningDrawerPortalElement
-                                    ? createPortal(planningDrawerNode, planningDrawerPortalElement)
-                                    : null, onAssignTaskToWorkstream: handleAssignTaskToWorkstream, onAssignWorkstreamToInitiative: handleAssignInitiativeToWorkstream, workstreams: props.workstreams, initiatives: props.initiatives, onUnarchive: (taskId) => {
-                                    if (taskScope === 'deleted') {
+    const taskforceAgentDrawerNode = taskforceAgentDrawerOpen ? (_jsx("div", { className: `${styles.taskforceAgentDrawerOverlay} ${taskforceAgentPanelCollapsed ? styles.taskforceAgentDrawerOverlayCollapsed : ''}`.trim(), style: { top: `${taskforceAgentDrawerTop}px` }, "data-theme": currentTheme, "aria-label": "Taskforce Agent chat", children: _jsx("aside", { className: taskforceAgentPanelCollapsed
+                ? `${shellStyles.workspaceToolRail} ${shellStyles.workspaceToolRailRight}`
+                : styles.taskforceAgentDrawerPanel, children: taskforceAgentPanelCollapsed ? (_jsxs("div", { className: shellStyles.workspaceToolRailMain, children: [_jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} tf-control-icon tf-control-icon-quiet tf-control-icon-active`, onClick: () => setTaskforceAgentPanelCollapsed(false), title: "Expand agent chat", "aria-label": "Expand agent chat", children: _jsx(Bot, { size: 16 }) }), _jsx("button", { type: "button", className: `${shellStyles.workspaceToolButton} tf-control-icon tf-control-icon-quiet`, onClick: handleCloseTaskforceAgentDrawer, title: "Close agent chat", "aria-label": "Close agent chat", children: _jsx(X, { size: 16 }) })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: styles.taskforceAgentDrawerHeader, children: [taskforceAgentDrawerHeaderContent || (_jsxs("div", { className: styles.taskforceAgentDrawerHeaderFallback, children: [_jsx("span", { className: styles.taskforceAgentDrawerFallbackAvatar, "aria-hidden": "true", children: _jsx(Bot, { size: 16 }) }), _jsx("strong", { children: "Loading agent..." })] })), _jsxs("div", { className: styles.taskforceAgentDrawerHeaderActions, children: [_jsx("button", { type: "button", className: "tf-control-icon", onClick: () => setTaskforceAgentPanelCollapsed(true), title: "Collapse agent chat", "aria-label": "Collapse agent chat", children: _jsx(ChevronRight, { size: 16 }) }), _jsx("button", { type: "button", className: "tf-control-icon", onClick: handleCloseTaskforceAgentDrawer, title: "Close agent chat", "aria-label": "Close agent chat", children: _jsx(X, { size: 16 }) })] })] }), _jsx(Suspense, { fallback: _jsx("div", { className: styles.taskforceAgentDrawerLoading, children: _jsx(Loader2, { size: 18, className: styles.spinner }) }), children: _jsx(TaskforceAgentsModule, { workspaceId: currentWorkspaceId, launchContext: taskforceAgentsLaunchContext, onClearLaunchContext: handleCloseTaskforceAgentDrawer, onOpenTaskContext: handleOpenTaskforceAgentTaskContext, taskReferences: taskReferences, surface: "taskDrawer", runtimeMode: runtimeMode, cloudAuthConfigured: cloudAuthConfigured, authSessionResolved: authSessionResolved, isAuthenticated: isAuthenticated, resolveCloudAuthUrl: resolveCloudAuthUrl, theme: currentTheme, rememberedAgentId: taskforceAgentId, rememberedConversationId: taskforceAgentConversationId, rememberedConversationByAgentId: taskforceAgentConversationByAgentId, rememberedSelectionReady: uiStateReady, onRememberSelection: handleRememberTaskforceAgentSelection, onRenderDrawerHeader: handleRenderTaskforceAgentDrawerHeader }) })] })) }) })) : null;
+    return (_jsxs("div", { className: `${shellStyles.standaloneWrapper} ${zenMode ? styles.zenModeEnabled : ''}`, "data-theme": currentTheme, children: [_jsx("div", { ref: appShellHeaderRef, style: { flexShrink: 0 }, children: _jsx(AppShellHeader, { projectName: projectName, currentWorkspaceId: currentWorkspaceId, runtimeMode: runtimeMode, theme: currentTheme, onBrandClick: handleOpenKanbanFromBrand, meta: (_jsxs(_Fragment, { children: [_jsx("span", { className: styles.taskCountBadge, title: activeCountTitle, children: activeCountLabel }), normalizedAuthUserId && normalizedAuthUserId !== 'anonymous' && (_jsxs(_Fragment, { children: [_jsxs("button", { type: "button", className: `${styles.taskCountBadge} ${styles.taskCountBadgeButton} ${taskHeaderQuickFilter === 'assigned-to-me' ? styles.taskCountBadgeActive : ''}`.trim(), onClick: () => handleTaskHeaderQuickFilter('assigned-to-me'), title: taskHeaderQuickFilter === 'assigned-to-me' ? 'Clear assigned-to-me quick filter' : 'Filter to my open tasks', "aria-label": `${taskHeaderQuickFilter === 'assigned-to-me' ? 'Clear' : 'Apply'} assigned to me quick filter (${assignedTaskCount} task${assignedTaskCount === 1 ? '' : 's'})`, "aria-pressed": taskHeaderQuickFilter === 'assigned-to-me', children: [_jsx(User, { size: 13, className: styles.taskCountBadgeIcon, "aria-hidden": "true" }), assignedTaskCount] }), _jsxs("button", { type: "button", className: `${styles.taskCountBadge} ${styles.taskCountBadgeButton} ${assignedOverdueTaskCount > 0 ? styles.taskCountBadgeAlert : ''} ${taskHeaderQuickFilter === 'overdue' ? styles.taskCountBadgeActive : ''}`.trim(), onClick: () => handleTaskHeaderQuickFilter('overdue'), title: taskHeaderQuickFilter === 'overdue' ? 'Clear my-overdue-tasks quick filter' : 'Filter to my overdue tasks', "aria-label": `${taskHeaderQuickFilter === 'overdue' ? 'Clear' : 'Apply'} my overdue tasks quick filter (${assignedOverdueTaskCount} task${assignedOverdueTaskCount === 1 ? '' : 's'})`, "aria-pressed": taskHeaderQuickFilter === 'overdue', children: [_jsx(ClockAlert, { size: 13, className: styles.taskCountBadgeIcon, "aria-hidden": "true" }), assignedOverdueTaskCount] })] })), shouldShowSyncStatus && (_jsx("button", { className: "tf-control-icon", onClick: openSyncStatusModal, title: `Sync manager: ${headerSyncStatusMeta.label} | Last success: ${formattedLastSyncTime}`, style: {
+                                    marginLeft: '6px',
+                                    height: '24px',
+                                    width: '24px',
+                                    padding: 0,
+                                    borderRadius: '999px',
+                                    border: `1px solid ${headerSyncStatusMeta.border}`,
+                                    background: headerSyncStatusMeta.background,
+                                    color: headerSyncStatusMeta.color,
+                                    display: 'inline-flex',
+                                    alignItems: 'center',
+                                    justifyContent: 'center'
+                                }, children: headerSyncStatusMeta.icon === 'off' ? (_jsx(CloudOff, { size: 16 })) : (_jsx(Cloud, { size: 16 })) }))] })), actions: (_jsxs(_Fragment, { children: [isPlansScreen && (_jsxs(_Fragment, { children: [isAuthenticated && accountProfileSummary?.stripeCustomerId && (_jsx("button", { className: "tf-control-icon", onClick: () => { void handleOpenBillingPortal(); }, title: "Manage billing", disabled: billingActionBusy, children: "Manage billing" })), _jsx("button", { className: "tf-control-icon", onClick: () => {
+                                            if (hasActiveCommercialEntitlement) {
+                                                void handlePlansBack();
+                                                return;
+                                            }
+                                            closePlansScreen();
+                                        }, title: hasActiveCommercialEntitlement ? 'Continue to Taskforce' : 'Back', disabled: plansNavigationBusy, children: hasActiveCommercialEntitlement ? 'Take Me to Taskforce' : 'Back' })] })), !isPlansScreen && (_jsxs(_Fragment, { children: [workspaceHeaderSections, _jsx(WorkspaceHeaderActions, { actions: taskFilterActions }), workspacePrimaryAction] })), _jsx(WorkspaceHeaderActions, { actions: universalDisplayActions }), !isPlansScreen && _jsx(WorkspaceHeaderActions, { actions: universalAgentActions }), accountMenuControl] })) }) }), _jsx(TopNoticeLayer, { notice: activeTab === 'add' ? null : uiNotice, onDismiss: clearNotice }), _jsx(AttachmentPreviewHost, { theme: currentTheme }), authBlocked && (_jsx("div", { className: authStyles.authBlockedBanner, children: "Authentication required for this environment. Use the Account menu to sign in." })), _jsx("div", { className: `${styles.taskforceAssistantWorkspace} ${taskforceAgentDrawerOpen ? styles.taskforceAssistantWorkspaceOpen : ''} ${taskforceAgentPanelCollapsed ? styles.taskforceAssistantWorkspaceCollapsed : ''}`.trim(), children: _jsx("div", { className: styles.taskforceAssistantWorkspaceContent, children: isPlansScreen ? (_jsx("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent} ${styles.appScrollbar} tf-scrollbar`, style: {
+                            position: 'relative',
+                            display: 'flex',
+                            flex: 1,
+                            minHeight: 0,
+                            overflowY: 'auto',
+                            overflowX: 'hidden',
+                            scrollbarGutter: 'stable',
+                            background: 'var(--surface-page)'
+                        }, children: _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(PlansPage, { ...props, currentTheme: currentTheme, projectName: projectName, currentWorkspaceId: currentWorkspaceId, authUserId: authUserId, apiBaseUrl: apiBaseUrl, connectedEnvironmentSource: props.config?.cloudAuthBaseUrl || props.config?.apiBaseUrl || '', resolveCloudAuthUrl: resolveCloudAuthUrl, embedded: true, shellOwnsScroll: true, onAccountProfileSummaryChange: applyPlansAccountProfileSummary, onContinueToTaskforce: handlePlansBack, continueBusy: plansNavigationBusy }) }) })) : resolvedWorkspaceModule === 'planning' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(PlanningModule, { model: planningWorkspaceModel }) })] })) : resolvedWorkspaceModule === 'docs' && documentsWorkspaceEnabled ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(DocumentWorkspaceShell, { taskReferences: taskReferences, tasks: tasks, runtimeMode: runtimeMode, workspaceId: currentWorkspaceId, apiBaseUrl: props.config?.apiBaseUrl || '', cloudAuthBaseUrl: props.config?.cloudAuthBaseUrl || '', typeFilters: documentTypeFilters, attachmentFilters: documentAttachmentFilters, onTypeFiltersChange: setDocumentTypeFilters, onAttachmentFiltersChange: setDocumentAttachmentFilters, sortField: documentSortField, sortOrder: documentSortOrder, onSortFieldChange: setDocumentSortField, onSortOrderChange: setDocumentSortOrder, pinnedDocIds: documentPinnedDocIds, onPinnedDocIdsChange: setDocumentPinnedDocIds, searchQuery: documentSearchQuery, onSearchQueryChange: setDocumentSearchQuery, selectedDocId: documentSelectedDocId, onSelectedDocIdChange: setDocumentSelectedDocId, selectionReady: layoutUiStateReady, documentScrollByDocId: documentScrollByDocId, onDocumentScrollChange: handleDocumentScrollChange, documentListScrollTop: documentListScrollTop, onDocumentListScrollChange: handleDocumentListScrollChange, documentTrayOpen: documentTrayOpen, onCloseDocumentTray: () => setDocumentTrayOpen(false), requestedDocPath: requestedDocPath, requestedDocAssetId: requestedDocAssetId, onRequestedDocHandled: () => {
+                                        setRequestedDocPath(null);
+                                        setRequestedDocAssetId(null);
+                                    }, onBackToTask: handleBackToTaskFromDocument, enableTaskGeneration: true }) })] })) : resolvedWorkspaceModule === 'annotate' && annotatedAttachmentsWorkspaceEnabled ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(AnnotatedAttachmentWorkspaceShell, { runtimeMode: runtimeMode, apiBaseUrl: props.config?.apiBaseUrl || '', cloudAuthBaseUrl: props.config?.cloudAuthBaseUrl || '', workspaceId: currentWorkspaceId, sessionLoadReady: annotatedWorkspaceReady, requestedTarget: scopedRequestedAnnotatedTarget, requestedSessionId: scopedRequestedAnnotatedSessionId, requestedOpenVersion: requestedAnnotatedOpenVersion, imageTrayOpen: imageTrayOpen, onCloseImageTray: () => setImageTrayOpen(false), resolveTaskReferenceLabel: resolveAnnotatedTaskReferenceLabel, resolveImageReferenceLabel: resolveAnnotatedImageReferenceLabel, onOpenTarget: handleAnnotatedAttachmentOpenTarget, onContextChange: handleAnnotatedAttachmentContextChange, viewportByContextKey: annotatedViewportByContextKey, onViewportChange: handleAnnotatedViewportChange, onBackToTask: handleBackToTaskFromAnnotatedAttachment }) })] })) : resolvedWorkspaceModule === 'workflowManager' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(WorkflowManagerModule, { workspaceId: currentWorkspaceId, libraryTrayOpen: workflowLibraryTrayOpen, onCloseLibraryTray: () => setWorkflowLibraryTrayOpen(false), assigneeOptions: assigneeOptions, theme: currentTheme, onUnsavedChangesChange: setWorkflowManagerHasUnsavedChanges }) })] })) : resolvedWorkspaceModule === 'taskforceAgents' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(TaskforceAgentsModule, { workspaceId: currentWorkspaceId, taskReferences: taskReferences, agentRosterTrayOpen: taskforceAgentRosterTrayOpen, onCloseAgentRosterTray: () => setTaskforceAgentRosterTrayOpen(false), runtimeMode: runtimeMode, cloudAuthConfigured: cloudAuthConfigured, authSessionResolved: authSessionResolved, isAuthenticated: isAuthenticated, resolveCloudAuthUrl: resolveCloudAuthUrl, theme: currentTheme, rememberedAgentId: taskforceAgentId, rememberedConversationId: taskforceAgentConversationId, rememberedConversationByAgentId: taskforceAgentConversationByAgentId, rememberedSelectionReady: uiStateReady, onRememberSelection: handleRememberTaskforceAgentSelection, onOpenConversation: handleOpenTaskforceAgentConversation }) })] })) : resolvedWorkspaceModule === 'aiProfiles' ? (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent}`, style: { position: 'relative', display: 'flex', flex: 1, minHeight: 0, overflow: 'hidden', paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px` }, children: [workspaceToolRail, _jsx(Suspense, { fallback: _jsx("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', flex: 1 }, children: _jsx(Loader2, { size: 20, className: styles.spinner }) }), children: _jsx(AiProfilesModule, { workspaceId: currentWorkspaceId, runtimeMode: runtimeMode, cloudAuthConfigured: cloudAuthConfigured, authSessionResolved: authSessionResolved, isAuthenticated: isAuthenticated, cloudAiProfileSeatUsage: accountProfileSummary?.aiProfileSeatUsage ?? null, agentTrayOpen: agentTrayOpen, onCloseAgentTray: () => setAgentTrayOpen(false), resolveCloudAuthUrl: resolveCloudAuthUrl, theme: currentTheme, onNotice: pushNotice, mcpSettingsNode: _jsx(TaskSettings, { settingsModel: {
+                                            ...settingsModel,
+                                            initialSection: 'mcp',
+                                            onOpenCloudAuth: openSharedLoginRoute
+                                        }, renderMode: "mcp-only" }) }) })] })) : (_jsxs("div", { className: `${shellStyles.standalonePage} ${shellStyles.standaloneContent} `, style: {
+                            position: 'relative',
+                            opacity: props.loadingTasks ? 0.7 : 1,
+                            transition: 'opacity 0.2s ease, padding 220ms cubic-bezier(0.4, 0, 0.2, 1)',
+                            display: 'flex',
+                            flex: 1,
+                            minHeight: 0,
+                            paddingLeft: `${WORKSPACE_TOOL_RAIL_WIDTH}px`,
+                        }, children: [workspaceToolRail, _jsxs("div", { style: { position: 'relative', width: '100%', minWidth: 0, flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column', overflow: 'hidden' }, children: [showFilters && taskFilterBar, _jsxs("div", { style: {
+                                            position: 'relative',
+                                            width: '100%',
+                                            minWidth: 0,
+                                            flex: 1,
+                                            minHeight: 0,
+                                            display: 'flex',
+                                            flexDirection: 'column',
+                                            overflow: 'hidden',
+                                            transition: 'padding 220ms cubic-bezier(0.4, 0, 0.2, 1)',
+                                            paddingLeft: planningDrawerOpen
+                                                ? `${planningDrawerWidthPx + WORKSPACE_CONTENT_GUTTER}px`
+                                                : `${WORKSPACE_CONTENT_GUTTER}px`,
+                                            paddingRight: (groupBy === 'schedule' && scheduleSidebarOpen)
+                                                ? `${SCHEDULE_SIDEBAR_WIDTH_PX}px`
+                                                : 0,
+                                        }, children: [_jsx("div", { ref: setPlanningDrawerPortalRef, style: {
+                                                    position: 'absolute',
+                                                    top: 0,
+                                                    right: 0,
+                                                    bottom: 0,
+                                                    left: `-${WORKSPACE_TOOL_RAIL_WIDTH}px`,
+                                                    zIndex: 35,
+                                                    pointerEvents: 'none',
+                                                } }), props.loadingTasks && boardVisibleTasks.length > 0 && (_jsx("div", { className: styles.boardRefreshIndicator, "aria-live": "polite", "aria-label": "Refreshing tasks", children: _jsx(Loader2, { size: 14, className: styles.spinner }) })), taskScope === 'deleted' && (_jsx(TrashRestoreControls, { theme: currentTheme, selectedRecords: trashSelection.selectedRecords, matchingCount: trashSelection.matchingRecords.length, allMatchingSelected: trashSelection.allMatchingSelected, someMatchingSelected: trashSelection.someMatchingSelected, fullTrashCount: props.deletedTasks.length, onSelectAllMatching: trashSelection.selectAllMatching, onClearSelection: trashSelection.clear, onRestore: handleRestoreSelectedDeletedTasks, onEmptyEntireTrash: () => {
+                                                    const count = props.deletedTasks.length;
+                                                    if (count > 0 && window.confirm(`Permanently delete all ${count} tasks in Trash? Filters and selection do not limit this action. This cannot be undone.`)) {
+                                                        void handleEmptyDeletedTasks();
+                                                    }
+                                                } })), _jsx(TaskKanban, { tasks: scopedBoardVisibleTasks, allTasks: scopedKanbanAllTasks, columns: kanbanColumns, groupBy: groupBy, scheduleDates: scheduleDates, searchQuery: searchQuery, filterCategories: filterCategories, filterTypes: filterTypes, filterPriorities: filterPriorities, filterStatus: filterStatus, filterAssignees: filterAssignees, filtersReady: hasInitedFilters, assigneeOptions: assigneeOptions, scheduleFilteredTaskIds: scheduleFilteredTaskIdList, copiedId: copiedId, taxonomies: taxonomies, types: activeTypes, priorities: priorities, workspaceId: currentWorkspaceId, deletedTaskRecordByTaskId: deletedTaskRecordByTaskId, selectedDeletedRecordIds: trashSelection.selectedIds, onDeletedSelectionChange: trashSelection.toggle, onUpdateTask: handleUpdateTask, onTaskClick: handleEdit, taskReferences: taskTextReferences, onCopyId: handleCopyId, onToggleInProgress: handleToggleInProgress, onToggleReview: handleToggleReview, onToggleComplete: handleToggleComplete, onToggleCancel: handleToggleCancel, onSetStatus: handleSetStatus, onArchiveTask: handleArchiveTask, onAddTaskToColumn: handleAddTaskToColumn, showTaskCardStatusLabel: showTaskCardStatusLabel, onScheduleDaySelected: handleBoardScheduleDaySelected, persistedScrollLeft: groupBy === 'schedule' ? scheduleScrollLeft : undefined, onScrollLeftChange: handleBoardScrollLeftChange, emptyColumnMode: emptyColumnMode, categories: activeCategories, compressed: compressedCards, readOnlyMode: taskScope === 'deleted' ? 'deleted' : taskScope === 'archived' ? 'archived' : null, recentlyChangedTaskIds: props.recentlyChangedTaskIds, sortBy: sortBy, sortOrder: props.sortOrder, planningDropTargets: planningDrawerPortalElement
+                                                    ? createPortal(planningDrawerNode, planningDrawerPortalElement)
+                                                    : null, onAssignTaskToWorkstream: handleAssignTaskToWorkstream, onAssignWorkstreamToInitiative: handleAssignInitiativeToWorkstream, workstreams: props.workstreams, initiatives: props.initiatives, onUnarchive: handleBoardUnarchive, onDelete: handleBoardDelete }, `${groupBy}-${kanbanColumns.map(c => String(c.value)).join('|')}-${scheduleDates.mon}`), groupBy === 'schedule' && !scheduleSidebarOpen && (_jsx("button", { type: "button", className: "tf-control-icon", onClick: () => {
+                                                    setPlanningDrawerDetail(null);
+                                                    setScheduleSidebarOpen(true);
+                                                }, title: "Show Schedule Sidebar", style: {
+                                                    position: 'absolute',
+                                                    top: '10px',
+                                                    right: '10px',
+                                                    zIndex: 20,
+                                                }, children: _jsx(ChevronLeft, { size: 16 }) })), groupBy === 'schedule' && (_jsx(ScheduleSidebar, { open: scheduleSidebarOpen, onClose: () => setScheduleSidebarOpen(false), scheduleSelectedDate: scheduleSelectedDate, setScheduleSelectedDate: setScheduleSelectedDate, scheduleCalendarMonth: scheduleCalendarMonth, setScheduleCalendarMonth: setScheduleCalendarMonth, scheduleShowWeekends: scheduleShowWeekends, setScheduleShowWeekends: setScheduleShowWeekends, scheduleShowBacklog: scheduleShowBacklog, setScheduleShowBacklog: setScheduleShowBacklog, scheduleOnlyExpired: scheduleOnlyExpired, setScheduleOnlyExpired: setScheduleOnlyExpired, expiredScheduledCount: expiredScheduledCount, overdueDueCount: overdueDueCount, expiredLeafCandidates: expiredLeafCandidates, expiredRecoveryCandidates: expiredRecoveryCandidates, onMoveExpiredToSelectedWeek: handleMoveExpiredToSelectedWeek, onMoveExpiredToBacklog: handleMoveExpiredToBacklog, scheduleBulkBusy: scheduleBulkBusy, globalWeekStartsOn: globalWeekStartsOn, resolvedLocale: resolvedLocale, todayDateOnly: todayDateOnly, scheduleBaseTasks: scheduleBaseTasks, scheduleWeekStart: scheduleWeekStart, scheduleWeekLabel: scheduleWeekLabel }))] })] })] })) }) }), taskforceAgentDrawerNode && typeof document !== 'undefined'
+                ? createPortal(taskforceAgentDrawerNode, document.body)
+                : taskforceAgentDrawerNode, _jsxs(Modal, { isOpen: activeTab === 'add', onClose: handleCloseModal, title: editingTaskId ? (currentTask?.isDeleted ? 'Deleted Task' : 'Edit Task') : 'New Task', size: taskModalFullscreen ? 'full' : 'xl', theme: currentTheme, className: `${styles.taskforceTaskModalOverlay} ${taskforceAgentDrawerOpen ? styles.taskforceModalWithAssistantPanel : ''} ${taskforceAgentPanelCollapsed ? styles.taskforceModalWithAssistantPanelCollapsed : ''}`.trim(), overlayStyle: {
+                    '--taskforce-task-modal-backdrop-top': `${taskforceAgentDrawerTop}px`,
+                    '--taskforce-task-modal-backdrop-left': `${WORKSPACE_TOOL_RAIL_WIDTH}px`,
+                }, headerActions: (_jsxs(_Fragment, { children: [!editingTaskId ? (_jsxs("button", { type: "button", onClick: (event) => handleSubmit(event), disabled: loading || !title.trim(), className: styles.primaryUpdateBtn, title: t('actionHeader.addTaskTitle'), children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Plus, { size: 16 }), t('actionHeader.addTask')] })) : null, _jsx("button", { className: "tf-control-icon", onClick: () => setTaskModalFullscreen((value) => !value), title: taskModalFullscreen ? 'Exit full screen' : 'Enter full screen', "aria-label": taskModalFullscreen ? 'Exit full screen' : 'Enter full screen', children: taskModalFullscreen ? _jsx(Minimize2, { size: 18 }) : _jsx(Maximize2, { size: 18 }) })] })), draggable: !taskModalFullscreen, closeOnOverlayClick: false, children: [_jsxs("div", { className: styles.taskNoticeAnchor, children: [_jsx(TaskActionHeader, { editingTaskId: editingTaskId, loading: loading, autoSaveState: autoSaveState, title: title, status: status, onStatusChange: setStatus, showCreateSubmit: false, currentTask: currentTask, currentTaskWorkstream: currentTaskWorkstream, currentTaskInitiative: currentTaskInitiative, workstreams: props.workstreams, onWorkstreamInputChange: setWorkstreamInput, onSetWorkstreamForCurrentTask: handleSetWorkstreamForCurrentTask, handleSubmit: handleSubmit, handleCopyId: handleCopyId, copiedId: copiedId, tasks: tasks, handleToggleInProgress: handleToggleInProgress, handleToggleReview: handleToggleReview, handleToggleComplete: handleToggleComplete, handleToggleCancel: handleToggleCancel, handleSetStatus: handleSetStatus, handleArchiveTask: handleArchiveTask, handleUnarchiveTask: (taskId) => {
+                                    if (currentTask?.isDeleted) {
                                         const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
                                         if (!deletedRecord)
                                             return;
-                                        void handleRestoreDeletedTask(deletedRecord.id);
+                                        void handleRestoreDeletedTask(deletedRecord.id, deletedRecord.taskId);
                                         return;
                                     }
                                     void handleUnarchive(taskId);
-                                }, onDelete: (taskId) => {
-                                    if (taskScope === 'deleted') {
-                                        const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
-                                        if (!deletedRecord)
-                                            return;
+                                }, handleRestoreDeletedTask: currentTask?.deletedRecordId
+                                    ? (deletedRecordId) => {
+                                        const deletedRecord = props.deletedTasks.find((entry) => entry.id === deletedRecordId);
+                                        void handleRestoreDeletedTask(deletedRecordId, deletedRecord?.taskId);
+                                    }
+                                    : undefined, handlePermanentlyDeleteDeletedTask: currentTask?.deletedRecordId
+                                    ? (deletedRecordId) => {
                                         const confirmed = window.confirm('Permanently delete this task? This cannot be undone.');
                                         if (!confirmed)
                                             return;
-                                        void handlePermanentlyDeleteDeletedTask(deletedRecord.id);
-                                        return;
+                                        void handlePermanentlyDeleteDeletedTask(deletedRecordId);
+                                        resetForm();
+                                        setActiveTab('tasks');
                                     }
-                                    void handleDelete(taskId);
-                                } }, `${groupBy}-${kanbanColumns.map(c => String(c.value)).join('|')}-${scheduleDates.mon}`), groupBy === 'schedule' && !scheduleSidebarOpen && (_jsx("button", { type: "button", className: "tf-control-icon", onClick: () => {
-                                    setPlanningDrawerDetail(null);
-                                    setScheduleSidebarOpen(true);
-                                }, title: "Show Schedule Sidebar", style: {
-                                    position: 'absolute',
-                                    top: '10px',
-                                    right: '10px',
-                                    zIndex: 20,
-                                }, children: _jsx(ChevronLeft, { size: 16 }) }))] }), groupBy === 'schedule' && (_jsx(ScheduleSidebar, { open: scheduleSidebarOpen, onClose: () => setScheduleSidebarOpen(false), scheduleSelectedDate: scheduleSelectedDate, setScheduleSelectedDate: setScheduleSelectedDate, scheduleCalendarMonth: scheduleCalendarMonth, setScheduleCalendarMonth: setScheduleCalendarMonth, scheduleShowWeekends: scheduleShowWeekends, setScheduleShowWeekends: setScheduleShowWeekends, scheduleShowBacklog: scheduleShowBacklog, setScheduleShowBacklog: setScheduleShowBacklog, scheduleOnlyExpired: scheduleOnlyExpired, setScheduleOnlyExpired: setScheduleOnlyExpired, expiredScheduledCount: expiredScheduledCount, overdueDueCount: overdueDueCount, expiredLeafCandidates: expiredLeafCandidates, expiredRecoveryCandidates: expiredRecoveryCandidates, onMoveExpiredToSelectedWeek: handleMoveExpiredToSelectedWeek, onMoveExpiredToBacklog: handleMoveExpiredToBacklog, scheduleBulkBusy: scheduleBulkBusy, globalWeekStartsOn: globalWeekStartsOn, resolvedLocale: resolvedLocale, todayDateOnly: todayDateOnly, scheduleBaseTasks: scheduleBaseTasks, scheduleWeekStart: scheduleWeekStart, scheduleWeekLabel: scheduleWeekLabel }))] })), _jsxs(Modal, { isOpen: activeTab === 'add', onClose: handleCloseModal, title: editingTaskId ? (currentTask?.isDeleted ? 'Deleted Task' : 'Edit Task') : 'New Task', size: taskModalFullscreen ? 'full' : 'xl', theme: currentTheme, headerActions: (_jsx("button", { className: "tf-control-icon", onClick: () => setTaskModalFullscreen((value) => !value), title: taskModalFullscreen ? 'Exit full screen' : 'Enter full screen', "aria-label": taskModalFullscreen ? 'Exit full screen' : 'Enter full screen', children: taskModalFullscreen ? _jsx(Minimize2, { size: 18 }) : _jsx(Maximize2, { size: 18 }) })), draggable: !taskModalFullscreen, closeOnOverlayClick: false, children: [_jsx(TaskActionHeader, { editingTaskId: editingTaskId, loading: loading, autoSaveState: autoSaveState, title: title, currentTask: currentTask, currentTaskWorkstream: currentTaskWorkstream, currentTaskInitiative: currentTaskInitiative, workstreamInput: workstreamInput, onWorkstreamInputChange: setWorkstreamInput, onSetWorkstreamForCurrentTask: handleSetWorkstreamForCurrentTask, handleSubmit: handleSubmit, resetForm: resetForm, handleCopyId: handleCopyId, copiedId: copiedId, tasks: tasks, handleToggleInProgress: handleToggleInProgress, handleToggleReview: handleToggleReview, handleToggleComplete: handleToggleComplete, handleToggleCancel: handleToggleCancel, handleSetStatus: handleSetStatus, handleArchiveTask: handleArchiveTask, handleUnarchiveTask: (taskId) => {
-                            if (currentTask?.isDeleted) {
-                                const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
-                                if (!deletedRecord)
-                                    return;
-                                void handleRestoreDeletedTask(deletedRecord.id);
-                                return;
-                            }
-                            void handleUnarchive(taskId);
-                        }, handleRestoreDeletedTask: currentTask?.deletedRecordId
-                            ? (deletedRecordId) => {
-                                void handleRestoreDeletedTask(deletedRecordId);
-                            }
-                            : undefined, handlePermanentlyDeleteDeletedTask: currentTask?.deletedRecordId
-                            ? (deletedRecordId) => {
-                                const confirmed = window.confirm('Permanently delete this task? This cannot be undone.');
-                                if (!confirmed)
-                                    return;
-                                void handlePermanentlyDeleteDeletedTask(deletedRecordId);
-                                resetForm();
-                                setActiveTab('tasks');
-                            }
-                            : undefined }), _jsx(TaskForm, { editingTaskId: editingTaskId, error: error, title: title, description: description, checklistItems: checklistItems, category: category, type: type, priority: priority, complexity: complexity, manualComplexityEnabled: manualComplexityEnabled, approach: approach, assignee: assignee, scheduledDate: scheduledDate, dueDate: dueDate, workstreamInput: workstreamInput, formTaxonomies: formTaxonomies, onTaxonomyChange: (id, val) => setFormTaxonomies(prev => ({ ...prev, [id]: val })), taxonomies: taxonomies, comments: comments, newCommentText: newCommentText, contextFiles: attachments, currentWorkspaceId: currentWorkspaceId, apiBaseUrl: apiBaseUrl, descriptionFocused: descriptionFocused, showMarkdownHelp: showMarkdownHelp, showChecklist: showChecklist, checklistEnabled: checklistDropdownEnabled, showComments: showComments, categories: activeCategories, types: activeTypes, priorities: priorities, taxonomyDisplayLabels: taxonomyDisplayLabels, assigneeOptions: assigneeOptions, workstreams: props.workstreams, initiatives: props.initiatives, copiedId: copiedId, onTitleChange: setTitle, onDescriptionChange: setDescription, onChecklistItemsChange: setChecklistItems, onCategoryChange: setCategory, onTypeChange: setType, onPriorityChange: setPriority, onComplexityChange: setComplexity, onApproachChange: (val) => { setApproach(val); setFormTaxonomies(prev => ({ ...prev, approach: val })); }, onAssigneeChange: setAssignee, onScheduledDateChange: setScheduledDate, onDueDateChange: setDueDate, onWorkstreamInputChange: setWorkstreamInput, onNewCommentTextChange: setNewCommentText, onDescriptionFocusedChange: setDescriptionFocused, onShowMarkdownHelpChange: setShowMarkdownHelp, onShowChecklistChange: setShowChecklist, onShowCommentsChange: setShowComments, onOpenSettings: (section) => {
+                                    : undefined, onAskAgent: handleAskTaskforceAgentForTask }), _jsx(TopNoticeLayer, { notice: error ? { message: error, tone: 'error' } : uiNotice, onDismiss: () => {
+                                    clearTaskError();
+                                    clearNotice();
+                                }, placement: "task" })] }), _jsx(TaskForm, { editingTaskId: editingTaskId, initialActivityEntryId: props.initialActivityEntryId, title: title, description: description, checklistItems: checklistItems, category: category, type: type, priority: priority, complexity: complexity, manualComplexityEnabled: manualComplexityEnabled, assignee: assignee, scheduledDate: scheduledDate, dueDate: dueDate, formTaxonomies: formTaxonomies, onTaxonomyChange: (id, val) => setFormTaxonomies(prev => ({ ...prev, [id]: val })), taxonomies: taxonomies, comments: comments, newCommentText: newCommentText, contextFiles: attachments, currentWorkspaceId: currentWorkspaceId, currentActorId: authUserId, apiBaseUrl: apiBaseUrl, runtimeMode: runtimeMode, showImageReviews: true, descriptionFocused: descriptionFocused, showMarkdownHelp: showMarkdownHelp, checklistEnabled: checklistDropdownEnabled, categories: activeCategories, types: activeTypes, priorities: priorities, taxonomyDisplayLabels: taxonomyDisplayLabels, assigneeOptions: assigneeOptions, workstreams: props.workstreams, initiatives: props.initiatives, copiedId: copiedId, onTitleChange: setTitle, onTitleDraftChange: setTitleDraft, onDescriptionChange: setDescription, onDescriptionDraftChange: setDescriptionDraft, onChecklistItemsChange: setChecklistItems, onCategoryChange: setCategory, onTypeChange: setType, onPriorityChange: setPriority, onComplexityChange: setComplexity, onAssigneeChange: setAssignee, onScheduledDateChange: setScheduledDate, onDueDateChange: setDueDate, onNewCommentTextChange: setNewCommentText, onDescriptionFocusedChange: setDescriptionFocused, onShowMarkdownHelpChange: setShowMarkdownHelp, onOpenSettings: (section) => {
                             setSettingsSection(section);
                             setActiveTab('settings');
-                        }, onSubmit: handleSubmit, commentsEndRef: commentsEndRef, onAddComment: () => handleAddComment(newCommentText), onOpenTaskById: handleOpenTaskById, onAddContextFile: (file) => {
+                        }, onSubmit: handleSubmit, commentsEndRef: commentsEndRef, onAddComment: () => handleAddComment(newCommentText), taskReferences: taskTextReferences, onAddContextFile: (file) => {
                             updateTaskContextAttachments((current) => [...current, file]);
                         }, onRemoveContextFile: async (index) => {
                             updateTaskContextAttachments((current) => current.filter((_, i) => i !== index));
@@ -3313,12 +4368,19 @@ export function StandaloneLayout(props) {
                                     return { path: s, caption, timestamp: new Date().toISOString() };
                                 return { ...s, caption };
                             }));
+                        }, onOpenContextImage: (attachment) => {
+                            dispatchPreviewContextAttachment(attachment, {
+                                ownerType: 'task',
+                                ownerId: editingTaskId,
+                                ownerReferenceLabel: getTaskReferenceLabel(currentTask),
+                                workspaceId: currentWorkspaceId,
+                            });
                         }, onCopyId: handleCopyId, onToggleInProgress: handleToggleInProgress, onToggleReview: handleToggleReview, onToggleComplete: handleToggleComplete, onToggleCancel: handleToggleCancel, onSetStatus: handleSetStatus, onArchiveTask: handleArchiveTask, onUnarchive: (taskId) => {
                             if (currentTask?.isDeleted) {
                                 const deletedRecord = deletedTaskRecordByTaskId.get(taskId);
                                 if (!deletedRecord)
                                     return;
-                                void handleRestoreDeletedTask(deletedRecord.id);
+                                void handleRestoreDeletedTask(deletedRecord.id, deletedRecord.taskId);
                                 return;
                             }
                             void handleUnarchive(taskId);
@@ -3329,22 +4391,14 @@ export function StandaloneLayout(props) {
                     setShowHelpModal(false);
                     setActiveTab('settings');
                     setSettingsSection('general');
-                }, onOpenAccountHub: () => {
-                    setShowHelpModal(false);
-                    startAccountSurfaceTiming('account_hub');
-                    setShowAccountHub(true);
-                } }), _jsx(EditProfileModal, { isOpen: showEditProfileModal, theme: currentTheme, onClose: closeEditProfileModal, onSave: () => { void handleSaveProfile(); }, displayName: profileDisplayNameDraft, email: authEmailLabel, avatarDisplayUrl: profileAvatarDisplayUrl, accountBadgeInitial: accountBadgeInitial, saveBusy: profileSaveBusy, avatarBusy: profileAvatarBusy, saveError: profileSaveError, saveNotice: profileSaveNotice, onDisplayNameChange: setProfileDisplayNameDraft, onOpenAvatarManager: () => {
+                } }), _jsx(AccountSettingsModal, { isOpen: showAccountSettings, theme: currentTheme, displayName: profileDisplayNameDraft, email: authEmailLabel, avatarDisplayUrl: profileAvatarDisplayUrl, accountBadgeInitial: accountBadgeInitial, profileSaveBusy: profileSaveBusy, profileAvatarBusy: profileAvatarBusy, profileSaveError: profileSaveError, profileSaveNotice: profileSaveNotice, cloudAuthEnabled: cloudAuthConfigured, availableAuthProviders: availableAuthProviders, billingLoading: billingLoading, billingError: billingError, billingActionError: billingActionError, billingNotice: billingNotice, billingActionBusy: billingActionBusy, billingIntervalChoice: billingIntervalChoice, accountProfileSummary: accountProfileSummary, onClose: closeAccountSettingsModal, onSaveProfile: () => { void handleSaveProfile(); }, onDisplayNameChange: setProfileDisplayNameDraft, onOpenAvatarManager: () => {
                     setProfileSaveError(null);
                     setProfileSaveNotice(null);
                     setShowAvatarPhotoManager(true);
-                } }), _jsx(AvatarImageManagerModal, { isOpen: showAvatarPhotoManager, theme: currentTheme, title: "Edit Profile Photo", currentImageUrl: profileAvatarDisplayUrl, fallbackInitial: accountBadgeInitial, accept: PROFILE_AVATAR_ACCEPT, busy: profileAvatarBusy, hasPendingImage: Boolean(profileAvatarDraftId), canRemove: Boolean(profileAvatarDisplayUrl), error: profileSaveError, notice: profileSaveNotice, onClose: () => setShowAvatarPhotoManager(false), onApplyImage: handleProfileAvatarSelected, onRemoveImage: handleRemoveProfileAvatar, onDiscardPendingImage: handleDiscardPendingProfileAvatar }), _jsx(AccountHubModal, { isOpen: showAccountHub, theme: currentTheme, runtimeMode: runtimeMode, authRequiredForApi: authRequiredForApi, isAuthenticated: isAuthenticated, hasAuthIdentity: hasAuthIdentity, authIdentityLabel: authIdentityLabel, billingLoading: billingLoading, billingError: billingError, billingActionError: billingActionError, billingNotice: billingNotice, billingActionBusy: billingActionBusy, billingIntervalChoice: billingIntervalChoice, accountProfileSummary: accountProfileSummary, currentWorkspaceId: currentWorkspaceId, canOpenTeamManagement: canOpenTeamManagement, canManageWorkspaceSync: canManageWorkspaceSync, workspaceCloudSyncEnabled: workspaceCloudSyncEnabled, syncStatusLabel: syncStatusMeta.label, workspaceSyncError: workspaceSyncError, syncControlBusy: syncControlBusy, cloudAuthEnabled: cloudAuthConfigured, availableAuthProviders: availableAuthProviders, onFetchLoginMethods: fetchLoginMethods, onUnlinkLoginMethod: unlinkLoginMethod, onAddPassword: addPasswordToAccount, onLinkProvider: (provider) => beginOAuthLink(provider), onClose: () => setShowAccountHub(false), onOpenWorkspaceAudit: () => {
-                    setShowAccountHub(false);
-                    void openTeamManagementModal();
-                    setTeamManagementTab('audit');
-                }, onBillingIntervalChange: setBillingIntervalChoice, onRefreshBilling: () => { void loadAccountProfileSummary(); }, onUpdateInterval: () => { void handleSwitchSubscriptionInterval(); }, onManageBilling: () => { void handleOpenBillingPortal(); }, onStartCheckout: () => { void handleStartCheckout(); }, onToggleWorkspaceSync: (enabled) => { void handleWorkspaceSyncToggle(enabled); }, onOpenHelp: () => {
-                    setShowAccountHub(false);
-                    setShowHelpModal(true);
-                } }), _jsx(TeamManagementModal, { isOpen: showTeamManagementModal, theme: currentTheme, teamPlanMode: teamPlanMode, teamMgmtError: teamMgmtError, teamManagementTab: teamManagementTab, teamUsersLoading: teamUsersLoading, teamUsers: teamUsers, teamActionBusyUserId: teamActionBusyUserId, teamInviteFeedback: teamInviteFeedback, teamInviteEmail: teamInviteEmail, teamInviteRole: teamInviteRole, teamInvitePermissionMode: teamInvitePermissionMode, teamInviteBusy: teamInviteBusy, pendingInvites: pendingInvites, teamAuditLoading: teamAuditLoading, teamAuditEvents: teamAuditEvents, teamAuditPage: teamAuditPage, teamAuditPages: teamAuditPages, teamAuditHasMore: teamAuditHasMore, onClose: () => setShowTeamManagementModal(false), onOpenMembersTab: () => {
+                }, onFetchLoginMethods: fetchLoginMethods, onUnlinkLoginMethod: unlinkLoginMethod, onAddPassword: addPasswordToAccount, onChangePassword: changePassword, onLinkProvider: (provider) => beginOAuthLink(provider), onBillingIntervalChange: setBillingIntervalChoice, onRefreshBilling: () => { void loadAccountProfileSummary(); }, onUpdateInterval: () => { void handleSwitchSubscriptionInterval(); }, onManageBilling: () => { void handleOpenBillingPortal(); }, onOpenPlans: () => {
+                    setShowAccountSettings(false);
+                    void handleStartCheckout();
+                } }), _jsx(AvatarImageManagerModal, { isOpen: showAvatarPhotoManager, theme: currentTheme, title: "Edit Profile Photo", currentImageUrl: profileAvatarDisplayUrl, fallbackInitial: accountBadgeInitial, accept: PROFILE_AVATAR_ACCEPT, busy: profileAvatarBusy, hasPendingImage: Boolean(profileAvatarDraftId), canRemove: Boolean(profileAvatarDisplayUrl), error: profileSaveError, notice: profileSaveNotice, onClose: () => setShowAvatarPhotoManager(false), onApplyImage: handleProfileAvatarSelected, onRemoveImage: handleRemoveProfileAvatar, onDiscardPendingImage: handleDiscardPendingProfileAvatar }), _jsx(TeamManagementModal, { isOpen: showTeamManagementModal, theme: currentTheme, teamPlanMode: teamPlanMode, teamMgmtError: teamMgmtError, teamManagementTab: teamManagementTab, teamUsersLoading: teamUsersLoading, teamUsers: teamUsers, teamActionBusyUserId: teamActionBusyUserId, teamInviteFeedback: teamInviteFeedback, teamInviteEmail: teamInviteEmail, teamInviteRole: teamInviteRole, teamInvitePermissionMode: teamInvitePermissionMode, teamInviteBusy: teamInviteBusy, pendingInvites: pendingInvites, teamAuditLoading: teamAuditLoading, teamAuditEvents: teamAuditEvents, teamAuditPage: teamAuditPage, teamAuditPages: teamAuditPages, teamAuditHasMore: teamAuditHasMore, onClose: () => setShowTeamManagementModal(false), onOpenMembersTab: () => {
                     setTeamManagementTab('members');
                     void loadTeamUsers();
                 }, onOpenInvitesTab: () => setTeamManagementTab('invites'), onOpenAuditTab: () => {
@@ -3393,11 +4447,21 @@ export function StandaloneLayout(props) {
                         headers: teamAdminHeaders(),
                         credentials: 'include'
                     }));
-                }, onInviteEmailChange: setTeamInviteEmail, onInviteRoleChange: setTeamInviteRole, onInvitePermissionModeChange: setTeamInvitePermissionMode, onSubmitInvite: () => { void submitTeamInvite(); }, onLoadAuditPrevious: () => { void loadTeamAuditPage(teamAuditPage - 1); }, onLoadAuditNext: () => { void loadTeamAuditPage(teamAuditPage + 1); } }), _jsx(CreateWorkspaceConfirmModal, { isOpen: showCreateWorkspaceConfirm, theme: currentTheme, onClose: () => setShowCreateWorkspaceConfirm(false), onConfirm: () => openWorkspaceSetup({ intent: 'create-workspace' }) }), _jsx(SyncStatusModal, { isOpen: showSyncStatusModal, theme: currentTheme, currentWorkspaceLabel: currentWorkspaceLabel, syncStatusMeta: syncStatusMeta, workspaceCloudSyncEnabled: workspaceCloudSyncEnabled, syncControlBusy: syncControlBusy, canManageWorkspaceSync: canManageWorkspaceSync, workspaceSyncSummary: headerSyncPresentation.summary, workspaceSyncRecommendedAction: headerSyncPresentation.recommendedAction, workspaceSyncRepairBusy: workspaceSyncRepairBusy, referenceMismatchCount: referenceMismatchCount, syncStageLabel: syncStageLabel, workspaceSyncPendingChanges: workspaceSyncPendingChanges, formattedLastSyncTime: formattedLastSyncTime, formattedLastPullTime: formattedLastPullTime, formattedLastPushTime: formattedLastPushTime, syncLastError: syncLastError, workspaceSyncDiagnostics: workspaceSyncDiagnostics, activeReferenceMismatchSummaries: activeReferenceMismatchSummaries, syncDiagnosticsSummary: syncDiagnosticsSummary, syncEventRows: syncEventRows, syncEventsListRef: syncEventsListRef, workspaceSyncRepairQueued: workspaceSyncRepairQueued, workspaceSyncBusy: workspaceSyncBusy, workspaceSyncCopied: workspaceSyncCopied, runtimeMode: runtimeMode, isAuthenticated: isAuthenticated, onClose: closeSyncStatusModal, onToggleWorkspaceSync: (enabled) => {
+                }, onInviteEmailChange: setTeamInviteEmail, onInviteRoleChange: setTeamInviteRole, onInvitePermissionModeChange: setTeamInvitePermissionMode, onSubmitInvite: () => { void submitTeamInvite(); }, onLoadAuditPrevious: () => { void loadTeamAuditPage(teamAuditPage - 1); }, onLoadAuditNext: () => { void loadTeamAuditPage(teamAuditPage + 1); } }), _jsx(CreateWorkspaceConfirmModal, { isOpen: showCreateWorkspaceConfirm, theme: currentTheme, onClose: () => setShowCreateWorkspaceConfirm(false), onConfirm: () => openWorkspaceSetup({ intent: 'create-workspace' }) }), _jsx(SyncStatusModal, { isOpen: showSyncStatusModal, theme: currentTheme, currentWorkspaceLabel: currentWorkspaceLabel, syncStatus: headerSyncStatus, syncStatusMeta: syncStatusMeta, workspaceCloudSyncEnabled: effectiveWorkspaceCloudSyncEnabled, syncControlBusy: syncControlBusy, canManageWorkspaceSync: canManageWorkspaceSync, workspaceSyncSummary: headerSyncPresentation.summary, workspaceSyncRecommendedAction: headerSyncPresentation.recommendedAction, workspaceSyncRepairBusy: effectiveWorkspaceSyncRepairBusy, referenceMismatchCount: referenceMismatchCount, syncStageLabel: syncStageLabel, workspaceSyncPendingChanges: effectivePendingLocalChanges, incomingCloudChanges: coordinatorSyncPresentation?.incomingCloudChanges || 'Unknown', formattedLastSyncTime: effectiveFormattedLastSyncTime, formattedLastPullTime: effectiveFormattedLastPullTime, formattedLastPushTime: effectiveFormattedLastPushTime, syncLastError: syncLastError, activeReferenceMismatchSummaries: activeReferenceMismatchSummaries, syncDiagnosticsSummary: syncDiagnosticsSummary, syncEventRows: syncEventRows, syncEventsListRef: syncEventsListRef, workspaceSyncRepairQueued: workspaceSyncRepairQueued, workspaceSyncBusy: effectiveWorkspaceSyncBusy, workspaceSyncCopied: workspaceSyncCopied, coordinatorOwnershipMode: coordinatorOwnershipMode, coordinatorOwnershipTransferBusy: coordinatorOwnershipTransferBusy, coordinatorOwnershipTransferDisabled: coordinatorOwnershipTransferDisabled, onClose: closeSyncStatusModal, onToggleWorkspaceSync: (enabled) => {
                     void handleWorkspaceSyncToggle(enabled);
-                }, onRepairSync: handleQueueOrRunRepairSync, onCopyReport: () => { void handleCopySyncDetails(); }, onOpenLogin: () => {
-                    openSharedLoginRoute('login');
-                }, onRetrySync: () => { void retryWorkspaceCloudSync(); } }), unsavedModalOpen && createPortal(_jsx("div", { className: `${modalStyles.overlay} ${modalStyles.unsavedOverlay}`, style: { zIndex: 2000 }, children: _jsxs("div", { className: `tf-surface-modal tf-modal-shell ${modalStyles.modal} ${modalStyles.unsavedModal}`, "data-theme": currentTheme, children: [_jsx("div", { className: `tf-modal-header ${modalStyles.unsavedHeader}`, children: _jsxs("div", { className: `tf-modal-title ${modalStyles.unsavedTitle}`, children: [_jsx(AlertTriangle, { size: 20 }), "Unsaved Changes"] }) }), _jsx("div", { className: `${modalStyles.form} ${modalStyles.unsavedContent}`, children: _jsx("p", { className: modalStyles.unsavedText, children: "You have unsaved changes. Would you like to save them?" }) }), _jsxs("div", { className: `${modalStyles.formActions} ${modalStyles.unsavedActions}`, children: [_jsx("button", { className: styles.cancelBtn, onClick: () => setUnsavedModalOpen(false), title: "Close dialog and continue editing", children: "Keep Editing" }), _jsx("button", { className: styles.destructiveBtn, onClick: handleDiscard, title: "Discard unsaved changes and leave", children: "Discard" }), _jsxs("button", { className: styles.submitBtn, onClick: handleSaveAndNavigate, disabled: loading, title: "Save changes and leave", children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Save, { size: 16 }), "Save"] })] })] }) }), document.body), showFolderBrowser && createPortal(_jsx("div", { className: folderBrowserStyles.overlay, children: _jsxs("div", { className: folderBrowserStyles.browser, children: [_jsxs("div", { className: folderBrowserStyles.header, children: [_jsxs("div", { className: folderBrowserStyles.pathInfo, children: [_jsx(Folder, { size: 14 }), _jsx("span", { children: currentBrowsePath || 'Project Root' })] }), _jsxs("div", { className: folderBrowserStyles.actions, children: [currentBrowsePath && (_jsx("button", { className: styles.helpLink, onClick: () => {
+                }, onRepairSync: handleQueueOrRunRepairSync, onCopyReport: () => { void handleCopySyncDetails(); }, onRetrySync: () => {
+                    void retryWorkspaceCloudSync().catch(() => {
+                        // Coordinator status owns the durable error and retry presentation.
+                    });
+                }, onTransferCoordinatorOwnership: () => {
+                    void handleCoordinatorOwnershipTransfer();
+                } }), _jsx(DiscardChangesDialog, { isOpen: Boolean(pendingWorkflowDiscardAction), onKeepEditing: () => setPendingWorkflowDiscardAction(null), onDiscard: () => {
+                    const action = pendingWorkflowDiscardAction;
+                    setPendingWorkflowDiscardAction(null);
+                    workflowDiscardBypassRef.current = true;
+                    action?.();
+                    window.setTimeout(() => { workflowDiscardBypassRef.current = false; }, 0);
+                }, theme: currentTheme }), unsavedModalOpen && createPortal(_jsx("div", { className: `${modalStyles.overlay} ${modalStyles.unsavedOverlay}`, style: { zIndex: 2000 }, children: _jsxs("div", { className: `tf-surface-modal tf-modal-shell ${modalStyles.modal} ${modalStyles.unsavedModal}`, "data-theme": currentTheme, children: [_jsx("div", { className: `tf-modal-header ${modalStyles.unsavedHeader}`, children: _jsxs("div", { className: `tf-modal-title ${modalStyles.unsavedTitle}`, children: [_jsx(AlertTriangle, { size: 20 }), "Unsaved Changes"] }) }), _jsx("div", { className: `${modalStyles.form} ${modalStyles.unsavedContent}`, children: _jsx("p", { className: modalStyles.unsavedText, children: "You have unsaved changes. Would you like to save them?" }) }), _jsxs("div", { className: `${modalStyles.formActions} ${modalStyles.unsavedActions}`, children: [_jsx("button", { className: styles.cancelBtn, onClick: () => setUnsavedModalOpen(false), title: "Close dialog and continue editing", children: "Keep Editing" }), _jsx("button", { className: styles.destructiveBtn, onClick: handleDiscard, title: "Discard unsaved changes and leave", children: "Discard" }), _jsxs("button", { className: styles.submitBtn, onClick: handleSaveAndNavigate, disabled: loading, title: "Save changes and leave", children: [loading ? _jsx(Loader2, { size: 16, className: styles.spinner }) : _jsx(Save, { size: 16 }), "Save"] })] })] }) }), document.body), showFolderBrowser && createPortal(_jsx("div", { className: folderBrowserStyles.overlay, children: _jsxs("div", { className: folderBrowserStyles.browser, children: [_jsxs("div", { className: folderBrowserStyles.header, children: [_jsxs("div", { className: folderBrowserStyles.pathInfo, children: [_jsx(Folder, { size: 14 }), _jsx("span", { children: currentBrowsePath || 'Project Root' })] }), _jsxs("div", { className: folderBrowserStyles.actions, children: [currentBrowsePath && (_jsx("button", { className: styles.helpLink, onClick: () => {
                                                 const parts = currentBrowsePath.split('/').filter(Boolean);
                                                 parts.pop();
                                                 fetchFolders(parts.length ? parts.join('/') + '/' : '');